Two years ago, an AI coding assistant finished your line. Today it can read a ticket, explore a repository, run the tests, and hand back a pull request. That is a different kind of tool, and it quietly changes who does what on a software team.
- The unit of AI assistance has moved from the keystroke to the task, which shifts the bottleneck from writing code to reviewing it.
- Independent evidence on productivity is mixed: gains are real in some workflows and absent, or even negative, in others.
- Agents need the same things a new hire needs: clear repository instructions, fast tests, and narrowly scoped permissions.
- Teams that treat agents as untrusted contributors, with sandboxes and mandatory review, avoid most of the early security pain.
- Measure outcomes such as lead time, change failure rate and review load, not lines of code or acceptance rates.
01From autocomplete to autonomy
The first wave of AI coding tools lived inside the editor and behaved like a very fast pair of hands. You typed a function signature, the model suggested a body, and you pressed Tab. The interaction was tiny, the feedback loop was instant, and the human stayed in control of every line.
The second wave behaves more like a junior colleague with a terminal. Tools from the major assistants and a growing field of independent products now accept a goal in plain language, search a codebase, edit several files, run a build, read the failing output, and try again. Many can work in the background and report back with a branch and a summary. The interface is no longer the cursor. It is the issue tracker and the pull request.
That distinction matters because it changes where the effort goes. When a model suggests a line, the cost of a wrong suggestion is a second of your attention. When an agent produces a four-hundred-line change across nine files, the cost of a wrong answer is a reviewer’s afternoon, and a subtle bug can slip through precisely because the diff looks so tidy.
The scarce resource on a modern software team was never typing speed. It is the attention of the people who understand the system well enough to say yes.
02What the evidence actually says about productivity
Vendor demos suggest dramatic speedups, and surveys of developers usually report that people feel faster. The harder question is whether teams ship better software sooner. The independent research so far is more cautious than the marketing.
One widely discussed randomized study published in 2025 by the research group METR followed experienced open-source maintainers working on their own mature repositories. The developers expected AI tools to speed them up, but measured completion times were slower on average, in part because of time spent prompting, waiting and cleaning up output. Other studies, often run on more self-contained tasks or with less experienced engineers, have found meaningful gains. The 2025 DORA research from Google Cloud framed AI as an amplifier: it magnifies the strengths of a well-run engineering organization and the dysfunction of a struggling one.
The honest reading is that results depend on context. Greenfield prototypes, test scaffolding, migrations, documentation and well-specified bug fixes tend to go well. Deep changes in tangled legacy systems, where the hard part is knowing what not to touch, tend to go poorly. Teams that adopt agents with that map in mind get more value than teams that apply them uniformly.
03The review bottleneck nobody budgeted for
If an agent can produce five candidate changes in the time a human writes one, the pipeline immediately shifts its constraint downstream. Code review, already the most overloaded ritual in software, absorbs the surge. Reviewers face larger diffs, written by an author that cannot be asked why it chose an approach, in a style that is consistently plausible and occasionally wrong.
Teams that cope well tend to make a few structural choices. They cap the size of agent-authored changes and ask for small, single-purpose pull requests. They require the agent to include a short rationale and a list of what it did not verify. They lean harder on automated checks, including type checking, linters, property tests and snapshot tests, so that human attention is reserved for design and intent. Some assign an explicit owner to every agent-authored change, so that accountability never dissolves into the phrase the AI did it.
There is also a cultural point. Reviewers need permission to reject a change that is merely adequate. An agent has no ego to bruise, which means feedback can be blunt and cheap, but it also means that bad patterns repeat unless someone encodes the lesson into the repository’s instructions.
04Context is the new infrastructure
An agent is only as good as what it can see. Early users learned this the hard way: the same model that produced elegant code in a small demo repository flailed in a monorepo with undocumented conventions. The response has been a quiet standardization of context. Repositories now carry plain-text instruction files that describe the build commands, test strategy, naming conventions and no-go areas, and several tools read common filenames for this purpose.
Alongside that, the Model Context Protocol, introduced by Anthropic in late 2024 and since adopted widely across vendors, gives agents a consistent way to reach external systems such as issue trackers, databases, documentation and observability tools. For platform teams, that turns integration work into something familiar: expose a well-scoped server, apply authentication, and log what gets called.
The practical lesson is that good developer experience and good agent experience are the same thing. Fast, deterministic tests give an agent a reliable signal. A one-command setup lets it start without guessing. Clear module boundaries limit the blast radius of a wrong edit. Companies that invested in these basics for human engineers are discovering that the payoff has just increased.
| Task type | Agent fit | Why | Human role |
|---|---|---|---|
| Test scaffolding and coverage gaps | Strong | Clear success signal, low blast radius | Spot-check assertions for meaning |
| Dependency and framework upgrades | Strong | Repetitive, well documented, mechanically verifiable | Review breaking-change decisions |
| Well-specified bug fixes | Good | Reproducible failing test anchors the work | Confirm root cause, not just symptom |
| New feature in familiar module | Mixed | Depends on spec quality and conventions | Own the design and edge cases |
| Cross-service architecture changes | Weak | Needs tacit knowledge and trade-off judgment | Lead, using the agent for research |
| Security-sensitive logic | Weak | Subtle failure modes, high cost of error | Author or deeply review every line |
05Guardrails: treat the agent like an untrusted contributor
An agent that can run shell commands, read files and call external services has a larger attack surface than any autocomplete plugin. The risks are not exotic. A model may follow instructions hidden inside a web page, a dependency’s README or an issue comment, a class of attack known as prompt injection. It may print a secret into a log, install a package that sounds right but is not, or run a destructive command because it misread the situation.
The defensive pattern looks like the one used for any untrusted code. Run agents in disposable sandboxes with no standing credentials. Grant the narrowest permissions that let the task succeed, and prefer short-lived tokens. Put network egress behind an allowlist. Require human approval for actions that are hard to reverse, such as deleting data, pushing to protected branches or touching production. Log every tool call so that incidents can be reconstructed afterwards.
06How teams and roles are shifting
Job titles have not changed overnight, but the work inside them has. Senior engineers spend more time writing specifications, shaping tests and reviewing, and less time producing first drafts. Junior engineers, who traditionally learned by writing and receiving feedback on small changes, face a different path: the small tasks that once trained them are exactly the ones agents handle best. Thoughtful organizations are responding by pairing newer engineers with reviews and incident work earlier, and by treating understanding of the system as the skill being trained, rather than typing.
Product and design roles are changing too. When a working prototype costs an afternoon, the cost of exploring an idea falls, and conversations move from debating a mockup to clicking a branch. That is healthy, provided someone still decides which experiments deserve to become maintained software. Every line an agent writes is a line a human team must own later.
07A practical rollout playbook
List recurring work such as upgrades, test gaps, flaky-test triage and documentation. Pick two or three categories with clear pass or fail signals.
Write instruction files, make the test suite fast and reliable, and document the one-command setup. Fix flaky tests first, because agents amplify noisy signals.
Run in isolated environments with minimal credentials, egress controls and mandatory review on every change that reaches a protected branch.
Set a size limit for agent pull requests, require a rationale and a list of unverified assumptions, and name a human owner for each change.
Track lead time, change failure rate, review time and rework before and after. Revisit quarterly and widen or narrow scope based on evidence.
08What to watch next
Three developments deserve attention over the coming year. First, long-running background agents that handle a queue of maintenance tasks will force teams to build proper approval workflows and cost controls. Second, evaluation will improve: expect more teams to maintain private benchmark suites drawn from their own repositories, because public leaderboards say little about your codebase. Third, regulation and procurement rules are catching up, and enterprises increasingly ask vendors about data handling, code provenance and auditability before approving a tool.
None of this makes the technology less useful. It makes it more like the rest of engineering: a set of trade-offs that reward discipline. Organizations that approach agents with clear scope, strong tests and honest measurement will find real leverage. Those that chase volume will find that generating code was never the hard part.
09Frequently asked questions
Will AI coding agents replace software engineers?
The evidence so far points to a change in the mix of work rather than the disappearance of the role. Specification, system design, review, debugging in context and accountability remain human responsibilities, and demand for them grows as more software is produced.
Are agent-written pull requests safe to merge automatically?
Not by default. Automatic merging is reasonable only for narrow, low-risk categories with strong automated verification, such as formatting or pinned patch upgrades. Anything touching business logic, authentication or data handling deserves human review.
What is the single best preparation step?
Make your tests fast and trustworthy. A reliable test suite is the feedback signal that lets an agent self-correct and lets reviewers trust the result.
How should small teams start?
Pick one repetitive task, run the agent in a sandbox for a month, and compare cycle time and defect rates with your baseline. Expand only if the numbers justify it.
