AI Coding Agents

From Autocomplete to Autonomy

The evolution of AI-assisted programming has moved through distinct phases. GitHub Copilot, launched in 2021, introduced inline code completion, suggesting the next few lines as a developer typed. By 2024, tools like Cursor and Continue embedded LLMs more deeply into the IDE, handling multi-line edits, explaining code, and generating functions from natural language descriptions.

AI coding agents extend assistance into an iterative workflow. They can plan implementations, edit multiple files, run tests, interpret failures, and revise their work. The human role expands from writing each change to specifying goals, reviewing decisions, and deciding whether the result is ready to use.

From Code Generation to Extended Projects

The defining shift is from producing a plausible fragment to maintaining a working project through a sequence of changes. An agent must track dependencies, interpret feedback, and revise its plan without losing the original goal. Formal verification workflows make this distinction especially clear: each step must fit into a larger structure that a checker can validate.

The working environment shapes how this happens:

IDE integration puts the agent alongside a developer's editor, making it easy to inspect changes and steer the work.

Terminal access lets an agent use the project's own build tools, tests, and version-control workflow.

Isolated execution provides a separate environment for longer tasks, with changes returned for review before integration.

All three are interaction patterns built on the same underlying intelligence. In each, useful autonomy depends on clear permissions, reliable feedback, and an effective handoff to the human responsible for the software.

How Coding Agents Work

Modern coding agents combine several capabilities:

Codebase understanding: Agents index and search codebases using tools like grep, glob, and AST parsing. They read files, understand project structure, and identify relevant code before making changes.

Planning: Given a task, agents decompose it into steps, which files to modify, what tests to write, what commands to run. Better agents plan before acting rather than diving in blindly.

Tool use: Agents operate terminals, run build tools, execute tests, manage git workflows, and interact with external services. Beyond generating text, they take real actions in the development environment.

Self-correction: When tests fail or builds break, agents read error output, diagnose the problem, and iterate on their solution. The best agents can recover from several rounds of failure.

Measuring Performance

Two benchmarks have become standard for evaluating coding agents:

SWE-bench asks agents to resolve real GitHub issues in open-source projects, graded by each project's own tests. When it launched in 2023, the best system resolved about 2% of issues; frontier agents now exceed 80% on the human-validated Verified subset, which pushed researchers to the harder SWE-bench Pro. Scores depend on the variant and the agent harness, so see the benchmark catalog for sourced results.

Terminal-Bench evaluates agents on complex terminal-based tasks that require multi-step reasoning, file manipulation, and command execution. It measures practical engineering capability rather than isolated code generation.

The Productivity Multiplier

The impact on developer productivity is substantial but uneven. Today, AI coding agents amplify developers: an experienced developer who understands architecture, testing, and system design can direct an agent to handle implementation details, boilerplate, and routine tasks at dramatically higher speed.

Teams adopting these tools report 3-10x speedups on tasks like writing tests, implementing well-specified features, debugging, refactoring, and migrating codebases. The gains are largest for tasks with clear specifications and existing patterns to follow. A 2025 METR trial found that early-2025 assistants actually slowed experienced developers working in large codebases they knew well; the tools have since moved from suggesting code to running and verifying it on their own.

The gains are smaller, sometimes negative, for novel architecture decisions, complex system design, and tasks requiring deep domain knowledge that the developer themselves doesn't possess. The agent amplifies the developer's knowledge, which is why expertise still matters most on exactly these tasks.

Implications for the Field

AI coding agents are changing the economics of software development. Tasks that once required a team of engineers over weeks can be completed by a single developer with an agent in days. This is lowering the barrier to building software and enabling smaller teams to tackle ambitious projects.

The long-term trajectory points toward increasingly autonomous agents. As models improve at reasoning, planning, and self-correction, the gap between "agent-assisted development" and "autonomous software engineering" will narrow. AI is on track to write most of the world's code; the open questions are how soon, and what role humans play in directing the work.