Verification Was Never the Bottleneck. Comprehension Is, and You Can Build for It.

For two years the working assumption in AI-assisted engineering has been that verification is the tax you pay for speed. We argued it ourselves in The AI Verification Debt: 96% of developers distrust AI output, only 48% verify it, and the distance between those two numbers compounds daily. Geoffrey Litt, writing in July 2026, moves the frame one step forward. As agents get better at checking their own work, the constraint that actually binds is comprehension. Can a human still understand the system well enough to steer it?

That question sounds soft next to a security scan. It is the harder one. Verification is increasingly something a machine can do to its own output: run the tests, generate the property checks, critique the diff, produce a proof obligation and discharge it. Each of those is a bounded task with a pass or fail. Comprehension has no pass or fail and no agent can do it for you. It lives in a human head, and it decays.

The Debt That Shows Up on Loop Three

Litt’s observation goes further than saying comprehension is nice to have. Comprehension is the resource you spend without noticing. You accept the first agent-built module because it works and the tests are green. You accept the second because the first one did. By the third or fourth loop you are approving changes to a system you no longer hold in your head. The output is still correct. Your ability to set its direction is gone.

This is the mechanism behind what we called cognitive debt. Early loops feel fast because the agent absorbs the labor. The cost is deferred and invisible: each unread diff shifts a little more of the system into territory only the agent has visited. When a genuinely new requirement arrives, the kind that needs a human to invent a direction rather than approve one, the mental model required to do that has quietly eroded. You can still verify. You can no longer imagine.

Correct-but-incomprehensible is a worse failure mode than wrong-and-obvious, for the same reason “almost right” code is worse than code that does not compile. Nothing alerts you. The velocity dashboard stays green while the trajectory-setting capacity of the team drains out of it.

Four Artifacts You Can Build This Quarter

The useful part of Litt’s piece is that it treats comprehension as something you build rather than a virtue to exhort. He sketches four concrete artifacts, and none of them require new model capability. They require deciding that understanding is part of the definition of done.

An /explain-diff skill. Point it at a change and it produces an explainer ordered for learning rather than for chronology. Git shows you what happened in commit order. A pedagogical explainer starts from the concept a reader needs first, then the change that depends on it, then the edge that only makes sense once the first two are in place. The agent that wrote the code is well positioned to teach it, because it holds the full intent that the diff itself discards.

A five-question comprehension quiz that gates circulation. Before a change is allowed to merge or ship, the system generates five questions from it, and a human has to answer them. The system asks actual questions about what the code does and why, and a rubber stamp on the PR will not answer them. The point is to make the loss of comprehension visible at the moment it happens, while the context is still recoverable, instead of on loop three when it is gone. Catching cheaters is beside it.

Interactive micro-worlds. A small, runnable environment where a person can step through the new behavior with real inputs and watch state change. Reading a diff is passive. Driving a system is active, and active engagement is how understanding actually forms. A micro-world turns a wall of text into something you can poke.

Shared human-and-agent planning spaces. Comprehension built during construction is cheaper than comprehension reconstructed after. If the plan is co-authored, a document both the human and the agent read from and write to before code exists, the human enters the review already holding the intent. The alternative is forensic: reverse-engineering a decision process from an artifact that never recorded it, which is precisely the debugging problem we described for unverified AI code.

The Quiz Is a Speed Regulator, Not a Gate

The instinct on reading “quiz that blocks the merge” is to hear a bureaucratic checkpoint. That reading misses the design. A blunt gate stops everything at a fixed cost. A comprehension quiz costs nothing when the human already understands the change and costs real time only when they do not. It is a governor on an engine, applying resistance in proportion to how far the human has fallen behind the agent.

That property matters because it makes the control self-scaling. On a well-understood, low-risk change the human answers five questions in a minute and the loop runs at full speed. On a change that has quietly drifted beyond anyone’s mental model, the quiz gets hard, the human slows down, and the slowing is exactly the correct response. The system regulates its own pace against the one variable that dashboards never capture: whether a person still knows what is being shipped.

Comprehension Is a Governance Control

The intellectual lineage here is older than agents. Seymour Papert argued that people build understanding by building things, not by being shown finished results. Andy Matuschak has spent years demonstrating that reading produces the illusion of understanding while active recall produces the real thing, which is exactly what the quiz operationalizes. Alan Kay designed systems you could see into, on the premise that a tool you cannot inspect is a tool that thinks for you rather than with you. The through-line is participation. You understand a system by inhabiting it, not by supervising its output from the outside.

That reframes comprehension from a personal habit into an organizational control, which is the same move we made with verification. Verification became infrastructure when teams stopped hoping individuals would review carefully and started budgeting review into the pipeline. Comprehension follows the same path. It can be instrumented: an explainer generated on every diff, a quiz gating circulation, a planning space that exists before the code. Each one is a place where the system checks that a human is still in the loop as a thinker rather than only as an approver.

This is the next move after verification debt, and it inverts the priority. Once agents can verify their own correctness, the scarce resource is no longer confidence that the code works. It is the human capacity to still change where the code is going. Governance that only measures correctness will report all-green while that capacity disappears.

Do This Now

Pick your highest-velocity repository, the one where agents are shipping the most and humans are reading the least. Add one artifact: the five-question comprehension quiz on merge. Do not gate anything yet. Just generate the questions and record whether the humans on that repo can answer them. Within two weeks you will have something no velocity metric gives you, a direct reading of how much of your own system your team still understands. If the answers are getting worse, you have found the debt before it found you. Then build the /explain-diff skill, because the fastest way to pass the quiz is to have been taught the change well in the first place.

---

This analysis synthesizes Understanding is the new bottleneck (Geoffrey Litt, July 2026), a single thought piece whose value is its inversion frame and its four concrete artifacts rather than any dataset.

Victorino Group helps engineering organizations turn comprehension into a governance control, instrumented in the pipeline rather than left to individual discipline. Let’s talk.