Technical debt has always been defined as a property of code: implementation shortcuts that are expensive to change later. That definition is now incomplete. The liability accumulating fastest in AI-assisted engineering organizations is the distance between the code that exists and the number of people who understand it.
The clearest available analysis of this problem was not written about software. In August 2026, Terence Tao published "Mathematics in the Age of AI," based on a lecture at the International Congress of Mathematicians. Tao declines to argue about whether AI systems can perform research mathematics. He assumes a strong version of that claim and examines what the mathematical community actually optimizes for. His conclusion transfers directly to software delivery.
Tao takes problem solving as a case study and begins with the stated objective: solve as many unsolved problems as possible. He then revises it four times.
Optimizing for solution volume produces incorrect solutions, which adds a verification stage. Verification produces proofs that are formally correct and that no one understands. Tao notes that the Erdős problems database already contains dozens of AI-generated submissions where no expert has volunteered to verify them, and where several submitters have stated they are not qualified to do so. That adds an exposition stage. Exposition is insufficient because a result contributes only when other mathematicians absorb it, which adds an acceptance stage. Acceptance is not the end, because the final stage is canonicalization: restating a result in its natural generality, giving it its right proof rather than its first proof, and absorbing it into the standard reference material.
One arrow becomes five stages. Tao's central observation is that only the first stage was ever an explicit goal. The remaining four were implicit, unfunded, and assumed to follow.
Those stages have now decoupled. Tao invokes Strathern's formulation of Goodhart's law, under which a measure ceases to be a good measure once it becomes a target. Generative systems locate the gap between a proxy and the property it was standing in for, and the commercial incentives of the AI industry reward precisely the benchmarkable proxies that historically correlated with everything else.
The same five stages exist in software delivery. Generation is writing the code. Verification is the test suite, type system, static analysis, and CI. Exposition is readable structure, the pull request description, and the architecture decision record. Acceptance is review, merge, and assumption of ownership. Canonicalization is the point at which a pattern enters a shared library, a platform capability, or an internal standard.
AI reduces the cost of the first stage to near zero and contributes materially to the second. It does not perform the remaining three, and it reliably produces artifacts that resemble them without the transfer of understanding that gives them value.
The measurement evidence is consistent with that asymmetry. The 2025 DORA State of AI-assisted Software Development report, based on responses from nearly 5,000 technology professionals, found 90 percent AI adoption, a positive correlation between adoption and delivery throughput, and a negative correlation with delivery stability. Faros AI, analyzing telemetry from more than 10,000 developers, reported teams with high AI adoption merging 98 percent more pull requests while review time increased 91 percent.
Tao names the resulting condition the transition from proof scarcity to proof abundance, and observes that institutions designed under scarcity should not be expected to behave well under abundance. Sprint velocity, story points, commit counts, and pull request throughput are scarcity-era instruments. They measure the first stage.
The term for what accumulates in the later stages originates outside software. In "Your Brain on ChatGPT," Nataliya Kosmyna and colleagues at the MIT Media Lab ran 54 participants through repeated essay-writing sessions using an LLM, a search engine, or no tools. EEG measurement showed brain connectivity scaling down with the amount of external support. The LLM group reported the lowest sense of ownership over their own essays and had difficulty quoting work produced minutes earlier. The authors named the pattern cognitive debt.
The distinction matters. Technical debt is code that is expensive to change. Cognitive debt is code that no one on the team can explain. They are separate liabilities, they register on different instruments, and only one is addressed by refactoring.
Tao argues that exposition can be over-optimized. A proof can be written too smoothly, presenting routine steps and genuinely difficult steps as equally easy to absorb. In human-written work, the difficult passages retain friction: an unusually careful lemma, a change of notation, a paragraph clearly rewritten several times. That friction indicates where a reader should slow down and is a primary channel for transmitting the tacit knowledge of a field. Excessive polish removes it.
The same applies to agent output. A trivial helper and a subtle concurrency boundary arrive formatted identically, commented identically, and named with the same even competence. Nothing in the diff marks where a careful engineer would have hesitated. GitClear, analyzing 211 million changed lines of code, found duplicated blocks rising roughly eightfold and refactoring falling as a share of all changes. Duplication is the observable residue of code generated rather than understood, since knowing that an abstraction already exists is a property of understanding the system.
The failure is structural rather than individual. Five teams asking an agent for a retry policy receive five locally correct implementations. Each passes review. No pull request raises the question of what the system's retry semantics are, and that question is first asked during an incident.
Software differs from mathematics in one respect that matters here. A proof is both the result and its explanation. Code is not. The layer the machine executes stopped being readable decades ago, and nobody reads emitted assembly, bytecode, or a minified bundle. That boundary held because the transformation below it is deterministic and fully determined by the source above it.
Generation moves the opaque layer upward without those properties. A prompt does not reliably produce a given implementation, is not versioned as the definition of behavior, and cannot be used to regenerate the code. Treating generated source as a compiler target is therefore premature.
The requirement is narrower than readable code everywhere. The layer a team maintains and modifies has to be readable, and it has to be the highest layer that fully determines behavior. Today that is still the source.
The productivity evidence is unsettled. METR's randomized controlled trial of early-2025 tools found experienced developers 19 percent slower with AI assistance while estimating they were 20 percent faster. METR published revised data in February 2026 indicating a measured speedup with late-2025 tools. Findings on stability, review load, and duplication have been more stable than findings on speed.
The cognitive debt research is not about code. The MIT Media Lab study is a preprint with 54 participants performing essay writing in an educational setting. It is an analogy to engineering work, not a measurement of it.
Tao's analysis is conditional. He assumes a capability claim rather than defending one. The pipeline argument holds regardless of how the capability question resolves.
Cognitive debt predates AI. Most large organizations already owned systems no current employee fully understood. AI changes the rate of accumulation, not the existence of the failure mode.
Generation was never the constraint that made software valuable. Understanding was. An organization that measures only what it produces will not detect the point at which it stops understanding what it owns.
83% faster delivery. Under 10% rework. See exactly how Xceptor got there.
