Support Through Chats

If you believe the promises made by AI tool providers, developers can increase their efficiency many times over for a small monthly fee. But is that true, or is the reality – as is so often the case – more complex than we think? In my opinion, whether a coding assistant adds little or a lot of value depends very specifically on its area of application and mode of use. “It depends,” as we techies say.

AI coding assistants can be used in a variety of ways. Many developers still rely on interacting with the LLM via chat: for example, they give ChatGPT a task and transfer the results it spits out into their codebase. Although this rather rudimentary approach does not usually lead to the best results due to a lack of context, it does allow developers to get quick results and very precise control over what is shared with the LLM and what is not.

Integrated Assistants

An alternative approach, which can be found in Github Copilot, for example, is integration into the development environment. A plugin decides specifically based on the context what information the LLM needs to provide the “right” answer to the question I haven't even asked yet.

Github's Copilot takes care of the many small tasks that would otherwise slow me down. The tool writes comments for me, creates unit tests, and saves me a lot of typing when changing function parameters. A code assistant is a blessing, especially when you lack experience with the library or programming language you are using: With the help of the assistant, I manage to write the Bash script that reads the CSV file, filters it, and then imports it into the local database. Copilot feels like a very advanced auto-complete feature: an IntelliSense that truly deserves its name.

Away from the Happy Path - the Obstacles

However, once you stray from the “happy path,” you quickly encounter obstacles that cause the assistant to stumble. In complex tasks, beyond what is found in typical “tutorials,” the stumbling block is hidden: if I ask the assistant for help with architectural design, it generates code that is neither useful nor logically correct. A simple model class is quickly created, but a sustainable feature toggle cannot be obtained from the co-pilot. What is missing is a sense of future development, the balance between solid and extensible code, and an individual approach to the specific project and customer requirements.

The Training Data is Noticeable

What is particularly striking is that the AI support only works adequately with the well-known versions of familiar libraries. It struggles with versions that were released after training and with libraries outside the mainstream.

And yet: as a daily companion, I wouldn't want to be without an integrated assistant. Simple but time-consuming tasks, such as asking the search engine how to implement an area calculation function for an octagon, are completely eliminated. And the things that you would otherwise be tempted to skip out of laziness, such as validating edge cases, Copilot does perfectly for me, as long as I ask it to.

AI Agents Take on Delegable Tasks

Coding agents take the next step: they typically do not integrate into the existing IDE, but offer an alternative interface. This allows me to talk to the agent, which then independently makes changes to the codebase. The agent takes the step from being a friendly helper to a partner in implementation.

This enables my new partner (in my case, Claude Code) to take on much more complex tasks: 

• “Create a project for me”

• “Build the skeleton of a feature flag system”

• “Integrate a configurable connection to an SQLite database”

These are suddenly delegable tasks that Claude Code implements with the highest level of motivation. Claude generates tests, makes suggestions for improvement, and expands code with new functions.

Coding agents really shine when it comes to all the little tasks that require diligence. These include tasks such as:

• Renaming attributes

• Introducing a new data type

• Use throughout the entire codebase

The Perfect Support for Exploration

A coding agent provides the perfect support when exploring a new codebase: it allows me to quickly answer questions about the code as a whole. What is the code quality of the authentication module? What features exist in the codebase and how is the code structured in each case? I no longer have to answer these questions myself, but can delegate them to the agent.

But here, too, AI reaches its limits: complex features or extensive business logic lead Claude Code down the path to a chaotic codebase. What Claude cannot do is restructure existing code to meet new requirements. Instead, new code is constantly being generated, and my project grows inexorably. The price I have to pay for usable code is that, as the complexity of the requirements grows, I have to become more and more precise in defining what I would like to have implemented. In the end, my definition is close to what we call coding, and the hoped-for efficiency gains are a thing of the past.

Lost in Translation - The Mistakes AI makes

Another factor becomes particularly noticeable when you are just starting out with AI-supported coding: the type of errors that AI makes. Human errors are easier to spot because you have probably made them yourself in the past, or at least can understand how they came about. AI errors are more subtle, sometimes so different that you would never assume that an error could be there. To use an analogy: while a colleague's mistake might be not plugging the power cord into the socket, the AI's mistake is sometimes that the power cord is tied to a trailer hitch.

Nevertheless, clear tasks can be implemented very efficiently with my new partner. If I want to get an overview of an existing code base, I can use a simple prompt to keep Claude busy for minutes rummaging through the code base and bringing me the answers.

Conclusion: I Make Decisions, not AI

The bottom line is that AI assistants in their various forms are the biggest innovation in coding tools since CI/CD pipelines. Tasks that I, as a developer, can clearly define can be delegated to the assistants. This not only allows me to be a little faster, but above all to increase the quality of my work. Where I might have previously skipped explicit error handling or clean documentation of my code due to time pressure, I now delegate these tasks to my diligent colleague.

Tools don't make decisions for me. And the responsibility for what I push to the repository lies 100 percent with me. Delegating something to the tool that I don't understand myself will always result in me getting something I can't control. And that's why it's useless – we want to maintain the high quality standards in our projects.