AI in Coding: My Two Cents

TL;DR: AI tools are a powerful productivity multiplier for experienced developers, but they are not a magic bullet. Their effectiveness depends entirely on the developer’s skill in providing clear, detailed prompts and critically evaluating the output. AI struggles with complex logical reasoning and often fails to grasp the full context of large projects. It’s a tool that amplifies skill, not a replacement for it. The key is to lead the process, break down tasks, and provide excellent instructions.

Interestingly, recent research by METR challenges some common productivity claims about AI coding tools. Their study found that experienced developers actually took 19% longer to complete tasks when using AI tools compared to working without them. This reinforces the points I make below about the critical importance of developer skill and the need for careful oversight when using these tools.


This post is my two cents on using AI for coding. It’s not a formal, rigorous study but a collection of personal opinions and reflections based on my direct experience over the last two years.

My journey, like that of many developers, started when ChatGPT was released in late 2022 and opened up new possibilities for how we write code. This is a practitioner’s view, shaped by using these tools in the trenches on real projects—from debugging legacy systems to bootstrapping greenfield applications.

Since then, I’ve made it a point to experiment widely. I have used multiple LLMs, including models from OpenAI, Anthropic, Google, Mistral, and DeepSeek. My workflow has involved various tools, from browser-based chats and GitHub Copilot to more specialized editors like Cursor and CLIs like Gemini’s. This exploration wasn’t just for curiosity; it was a necessary process to figure out what actually works and what is just hype.

I’ve applied these tools to projects of all sizes, from building small personal apps from scratch to navigating and contributing to large, existing codebases with years of technical debt.

My AI Tool Usage

I use a variety of AI tools and LLMs in my daily workflow, often running multiple models simultaneously to compare their outputs and pick the best solution. My primary tool is GitHub Copilot within Visual Studio Code, where I use models like Claude Sonnet 4 and Gemini 2.5 Pro for real-time code completion, asking questions about my codebase, and generating or editing code directly in the editor via prompts. Its strength is its immediacy—it sees the file I’m working on and provides relevant inline suggestions that speed up the most common tasks, like writing unit tests, refactoring a function into a more readable format, or generating boilerplate for a new component.

For starting small projects from scratch or when I’m already working in the terminal, I’ve found the Gemini CLI to be quite effective. It’s great for bootstrapping a new script, like a Python utility for processing a CSV file, or getting a quick, self-contained function without having to switch contexts back to the editor. This combination allows me to use AI in a way that feels natural and efficient, augmenting my existing habits rather than completely replacing them. The goal is to reduce friction, not to introduce a new, complicated step.

What I’ve Learned

The Productivity Equation: Skill as a Multiplier

For an experienced programmer, AI tools act as a powerful productivity multiplier. They automate the tedious, low-creativity tasks that consume a surprising amount of a developer’s day. This includes writing boilerplate for API endpoints, generating mocks for unit tests, converting data structures from one format to another, or even writing JSDoc comments for a function. What used to take half an hour of searching through documentation and repetitive typing might now take just a few minutes with a well-formed prompt. This isn’t just about saving time; it’s about maintaining focus and staying in a state of flow.

However, this multiplier effect is not a given. It is directly proportional to the developer’s skill—not just in coding, but in the emerging art of prompt engineering. The ability to translate a complex requirement into a clear, detailed, and unambiguous instruction for the AI is paramount. The quality of the output is a direct reflection of the quality of the input.

The Quality Control Mandate: You Are the Reviewer

Human oversight is not just recommended; it’s mandatory. AI can, and often does, produce code that is inefficient, incorrect, or insecure. I’ve seen it generate functions with subtle off-by-one errors, suggest nested loops for a task that could be done in linear time, and produce code with glaring security holes. An experienced developer can usually spot these issues during review, but the code can look deceptively correct at first glance.

Ultimately, the developer who commits the code is responsible for it, not the AI. You cannot blame your tools for a bug in production. This means every line of AI-generated code must be treated as if it were written by a new junior developer: it needs to be understood, scrutinized, and tested before it’s integrated into the codebase.

The Junior Developer’s Dilemma: A Tool for Learning, a Crutch for Growth

For junior developers, AI is a double-edged sword. On one hand, it can be an incredible learning tool, acting like a patient, 24/7 pair programmer. It can explain complex concepts, demonstrate different approaches to solving a problem, and help refactor code with detailed explanations.

On the other hand, there’s a significant risk of over-reliance. It’s tempting to simply ask the AI for the answer instead of wrestling with a problem and truly internalizing the solution. This can lead to dangerous habits, like “re-prompting instead of debugging”—a behavior that circumvents the development of fundamental debugging skills. It can create an illusion of competence, where a developer can produce a lot of code quickly but lacks the deep understanding to maintain it, fix it when it breaks, or justify their architectural choices. This creates a fragile foundation of knowledge that can crumble under the pressure of a real-world, high-stakes bug.

Key Limitations

From my experience, the main limitations of AI in coding are not about the size of the context window but about fundamental capabilities. Even as models get bigger and can “read” an entire codebase, the core challenges of comprehension and reasoning remain.

1. Limited Logical Reasoning

AI excels at pattern recognition and reproduction. Ask it to write a standard user authentication flow, and it will succeed because it has seen thousands of examples. But ask it to debug a complex algorithmic problem that requires multiple interdependent logical steps—like optimizing a recursive function to handle edge cases you haven’t explicitly mentioned—and it often falls short. It can combine familiar patterns effectively, but struggles with genuine problem-solving that requires reasoning through novel scenarios or understanding the deeper implications of design decisions. It’s more of a parrot that can repeat and combine patterns it has learned than a true innovator capable of genuine problem-solving. It doesn’t “understand” the logic; it just predicts the most probable next token based on its training data.

2. Context Handling Issues

Even models with very large context windows struggle with the complexity of a real-world codebase. Their attention is not perfect. I’ve seen them re-implement a utility function that already exists in another module because they failed to “see” it, leading to code duplication and future maintenance nightmares. They might suggest a change that looks correct in isolation but has cascading side effects that break other parts of the application because they don’t grasp the project’s architecture. The model’s context is not the same as a human developer’s holistic understanding of the project’s architecture, history, and goals.

3. Poor Handling of Ambiguity

AI struggles with vague or ambiguous prompts, often producing bad, incomplete code when requirements aren’t crystal clear. Given the limitations in logical reasoning and context handling, the AI cannot infer what you mean from incomplete information. It will make a guess based on statistical patterns, and that guess is often wrong. Unlike human developers who can ask clarifying questions or make reasonable assumptions, AI requires explicit, detailed instructions to function properly.

This means going beyond just what needs to be done. You need to specify how it should be done. For example, which libraries and versions should it use? Are there specific coding standards or design patterns that must be followed? What should the code structure look like? It’s often helpful to point it to existing, well-written code in your project as a template. The AI is a tool for execution, not for strategy, and it executes best when given a detailed blueprint.

How to Use AI Effectively

AI works best when the developer acts as an architect. You need to understand the codebase, define clear goals, and break down complex tasks into smaller, well-specified steps. The AI is your assistant that handles the tedious parts, like writing the code for each small step, but you must provide the direction and the critical thinking. It’s an iterative conversation: you prompt, review the output, critique it, identify its flaws, and re-prompt with refinements and corrections.

In the end, AI is a powerful tool that amplifies the abilities of a skilled developer. It’s not a replacement for one. It requires guidance, supervision, and a clear understanding of its limitations to be used well. It makes good developers faster, but it doesn’t make a novice an expert.


AI tools are a powerful productivity multiplier for experienced developers, but they are not a magic bullet. Their effectiveness depends entirely on the developer's skill in providing clear, detailed prompts and critically evaluating the output.

Antonio Sánchez

AI Coding

1548 Words

Jul 7, 2025