In an enterprise, once a software team is onboarded to use AI agents at scale, the commits keep piling up and PRs (pull requests) are being opened at a rapid pace. The progress looks great to leadership, at least when it comes to AI adoption, but the product roadmap barely seems to change. So where did all the time saved using AI agents go?
Harvard researchers Fiona Chen and James Stratton are trying to answer that question. Having analyzed roughly 300 million engineering activity records across 718 companies, they estimated a 30% increase in lines of code and a 23% rise in pull requests. Yet the increase in completed Jira issues (stories and other tasks) and larger projects (epics) was not statistically significant.
If you’ve worked in software development, you can probably guess where the bottleneck is without even reading the study.
Ta-daaa! Yes, you guessed it. Code review. At least, that's where the researchers found much of the slowdown.
For anyone unfamiliar, code review is where another developer examines your changes before they’re merged into the codebase, checking for bugs, missed edge cases, and whether the changes make sense.
The researchers found that the average time between submitting a PR and merging it increased by 49%. Comments per PR increased by 35%, and the share of PRs requiring changes nearly doubled.
That 49% doesn’t mean reviewers spent 49% more time actively reading code. It includes waiting, discussions, and back-and-forth changes. But it does suggest that code was taking longer to get through the review process.
Now, the obvious question is, do we need more people reviewing all this AI-generated code? Or could we catch more of these mistakes before they reach another developer?
Lauren Tan, an engineer working on Grokbot/SpaceXAI, recently made an interesting argument about this. She describes the codebase itself as a form of memory for AI agents. Agents learn patterns from the code that’s already there, including the bad ones. So instead of repeatedly fixing the same mistakes during code review, why not make the codebase better at preventing them?
Think about it. We’ve had compilers, type systems, lint rules, and automated tests for years. If an agent keeps using an outdated API, add a check that rejects it. If the same bug keeps appearing, write a regression test. And if agents keep introducing the same architectural problems, perhaps the codebase needs better interfaces that make those mistakes harder to introduce.
The interesting part is that these improvements don’t just help the next developer. They also help the next AI agent working on the repository. Better patterns give agents better examples to follow, while automated checks prevent them from repeating mistakes we’ve already caught.
Of course, this doesn’t mean human code reviews will disappear. Tests can’t tell us whether we’re building the right feature, and the Harvard study doesn’t establish that all the additional review time came from bad AI-generated code.
But it does raise an interesting question. We’ve spent a lot of effort making agents better at writing code. Shouldn’t we also spend more effort making our codebases better at verifying what they write?