When AI Builds Faster Than Engineers Can Understand
A study of 802 developers found AI doubled the pull requests written by those active three months or more, while the share getting a human review fell from 89% to 68%. Code now changes faster than teams can explain why it changed. That gap can be measured through the decisions behind each change.
Output doubled. Review did not.
In July 2026, a team of six researchers posted AI Writes Faster Than Humans Can Review, a study of one company that told its engineers to double their output with AI. They followed 802 developers and 196,212 pull requests from January 2024 to April 2026.
The mandate worked on its own terms. By the tenth month, among developers active for at least three months, the mean number of pull requests each one authored had risen from 21.2 to 44.3 a month, 2.09 times the baseline. On the company's own measure, merged pull requests per engineer, the rise was 2.31 times.
The review side moved differently. Total pull request volume, which counts every author, grew 3.1 times while the pool of reviewers grew 1.5 times, so each reviewer's load roughly doubled. The share of pull requests that got a human review fell from 89% to 68%. The share with an automated review rose from about 19% to about 84%. A pull request can get both kinds, so the two shares overlap.
The study covers one company, it is not randomized, and the authors call their estimates an upper bound. It is still a detailed record of what happens when implementation scales and human attention does not.
Three questions every change has to answer
A change to a production system has to answer three separate questions before a team can stand behind it:
| Question | What answers it | What AI did to it |
|---|---|---|
| Implementation: can the change be built? | An engineer or an agent writing the code | Made it much cheaper and faster |
| Verification: does the change behave correctly? | Tests, CI, automated and human review | Automated much of it, at growing review cost |
| Comprehension: does the organization know why the change exists and what it must preserve? | People who understand the system's decisions | Still depends on people, whose numbers and hours did not double |
Comprehension here is more than reading code. It means knowing why a boundary exists, which alternatives were rejected, where a dependency comes from and who may change an earlier decision. A reviewer can confirm that a function returns the right value without knowing any of that.
The three questions used to travel together. An engineer who wrote a change usually understood it, and the reviewer who approved it learned something about it. With agents, implementation and verification can complete without anyone answering the third question. We call the difference between the rate of change and the rate of understanding the comprehension gap.
A team can now ship a change that is built and verified, and that nobody on the team can explain.
Review is stretched thin
Three other sources show where review effort goes when output rises.
A March 2026 study, Human-AI Synergy in Agentic Code Review, analyzed 278,790 inline review conversations across 300 open-source projects. When people reviewed AI-generated code, they went through 11.8% more rounds of back-and-forth than when they reviewed code written by people. When an AI agent started the review, 85.2% to 86.7% of conversations ended after its first comment, with no follow-up, so most AI review comments drew no human discussion. The study is a preprint, and its sample is open source rather than enterprise.
Google's DevOps Research and Assessment (DORA) 2025 report, based on a survey of nearly 5,000 technology professionals, found that 90% use AI at work and that AI now raises delivery throughput while still increasing delivery instability. Its authors describe friction shifting from manual work to deciding and verifying. A March 2026 DORA article on balancing AI tensions describes time saved by AI being spent again on verification.
Read together, the sources describe the same movement. Human review covers a shrinking share of changes and takes more rounds per change, while automated review, which mostly checks the code itself, covers more. The time people have for the third question, why the change exists and what it must preserve, is what gets squeezed.
How a working change erodes understanding
The gap does its damage through changes that work. Consider a team whose services read customer data only through a shared data-access layer. It made that decision after two services drifted onto different schemas and a migration broke both.
An agent is asked to add an export feature. It queries the database directly from the handler, because that path is shorter and the tests pass. Automated review finds nothing wrong, since nothing is wrong with the code itself. A busy reviewer approves a small, correct-looking pull request.
The next agent asked to add a similar feature searches the repository for an example, finds the direct query and copies it. So does the one after that. Within a quarter, a shortcut taken once has become the codebase's working pattern, and the original decision survives only in the memory of the engineers who made it.
No single step was a mistake anyone could catch by reading code. The failure was that the authoritative decision was not available to the agent, the automated reviewer or the busy human at the moment it mattered. Each change was verified. None was checked against what the system was supposed to remain.
Measuring the gap
No study yet measures a fall in human comprehension directly. The evidence shows rising output and rising review pressure, and the comprehension gap is our reading of what those two together imply. It is a hypothesis that teams can test, not a proven law.
One way to frame it: count the architectural changes a team makes over a period, and count how many of them the team can connect to an accepted decision and explain. The difference, the changes nobody can yet explain, is the comprehension backlog. Turning that into a metric needs consistent definitions of a change and of understanding, which no team has standardized. These candidate indicators come closer:
| Indicator | What it reveals |
|---|---|
| Decision coverage | How much of the architecture that matters has an explicit, recorded decision behind it |
| Decision-to-change traceability | Whether an architectural change can be linked to the decision that allows it |
| Unresolved conflicts | How many changes conflict with a recorded decision and were never reconciled |
| Architectural rework rate | How often later changes reverse earlier design choices |
| Decision recovery time | How long an engineer needs to explain why a component is built the way it is |
None of these is a validated benchmark. Each one is cheap to sample, and each one can show the gap before an incident does.
What engineering leaders should do
- Stop reading throughput as progress on its own. Pair every output metric with one of the indicators above. A doubling of pull requests with flat decision coverage means the backlog of unexplained change is growing.
- Record the decisions agents most often break. Start with the boundaries that cost you an incident: data access, service ownership, approved dependencies. Write each one down with its scope and its reason.
- Move checkable decisions out of review. A rule a machine can check should be checked by a machine on every change. That frees reviewers to spend their attention on the changes that need judgment.
- Keep humans on the exceptions. Route changes that touch a recorded decision, or conflict with one, to a person who owns it. Let the rest flow.
Where Mneme fits
Mneme, an open-source decision and control layer for agentic software development, works on the checkable part of the gap. It does not create understanding, and it does not replace the people who hold it. Decisions that are ambiguous, conflicting or not machine-checkable still need human judgment.
Mneme enforces decisions that carry an active typed rule: a rule a machine can check, such as an exact piece of text that must not appear in code, optionally limited to certain paths. A rule that forbids the database driver's import in handler directories, with the data-access layer excluded, returns a FAIL when an agent's change adds that import, and the violation names the decision it broke. A decision without an active typed rule is not enforced.
The checks run in continuous integration (CI) and in coding agents including Claude Code, and the command-line interface (CLI) agents Codex CLI and Kiro CLI 3.0, where each agent's native write tools are checked before the write lands. Decisions live in the Decision Index, Mneme's persisted, versioned record of a repository's decisions, with each decision's lifecycle status and, where known, its source. That record is what a team counts when it measures decision coverage. It does not record who approved a decision.