Coding Agents: User Guide and Limitations

Coding agents are no longer just about autocompletion: they read repositories, modify files, run tests, and iterate towards a goal. Their power necessitates new practices: framing, explicit work loops, robust testing, and human review. Here’s a pragmatic guide to using them wisely and choosing the right tool for the task.

What the agent does not replace: human review and judgment

An agent can pass all tests while producing a poor implementation. Developers remain essential for reviewing the code generated by the agent. The review must check for design adequacy, integration with the existing architecture, and identify unnecessary changes. It should also track hidden assumptions, detect introduced dependencies, consider unusual inputs, assess maintainability, and account for security implications. AI makes code production inexpensive, but understanding the code remains costly. Working with coding agents requires slightly different skills: understanding algorithms and architecture, continuing to debug, and knowing how to delegate work to a machine that can act on behalf of the developer. It is necessary to define the problem, provide context, establish constraints, and then examine the result. As an AI agent can work much faster and produce more code in a short time, good delegation becomes even more important. For years, programmers have adapted to technological advancements, and the emergence of coding agents makes this adaptation particularly visible. The most interesting question posed is not about measuring the portion of programming that can be automated by AI.

Choosing the right assistance: agent, assistant, or none

Not all tasks require an autonomous agent. For small questions, an AI assistant or even a manual implementation may be quicker; for example, understanding why a Python expression returns None does not justify an agent accessing an entire repository. Conversely, finding out why integration tests are failing, identifying the cause, fixing it, and running the relevant tests is well-suited for an agent. A simple rule associates typical tasks with the tool: explaining an error falls to an assistant; writing a small function, to a coding assistant; refactoring a file may involve either an assistant or an agent; finding and fixing a bug, an agent; adding a feature at the repository scale, an agent; investigating a failing test suite, an agent; rewriting an entire application, an agent with human checkpoints; asking “improve this code” without specifying the problem suits none. The more a task involves exploration, multiple actions, and feedback, the more an agent is useful, provided it is given the right elements.

Framing the request: context, constraints, and five key elements

The constraints given to the agent matter more than the abundance of text. The quality of a prompt is limited without context, whereas a repository provides architecture, conventions, dependencies, tests, configuration, and documentation. Asking without context is like driving without GPS in an unfamiliar country. An effective request specifies the relevant files, prior readings (such as README, code, and targeted tests), reminds to follow existing patterns, and to run tests after modification; this framing creates a better reasoning environment. Instructions and documentation at the project level thus gain importance. Longer prompts are not necessarily better: a good prompt indicates where to look. A request to a coding agent generally includes five elements: an objective (such as adding support for a given input), context (for example, inspecting src/parser.py and existing tests), constraints (not changing the public API), acceptance criteria (keeping existing tests green and adding those for the new input), and validation (running targeted tests).

Unrolling the loop: inspect, plan, test, and iterate finely

The recommended work loop is Ask → Inspect → Plan → Implement → Test → Review. It is advisable to start with inspecting the repository without modifying files, in order to locate the targeted functionality, identify files likely to change, spot existing tests, and note architectural constraints. A planning step should precede modifications: it saves time and avoids errors by correcting misunderstandings before extensive changes; once the logic is understood, specific modifications can be requested. Massive tasks, such as rewriting an entire application, are difficult to review due to the volume of code produced; it is better to break the work into small steps and test after each addition (for example, adding a parser class, writing unit tests, integrating into the pipeline, refactoring duplicated code). This breakdown facilitates problem localization. An agent does not have inherent knowledge of how the code works in a given environment; however, after test failures, it can read the trace, target the code, modify, and relaunch. Good tests then become more valuable and can be part of the agent's very environment.

Agent capabilities and risks of a vague request

The applications of AI to coding have evolved: first, autocompletion, limited to predicting the next line and present in most editors and platforms like Google Colab; then assistants capable of producing functions and explaining errors; finally, agents. The latter examine a repository, create and modify files, run tests, read error messages, make other changes, and iterate towards a defined goal. The developer then asks to tackle a problem and explore the codebase rather than writing an isolated function. The key difference lies in the loop: the agent interacts with its environment, changing how it is used. Vague requests, such as building an application's authentication, can trigger extensive modifications, the addition of dependencies, and database alterations, resulting in an outcome far removed from the actual need; the problem arises from imprecise instructions. A better-framed request mandates prior inspection of the existing code, prohibits risky changes, requires adherence to established patterns, prescribes concrete tests, and demands a plan before any modification. In this framework, the programmer retains the thinking and planning and uses AI to gain efficiency.

Selecting the agent according to the workflow

An ecosystem of coding agents is growing, with integrations in IDEs, terminal-mode agents, and cloud offerings. The choice depends on the workflow. Spending most of the time in an IDE advocates for an agent integrated into the IDE; primarily working in the terminal points towards a command-line agent; if development revolves around GitHub, integration with repositories and pull requests may become a priority.