For a few years, AI coding help meant asking a chatbot a question and pasting the answer into your editor. Agentic coding assistants change the shape of that interaction: instead of answering "how do I do X," they attempt X. They read files, edit several of them, run the build or the tests, read the result, and try again.
The framing that explains why this works, and where it stops working, comes from Anthropic's engineering guide "Building effective agents." This article leans on it throughout.
Workflows versus agents
The guide draws a line that is useful for coding tools. Workflows are "systems where LLMs and tools are orchestrated through predefined code paths." Agents are "systems where LLMs dynamically direct their own processes and tool usage, maintaining control over how they accomplish tasks."
A tool that autocompletes a line or answers a question in a sidebar is closer to a workflow. A tool that decides on its own which files to open, which commands to run, and when it is finished is an agent. The second category is what people mean by agentic coding assistants.
The loop that makes it work
An agent's defining property is the loop: plan, act, observe, revise. The guide stresses that it is crucial for agents to gain "ground truth" from the environment at each step, such as tool-call results or code execution, to assess their progress. For a coding agent, the ground truth is concrete: the compiler's error, the failing test, the linter's output. Without that feedback the model is guessing; with it, the model can correct itself.
This is also why code is such a good fit for agents. The guide makes the point directly: code solutions are verifiable through automated tests, so agents can iterate on a solution using test results as feedback. Anthropic's own example is an agent that resolves real GitHub issues from the description alone, with a human still reviewing the result.
Where they help most
The tasks that suit an agent are the ones that are tedious, spread across many files, and checkable:
- Renaming or changing an API signature across many call sites.
- Updating a dependency and fixing the compile errors it causes.
- Scaffolding a feature that touches several layers in a way the codebase already demonstrates.
- Writing tests for existing behaviour, where the test run itself is the check.
Where they go wrong
The guide is blunt about the downsides of autonomy: higher costs and "the potential for compounding errors." An agent that misreads the task at step one can build ten more steps on top of the mistake. And the guide's closing note on coding agents is that human review remains crucial for ensuring solutions align with broader system requirements, because passing tests does not prove the change is what you wanted.
Its recommended mitigations are the ones that apply to any agent: extensive testing in sandboxed environments, appropriate guardrails, and starting with the simplest solution that works.
How to get good results
My own suggestions, built on those principles rather than quoted from them:
- Invest in tests first. The agent's loop is only as good as its feedback. A codebase with solid tests gives it a safety net; one without gives it nothing to check against.
- Scope tasks tightly. "Rename this function everywhere and make the tests pass" is a good task. "Improve the architecture" is an invitation to wander.
- Run in a sandbox or a branch. Give the agent room to try things in a place where a mistake costs nothing, and review the diff before it merges.
- Limit what it can touch. Grant the narrowest permissions the task needs, especially for commands that change state, delete files or reach the network. Connecting an agent to external tools, for example through MCP, widens what it can do, so each addition deserves a deliberate decision.
- Read the diff like a colleague's pull request. Check that the change matches your intent, not just that it compiles.
Start simple
One line in the guide is worth keeping in mind before you adopt a tool: start with the simplest solution possible, and add complexity only when needed. For many coding tasks, a single well-prompted request with the right files in context is enough. Reach for a full agent loop when the problem is open-ended, the number of steps is hard to predict, and you have the tests to keep it honest.
The takeaway
Agentic coding assistants are capable collaborators that can absorb mechanical work, as long as you give them feedback to learn from and a review step to catch what the feedback misses. The teams that benefit most are usually the ones that already invested in tests and code review, because those are exactly what make autonomous iteration safe.
Comments (0)
No comments yet — be the first.
Sign in to leave a comment.