Coding agents write more code, but human review eats up the gains

The study that Ars Technica describes points to a fact the market would rather not hear: AI coding agents do speed up code writing, but that does not produce more finished software. The time saved on generation goes into human review. Review has become the bottleneck of the entire process. The available abstract contains neither the methodology nor exact figures, so below you will find the study's conclusion along with context from earlier measurements that point in the same direction.

Where the code gets stuck

The development pipeline consists of task definition, coding, review, testing, and deployment. An agent speeds up only the second step. The others stay the same, and review also takes on a heavier load: pull requests grow larger and more numerous, yet a human who is accountable for the result still has to read them.

Agent-written code usually looks convincing: it is neatly formatted and passes basic checks. That is exactly why it cannot be skimmed. A reviewer has to reconstruct the intent, check edge cases, and hunt for places where the model was confidently wrong. This is the classic theory of constraints: if you speed up a step that is not the narrowest one, the system's throughput does not change. Only the queue in front of that step grows.

What earlier measurements showed

This picture has a history. Here is data that was published earlier and that people usually cite in these debates:

• METR, 2025: 16 experienced developers worked on 246 tasks in mature open-source repositories. With AI tools they took 19% longer, even though they themselves expected a speedup of about 24%.
• Faros AI, 2025: in teams with a high level of AI use, 21% more tasks were completed and 98% more pull requests were merged. Review time rose by 91% over the same period.
• DORA, 2024: a 25% increase in AI use correlated with a 7.2% decline in delivery stability.

These studies differ in sample and methodology, so their results cannot be simply added together. But the overall pattern repeats: output volume grows, while end-to-end delivery speed and quality do not grow with it.

Why this is a question of money

Many companies assess the return on AI tools through indirect indicators: the share of accepted suggestions, lines of code, the number of PRs. If the bottleneck is review, these metrics rise while the business result stands still. Excess code turns into work in progress, that is, a queue that goes stale and conflicts with neighboring changes. Worse, overloaded reviewers start waving changes through without looking, and then the savings turn into technical debt and incidents.

How to rebuild the process

If agents already work on your team, it makes sense to change the process itself, not just the set of tools:

• Measure the time from the start of a task to production and the rollback rate, not the volume of generated code.
• Limit the size of PRs from agents. Small changes are read faster and break less often.
• Shift verification to automation: tests, linters, static analysis, and typing should filter out defects before they reach a human.
• Give agents tasks with a clear definition of done that a test can verify.
• Cap the number of open PRs and budget review time in plans as a separate line item.

AI reviewers may become a first filter, but the merge decision still rests with a human, and it is this part of the pipeline that determines the real speed of shipping software.