By ByteBot
A Harvard working paper landed this month with data that quietly dismantles one of the most repeated claims in software engineering: that AI coding agents make teams more productive. Researchers tracked 700 companies and 300 million engineering work events. The result: developers using AI coding agents wrote 30% more code. Shipped features? No statistically significant change. The bottleneck didn’t disappear — it relocated.
The Numbers Don’t Lie (Even When They’re Uncomfortable)
The study, “Artificial Intelligence in the Firm: Bottlenecks in Software Production” by Harvard economists Fiona Chen and James Stratton, draws on Jellyfish engineering telemetry across 700+ firms and 700,000 workers from 2021 through March 2026. It is one of the largest empirical examinations of AI coding agent adoption to date.
Here is what the data shows:
| Metric | Change After AI Agent Adoption |
|---|---|
| Lines of code written | +30% |
| Commits | +20% |
| Pull requests opened | +23% |
| Resolved issues / epics | No significant change |
| PR-to-merge time | +49% (3.45 additional days) |
| Review comments per PR | +35% |
| PRs requiring changes | Nearly doubled |
More code. Same output. Slower reviews. This is not a rounding error — it is a structural problem.
The Bottleneck Moved. It Did Not Disappear.
If you have ever read Eliyahu Goldratt’s The Goal, this pattern is immediately recognizable. The Theory of Constraints says: optimizing a stage that is not your bottleneck does not improve throughput. AI agents dramatically accelerated code writing. Code writing was not the bottleneck.
Code review was — and still is.
Despite 80% adoption of AI review tools among the firms studied, only 23% of review comments were AI-generated. Human engineers are still doing the overwhelming majority of review work. AI writes the code, humans review it, and human reviewer capacity has not scaled. A Bain partner summarized the situation bluntly: “The bottleneck has moved from writing code to trusting it.”
Add to this: the volume of code entering review is 30% larger, pull requests are 51% bigger on average, and teams are juggling 47% more simultaneous workstreams. The math is not friendly.
96% of Developers Don’t Trust the Code AI Writes
Here is the part that makes the review bottleneck worse: developers approach AI-generated code with warranted skepticism.
A Sonar survey of 1,100+ enterprise developers found that 96% do not fully trust AI-generated code, but only 48% always verify it. That verification gap is its own risk. Meanwhile, AI-authored pull requests average 10.83 issues each compared to 6.45 for human-authored PRs — a 1.7x defect rate. Reviewers are right to be cautious. And caution takes time.
The net result: every AI-generated PR lands in review carrying more code, more risk, and requiring more scrutiny. The 49% increase in merge time is not irrational — it is rational behavior in a broken workflow.
Developers Feel Faster. The Data Disagrees.
This is where the story gets genuinely interesting. Despite objective metrics showing slower delivery, developer sentiment is largely positive. LinearB’s analysis of 8.1 million pull requests found developers feel 20% faster while actually moving 19% slower — a 39-point gap between perceived and actual productivity.
Separately, 69% of developers report that AI agents increased their productivity. They are not wrong — generating a complex function in seconds feels like a win. The disconnect is that individual-level speed gains are being absorbed by system-level bottlenecks before they reach shipped software.
The risk for engineering leaders: surveying your team and hearing “AI is great” is not the same as measuring cycle time and seeing improvement. The tools are capturing mindshare faster than they are capturing throughput.
What Engineering Teams Should Actually Do
The problem is structural. The solution needs to be too. Four adjustments that address the actual bottleneck:
- Measure completion, not volume. Track cycle time, PR-to-merge time, and issue resolution rate — not lines of code or commit count. If your AI productivity dashboard shows commits, it is measuring the wrong thing.
- Cap PR scope from AI agents. Limit AI-generated PRs to roughly 400 lines of changed code. Smaller pull requests are reviewed faster and with higher accuracy.
- Treat review capacity as a budget line. Bain estimates teams need approximately 14% more reviewer capacity to handle AI-generated code volume at current defect rates. That is a resourcing decision, not a tooling one.
- Layer automated pre-review filters. Run AI review tools, static analysis, security scanners, and test coverage checks before any human reviewer sees the PR. Reduce the defect load before it hits the bottleneck. Tools like CodeRabbit and Graphite are purpose-built for this stage.
The Bottom Line
AI coding agents are not productivity multipliers — they are throughput redistributors. They shift where time is spent, not how much software gets shipped. Every team adopting them without rethinking their review workflow is buying a faster printer without budgeting for more paper.
The Harvard study is not an argument against AI coding agents. It is an argument against naive adoption. The teams that will close the productivity gap are the ones that treat code review as the critical path, not an afterthought.
More code is not the goal. Shipped software is.
