From Suggestions to Agency
The first generation of AI coding tools (GitHub Copilot's initial release, early code completion features) operated on a simple model: you write code, the tool suggests what might come next. This was genuinely useful, saving keystrokes and surfacing patterns, but it was fundamentally reactive. The AI waited for you to do something, then offered to complete it. The human remained firmly in control of every decision.
The current generation works differently. Tools like Claude Code, Copilot's agent mode, Windsurf, and others don't just suggest completions. They can take autonomous action toward a goal. Describe what you want in natural language ("add user authentication to this application" or "fix the bug where the form doesn't validate email addresses"), and the agent figures out what files need to change, makes those changes, runs the tests, and iterates if something doesn't work.
This is a fundamentally different relationship between developer and tool. Instead of the AI assisting while you direct every step, you're delegating tasks to an agent that can work semi-independently. It's closer to working with a capable junior developer than using a sophisticated text editor feature.
The capabilities are impressive. Claude 4.5 Sonnet achieved 77.2% on SWE-bench Verified, a benchmark that tests whether an AI can successfully resolve real GitHub issues from real repositories with actual test suites. That means it correctly solved more than three-quarters of representative, non-trivial development tasks. Performance on Terminal-Bench 2.0, which focuses on practical coding tasks, has similarly broken barriers that seemed distant just a year ago.
What Coding Agents Actually Do
To understand the practical impact, it helps to trace through what happens when you give a coding agent a task. The process typically unfolds in several phases that parallel how a human developer would approach the same problem.
First, the agent explores the codebase to understand context. Unlike a human who might already know the project structure, the agent needs to discover how the application is organised, what patterns are used, where relevant code lives. Modern agents do this surprisingly well. They read configuration files, examine directory structures, and build mental models of the codebase that inform their decisions.
Then comes planning. Given the task and the context, what changes are actually needed? A request like "add user authentication" might require creating new database tables, building authentication routes, implementing middleware, updating the frontend, and adding tests. Good agents think through these dependencies and sequence their work appropriately, just as a competent developer would.
Execution follows: actually writing and modifying code. This is where the raw capability of modern language models shines. They can generate idiomatic code in virtually any language, follow existing patterns in your codebase, and handle the mechanical aspects of implementation that consume significant developer time.
Finally, there's validation and iteration. Agents can run tests, observe failures, analyse what went wrong, and make corrections. This feedback loop is crucial. It's what separates agents that generate plausible-looking code from agents that generate code that actually works. The ability to iterate on failures transforms a tool that might work from a tool that reliably works.
The Emerging Workflow
The most effective teams we've observed don't use coding agents for full autonomy. They use them for amplified pair programming. The pattern that works best involves humans handling certain responsibilities while delegating others to the agent.
Humans excel at architectural decisions, understanding business requirements, navigating organisational constraints, and handling genuinely novel problems that don't fit existing patterns. They're also better at reviewing code for subtle issues, catching edge cases the agent might miss, and making judgment calls about trade-offs. These remain fundamentally human tasks, and trying to delegate them fully to agents produces poor results.
Agents excel at implementation once direction is clear. Writing boilerplate, implementing well-understood patterns, making systematic changes across many files, generating tests, and iterating on feedback: these are tasks where agents can work faster than humans with comparable quality. The mechanical aspects of software development that consume so much time are precisely where agents add the most value.
The collaboration feels like working with a capable colleague who can type infinitely fast and never gets bored, but who needs clear direction and regular check-ins. You might say "implement the user profile page with edit functionality" and review the result, suggesting adjustments, catching issues, and redirecting as needed. The agent does the heavy lifting; you ensure it's lifting in the right direction.
This pattern is more productive than either fully manual development or fully autonomous AI development. The human provides judgment and direction; the agent provides speed and thoroughness. Neither could match the combination's effectiveness working alone.
Practical Considerations
Adopting coding agents effectively requires attention to several practical factors that aren't always obvious from demos and marketing materials.
Codebase readability matters more than ever. Agents learn from your code, including its patterns, naming conventions, and architectural decisions. Well-organised codebases with clear structure, good names, and consistent patterns produce dramatically better agent outputs than messy ones. The investment in code quality that you might have justified on maintainability grounds now has an additional payoff: better AI collaboration. If your codebase is hard for humans to understand, it will be equally hard for agents.
Tests become even more valuable. Agents can iterate effectively only if they can verify their work. Codebases with comprehensive test suites let agents catch their own mistakes and correct them automatically. Codebases without tests require human verification of every change, which dramatically reduces the productivity gain. If you've been underinvesting in testing, agent adoption provides strong motivation to change.
Context management is a skill to develop. Agents work best when they have relevant context and aren't overwhelmed with irrelevant information. Learning to provide appropriate context (pointing the agent to relevant files, explaining domain concepts, clarifying constraints) is a new skill that improves with practice. Teams that develop good context management habits get substantially better results.
Review workflows need adaptation. Code review practices developed for human-written code may need adjustment. Agent-generated code tends to be more consistent in some ways (it follows patterns systematically) but may have different failure modes than human-written code. Review practices should evolve to catch the specific issues agents tend to produce while not wasting time on issues they don't.
What This Means for Developers
The rise of coding agents doesn't eliminate the need for developers, but it does change what developers spend their time on. Less time writing boilerplate and implementing straightforward features; more time on architecture, complex problem-solving, and working with stakeholders to understand what actually needs to be built.
The developers who thrive in this environment tend to be those comfortable with ambiguity and high-level problem-solving. The ability to decompose a vague requirement into clear, implementable tasks (which an agent can then execute) becomes more valuable than the ability to personally implement those tasks quickly. Taste in architecture, judgment about trade-offs, and the ability to review AI output critically matter more; raw coding speed matters less.
This represents an opportunity for developers who have felt constrained by the mechanical aspects of their work. The parts of development that many find tedious (implementing yet another CRUD interface, writing boilerplate tests, making systematic changes across a codebase) are precisely what agents handle best. The parts that developers often find most engaging (designing systems, solving novel problems, understanding user needs) remain fundamentally human tasks.
For teams and organisations, the implication is that developer productivity can increase substantially, but only if workflows evolve to take advantage. Teams that simply use agents as better autocomplete will see modest gains. Teams that restructure how they work, delegating appropriate tasks while maintaining human judgment where it matters, will see transformative improvements.
Looking Forward
Coding agents will continue to improve. The trajectory of benchmark performance suggests that tasks which stump today's agents will be routine for agents a year from now. The integration into development environments will become smoother, the collaboration patterns more refined, and the failure modes better understood and mitigated.
But the fundamental dynamic is likely to persist: agents as amplifiers of human capability rather than replacements for human judgment. The most valuable developers will be those who can work effectively with AI tools while providing the direction, review, and decision-making that remains distinctly human. Building that capability now, developing intuitions for what agents do well and where they need guidance, positions teams well for whatever comes next.
If you haven't yet worked seriously with modern coding agents, the barrier to starting has never been lower. Claude Code and similar tools offer free or low-cost tiers sufficient for experimentation. The investment is a few hours of learning; the potential payoff is a fundamentally different relationship with the mechanical aspects of software development.