AI Writes Twice as Much Code. Who Reviews It?
AI has nearly doubled merged pull requests and review can't keep up. Five common beliefs about reviewing AI code, and what actually holds up.
August 6, 2026 · 5 min read
Your teams ship more code than ever, and nobody has time to read all of it. Most engineering leaders know this. Fewer agree on what to do about it, partly because a handful of comfortable beliefs keep the question from being asked properly. Here are five of them, and what we think holds up instead.
Belief 1. “Review will catch up”
The numbers point the other way. In The AI Productivity Paradox (July 2025, 10,000 developers across 1,255 teams), Faros AI found that teams using AI merged 98% more pull requests while time spent in review rose 91%. Production sped up. Review became the bottleneck.
And the volume keeps climbing. GitHub’s Octoverse 2025 report counts close to one billion commits pushed in 2025, up 25%. Each commit changes your software, and each change is a chance to break something that used to work. Hiring more reviewers won’t keep pace with that curve.
Belief 2. “Our developers check AI code carefully”
Most of them would like to. Sonar’s State of Code Developer Survey (January 2026, more than 1,100 developers) reports that 96% don’t fully trust AI-generated code, yet only 48% always verify it before committing. The Stack Overflow Developer Survey 2025, with 49,000 respondents, points the same way. In it, 29% say they trust the accuracy of AI output, down from 40% in earlier years.
Doubt followed by approval is the real pattern. Teams have reservations and merge anyway, because the queue never empties. Over time people stop touching existing code. They add around it, wrap it, work past it. The software keeps growing while the team’s grip on it loosens.
Belief 3. “Clean code that passes tests is correct code”
Picture a retail app with a loyalty program. The rule, agreed with marketing two years ago, says points expire 12 months after the member’s last purchase. A developer asks an assistant to add a “points expiring soon” reminder email. The assistant returns three hundred tidy lines with good names and green tests. Somewhere inside, to work out which points are about to expire, it reimplements expiry as 12 months after each point was earned, a version it picked up from an old ticket.
The reviewer skims it between two meetings. Nothing looks wrong, because the code is fine as code. It simply implements a different rule. The tests pass because they were written alongside it, from the same misunderstanding. A few weeks later, active members start losing points they should still have, and support can’t say when it began.
Belief 4. “Another AI can review the first one”
AI code review tools read code line by line once it’s written. They catch a poor name, a swallowed exception, a classic vulnerability. That’s useful work, and you should keep doing it.
What they can’t tell you is whether the code does what your business intended, because intent is absent from the diff. In the loyalty case, an AI reviewer has no way to know that expiry runs from the last purchase. Answering that requires a reference outside the code, a record of what you meant to build. At Lyriks we treat code as the source of the implementation and keep the source of truth somewhere else, in what you set out to do: business rules, journeys, invariants. As long as that intent lives in scattered tickets and in two senior engineers’ heads, no amount of review settles the question.
Consistency is the other problem. Ask a model twice whether a change respects a rule and you may get two answers. That variability is fine when writing code. It becomes a real issue when the answer decides whether something ships.
Belief 5. “Verifying everything means specifying everything first”
You can start much smaller. Pick the places where AI touches code most often, or where nobody dares to change anything, and work rule by rule from there.
Here is how the loop runs. The validated spec goes to the LLM you already use (Claude Code, Cursor or Copilot through MCP) along with its rules and their sources. The LLM writes the code. A deterministic engine checks the result against each rule: same code, same spec, same verdict. Every gap goes back to the LLM, and the loop continues until 100% of the rules hold.
On the reminder email, the engine flags a gap on the expiry rule, since the computed date no longer matches “12 months after last purchase.” The fix goes back to the assistant, and the work counts as compliant only once the rule holds. The engine behind that check is built on graph rewriting, developed in-house, and is patent pending. Same question, same answer, today and next week, so you can write a release policy around it.
Each release gets a compliance report that sorts every item four ways. Compliant. Addition, built without being asked for. Omission, planned but missing. Regression, something that used to work and broke. Reviewers stop hunting through three hundred lines and read a short list of named gaps, each tied to a rule and to the code involved.
It runs on your infrastructure, too. The engine is open source under the AGPL, installs with one command, and runs on-premise or air-gapped with no outbound connections, using your own LLM and tokens.
So who reviews it?
People still do. They just review something else. Instead of reading every line in the hope of spotting a misplaced date, they read the list of places where the code departs from a rule they agreed on, and decide what to do about each one. Humans are good at that job, and they can keep up with it.
The Verify AI code page lays out the full approach. To see it on your own repository, book a demo.
Go further
White paper · free · 15 pages
Verifying AI-written code: a deterministic approach
The verification gap in numbers, the three gaps to look for, why the check must be deterministic, and how a verification loop fits next to code review.
Thank you. Download the PDF