AI Coding Agents Write 30% More Code, but Nothing Ships Faster

A Harvard study that started circulating this week put hard numbers on something a lot of engineering leads already suspected. After companies adopted AI coding agents, their developers wrote about 30% more code. The amount of finished work, measured as resolved tickets, barely moved.

The paper, by Fiona Chen and James Stratton, draws on roughly 300 million work events from 718 software firms between 2021 and March 2026 (the paper, Ars Technica). If you pay for coding agents, or pay a vendor who uses them, this matters. The bottleneck didn't go away. It moved to code review.

TL;DR#

• Firms that adopted AI coding agents saw lines of code rise 30% and pull requests rise 23%, with no statistically significant increase in issues resolved.
• Code review is where the gains stall: average review time went up 49% and the share of pull requests sent back for changes nearly doubled.
• Faster delivery from AI comes from better specs, tests and review capacity, not from generating even more code.

What the Harvard study on AI coding agents found#

The researchers used data from Jellyfish, an engineering analytics platform that tracks commits, pull requests and tickets. They compared firms before and after adopting agents against firms that hadn't adopted yet, which separates the tool's effect from industry trends.

Here's the core result for agents, measured per worker per month (Chen and Stratton):

Headcount didn't change measurably, so "agents will replace the team" doesn't show up in the data yet. And pull request size stayed flat, so reviewers weren't commenting more because diffs got bigger. They were finding more to fix.

Why more code doesn't mean more software#

Think of a factory where you double the speed of one machine but leave the inspection station alone. You get a bigger pile of parts waiting for inspection, not more finished goods.

The paper models software the same way: one stage writes code, a second reviews it. Agents speed up the first stage a lot. They don't speed up the second, and may make it harder.

Two reasons review gets heavier#

The authors describe two channels. The first is volume: more code arrives at the review queue. The second is quality: AI-written drafts may carry a higher bug rate, so each pull request takes more effort to check. The share of engineers doing review went up 14% after adoption, while the share writing code stayed the same.

There's also a ceiling. Jellyfish's data suggests engineers spend about 42% of their time coding (a survey in the same paper said nearer 30%). Even a perfect agent only touches part of the job.

The trust problem#

Developers don't fully trust what agents produce. A Sonar survey of more than 1,100 developers, reported by IEEE Spectrum, found 96% didn't fully trust AI output to work correctly, and 61% said it often looks right but isn't reliable. At Bonterra, code entering review rose tenfold after adopting AI tools and review times tripled.

Technical breakdown: where AI coding agents help and where they stall#

Here's the delivery pipeline in plain terms:

Spec -> Agent writes code -> Pull request -> Human review -> Merge -> Deploy
         (much faster)        (more of them)   (queue grows)

Everything left of review got cheaper. Review got more expensive per change. So time from idea to production can stay flat while every dashboard that counts commits looks great.

Can AI review the AI?#

That's the obvious fix, and companies are trying it. By March 2026 nearly 80% of firms in the sample had used AI code review tools, yet only 10.8% of pull requests received an AI-generated comment. AI review is good at a first pass: style, obvious bugs, missing null checks. It isn't good at asking whether the change matches what the business needed, which is the question that prevents expensive mistakes.

One caveat: the data covers clients of one analytics vendor over a short window, with adoption measured per firm rather than per developer. Treat it as strong evidence about teams, not a verdict on every tool.

What this means for businesses buying software#

If you run a scaling company without an internal tech team, you probably buy software from an agency or freelancer, and many now pitch AI as the reason they're faster or cheaper. Some of that is real. This study tells you where to look.

Ask who reviews the code and how. A vendor that generates fast but reviews lightly ships fast at first, then spends months fixing things in production. If the system touches fulfilment, billing or customer data, one bug costs more than the hours the agent saved.

Ask how they measure progress. Lines of code and pull request counts now say very little. Working features, resolved issues and post-release breakage are what count.

For MVPs and fixed-scope builds, the constraint has shifted. Writing code is no longer the slow part. Clear scope, good acceptance criteria and someone who can judge whether the output is right are what decide how fast you get to a real product.

How to get real speed from AI coding agents: a checklist#

These steps target the review bottleneck directly:

1. Write the spec before the prompt. IEEE Spectrum describes Amazon engineers writing detailed specs before generating code. One missing instruction produced 25,000 lines in the wrong Swift version; once the spec was fixed, the rework took about 15 minutes.
2. Keep changes small. Small pull requests are faster to review and easier to roll back.
3. Make tests the first gate. Agent-written code should arrive with tests that pass in CI before a human looks at it.
4. Use AI review for the first pass only. Let it catch style and obvious defects so people can focus on logic and business rules.
5. Make authors explain their changes. Temporal requires engineers to explain an agent's design choices in their own words, or the reviewer rejects the code.
6. Plan for review capacity. If more of your team's time goes to review, schedule it rather than letting the queue silently grow.
7. Track delivery, not output. Watch lead time to production, issues resolved, escaped defects and review queue age.

How MagicMakers Lab approaches this#

We use AI coding agents on almost every project, and we plan our sprints around the review stage, not the typing stage. That means written scope up front, tests in CI and an engineer who reads and owns every merge. It's the reason a Rapid MVP Sprint can end in a deployed product in 2–6 weeks without a cleanup phase afterwards. Systems like the Framico fulfilment pipeline, which ships 200+ orders a day with zero manual steps, only hold up when every change is checked by someone who understands the business rules behind it.

Key takeaways#

• AI coding agents raised code output by about 30% across 718 firms, but resolved issues didn't rise significantly.
• Review time grew 49% and rework requests nearly doubled, so review is the new bottleneck.
• AI review tools are widely tried but still comment on a small share of pull requests.
• Specs, small changes, automated tests and explicit review time turn generation speed into delivery speed.
• When hiring a vendor, ask how they review AI-written code, not just how fast they write it.

FAQ#

Do AI coding agents actually make developers more productive?#

They make developers produce more code. The Harvard study found 30% more lines of code and 23% more pull requests after firms adopted agents. But resolved issues showed no statistically significant gain, so the extra code didn't turn into proportionally more finished work. Productivity at the team level depends on what happens after the code is written.

Why does AI-generated code take longer to review?#

There's more of it, and it may contain more bugs per change. In the study, review comments per pull request rose 35% even though pull request size stayed flat. Developers also report that AI code often looks correct while hiding subtle problems, which forces reviewers to read more carefully instead of skimming familiar patterns.

Can AI code review tools fix the review bottleneck?#

Partly. Nearly 80% of firms in the study had tried AI code review by March 2026, yet only about 11% of pull requests received AI comments. These tools help with a first pass on style and obvious defects. A human still needs to judge whether the change does what the business actually needs.

Will AI coding agents reduce the need for software engineers?#

Not according to this data so far. The study found no measurable change in headcount after agent adoption. What changed was how engineers spend their time: more of them now do code review. Over a longer period that could shift, but today the work is moving between tasks rather than disappearing.

If your team or vendor ships more code but features don't land faster, the problem is probably scope and review, not the tools. We'll look at your delivery process or planned build and show you where the time goes. Book a free audit.

Sources#

• Artificial Intelligence in the Firm: Bottlenecks in Software Production (Chen and Stratton, Harvard)
• AI coding agents generate more code, but not more software (Ars Technica)
• AI Slop Is Changing How Engineers Review Code (IEEE Spectrum)