AI Agents Write 30% More Code. Shipped Software Did Not Move. Code Review Is Why

Two of the most important software engineering studies of 2026 landed within days of each other, and they point at the same uncomfortable conclusion.

A Harvard working paper analyzed roughly 300 million work events across more than 700 software firms. After teams adopted AI coding agents, the code each developer produced rose about 30 percent. The amount of finished software those firms shipped did not move in any statistically significant way.

A Bain survey of nearly 300 senior technology leaders found the same pattern from the other direction. Developers complete roughly 21 percent more tasks. Time spent reviewing code rose about 91 percent.

The typing got faster. The shipping did not. And the reason sits in one place: code review.

The paper, "Artificial Intelligence in the Firm: Bottlenecks in Software Production" by Harvard economists Fiona Chen and James Stratton, paired engineering telemetry from the Jellyfish analytics platform with GitHub activity across 718 firms and more than 725,000 workers, covering January 2021 through March 2026. It is the first large-scale empirical look at what happens to a company, not an individual developer, when coding agents arrive.

The numbers, as reported by Ars Technica and other outlets covering the paper:

That last group of numbers is the mechanism. Agents generate code faster than the organization can absorb it, and the surplus piles up in the review queue. The authors put it plainly: "code review becomes the bottleneck." Their prescription is equally blunt. Realizing the benefits of AI adoption requires complementary investments in downstream review capacity, not more code generation.

One detail deserves its own sentence. By March 2026, 80 percent of firms in the dataset were running AI code review tools. Yet only 23 percent of review comments were AI-generated. Teams bought the tools. The tools did not remove the human constraint.

Bain's 2026 Global Technology Report, released September 29, surveyed nearly 300 senior technology leaders. The findings line up with the Harvard data almost number for number:

Purna Doddapaneni, a Bain partner and one of the report's authors, told CIO Dive: "The bottleneck has moved from writing code to trusting it. Every change still has to be understood, reviewed, tested, and secured, and most of that work still runs through people."

That gap between expected and captured gains is the whole story in one line. The reports are measuring the same thing Harvard measured, which is that output rises at the individual level and settles at the speed of the slowest human checkpoint at the organizational level.

If review is the bottleneck and AI review tools are the obvious answer, the first leaderboard for that category should show a solved problem. It shows the opposite.

On October 5, GitHub launched ReviewBench, an open benchmark for code review agents, built from 219 real pull requests across 187 public open source repositories in 19 languages, modeled on the distribution of 103.9 million real GitHub pull requests. GitHub Copilot's code review agent leads the inaugural leaderboard with a grounded F1 score of 40.1 percent.

Read that number again. The best-scoring agent on a benchmark designed and hosted by its own vendor catches less than half of what the ground truth set says matters, at a precision-recall balance the benchmark rewards. Meanwhile Faros AI's 2026 telemetry, covering 22,000 developers across more than 4,000 teams, found that high AI adoption came with average pull request size up 51 percent and bugs per developer up 54 percent.

So the loop currently looks like this: agents write bigger pull requests, bigger pull requests take longer to review, AI reviewers catch less than half of the issues, and the extra review load lands on humans. Amazon's internal response, cited in the Bain report, is a mandate to push up to 70 percent of code reviews to AI. That may work at Amazon's scale with Amazon's investment. For most teams, the honest reading of the data is that AI review is a filter, not a replacement.

It is worth being precise about why the constraint moved here and not somewhere else, because the answer tells you where to spend effort.

If your team adopted coding agents and your pull requests are aging, this is the checklist I would work through, in order. Each item maps to something the data says is actually broken.

None of these studies say AI coding agents are useless. They say the industry bought the first half of the pipeline, generation, and is now paying for having ignored the second half, verification. Writing code was never the only constraint; it was just the constraint that a chat box could relax.

The teams capturing real gains in this data are not the ones generating the most code. They are the ones who reinvested in review capacity, kept their diffs small, and treated AI reviewers as a first pass rather than a verdict. Bain's own numbers show organizations currently capture a fifth to a quarter of the gains their leaders expect. The difference lives almost entirely downstream of the code editor.

The next real productivity jump in software will not come from a model that writes faster. It will come from making trust scale: better review tooling, smaller changes, and engineers whose job shifts from producing code to certifying it. The reports agree on that. Now the process has to catch up.

I write about backend engineering, developer tools, and practical AI adoption every week. Subscribe, it's free.

Teams are clearly splitting on this: some have put AI review in front of every PR, others refuse it outright. Which side is your team on, and what did it do to your merge times? Tell me in the comments.