Analysis Engineering performance 8 min read

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:

QuestionWhat answers itWhat AI did to it
Implementation: can the change be built?An engineer or an agent writing the codeMade it much cheaper and faster
Verification: does the change behave correctly?Tests, CI, automated and human reviewAutomated 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 decisionsStill 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:

IndicatorWhat it reveals
Decision coverageHow much of the architecture that matters has an explicit, recorded decision behind it
Decision-to-change traceabilityWhether an architectural change can be linked to the decision that allows it
Unresolved conflictsHow many changes conflict with a recorded decision and were never reconciled
Architectural rework rateHow often later changes reverse earlier design choices
Decision recovery timeHow 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

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.

Frequently asked questions

What is the comprehension gap in AI-assisted software engineering?+
It is the difference between how fast a team's systems change and how fast the team can understand those changes: why each exists, which decisions govern it and what later changes must preserve. AI coding agents raise the rate of change sharply, while the human capacity to understand changes grows slowly. It is a hypothesis supported by rising output and review pressure, not yet a measured quantity.
Is the comprehension gap the same as a review backlog?+
No. A review backlog counts changes waiting for review. The comprehension gap counts changes nobody can explain, including ones that passed review.
How can engineering leaders tell whether implementation is outpacing understanding?+
Pair output metrics with decision indicators: how much of the architecture has a recorded decision, whether architectural changes can be traced to an accepted decision, how many conflicts with recorded decisions remain unresolved, how often later changes reverse earlier choices, and how long an engineer needs to explain why a component is built as it is. None is a validated benchmark, but each is cheap to sample.