Here's a failure pattern I've watched repeat since AI coding tools went mainstream, and it has a misleading crime scene. A small team ships at astonishing speed for a couple of months — features flying, milestones falling, generated code pouring in. Then, somewhere around week eight or ten, the wall: small changes break distant things, velocity collapses, and everyone reaches for the familiar diagnosis. Technical debt. Messy code, rushed shortcuts, architecture sacrificed to speed.
But dig into these stalls and the autopsy keeps coming back wrong. Often the code is... fine. Sometimes it's genuinely well-structured — the generators are decent architects. What's actually broken is something no linter flags: nobody on the team can explain why key design decisions were made, or how the parts are supposed to fit together, or what will happen if they touch this module. The code survived the sprint. The team's understanding of it didn't — and neither did any record of what the thing was supposed to be.
I've come to believe we need a bigger ledger than "technical debt" to account for what's going wrong in AI-accelerated development. Three debts, not one — because a software system is not just its code.
A system is three layers, and debt lives in each
Strip any software system down and you find three distinct layers. There's the intent: the goals, constraints, and rationale the system exists to serve — what it's for. There's the code: the implementation that makes it executable. And there's the shared understanding: the living mental models, distributed across the team, of how the thing works and how to reason about changing it — what an older tradition beautifully called the theory of the system. No individual ever holds the whole theory; health means the team collectively holds enough of it to change the system safely.
Each layer accumulates its own debt, and the three could not be more different in character.
Technical debt lives in code. It's the classic: shortcuts that compromise future changeability, accruing interest until every modification costs double. Crucially, it's also the most manageable debt we have — decades of practice built an arsenal (refactoring, tests, review), it's visible in the artifact itself, and, in a twist worth savoring, AI is getting genuinely good at paying it down: automated refactoring, test generation, smell detection. The best-understood debt is the one the machines are learning to fix.
Cognitive debt lives in people. It's the erosion of the team's shared understanding — accumulating gaps in who-knows-what, models going stale, confidence quietly decoupling from comprehension. It limits not what the system can do but what the team can safely reason about.
Intent debt lives in artifacts — or rather, in their absence. It's the missing specifications, unrecorded decisions, constraints that exist only in two people's heads, the rationale nobody wrote down. It limits knowing what the system is for and whether it still serves the people it was built for.
The one-word diagnosis "tech debt" collapses all three into the layer we know how to see. That's exactly backwards for the AI era, because of what's happening to their relative sizes.
AI shrinks the visible debt and feeds the invisible ones
Here's the structural shift. When a human writes code — even bad code — the effort itself is a forcing function: you can't type an implementation without building at least a partial model of what it does, and you can't design without at least momentarily knowing why. Understanding and intent were by-products of the friction. Nobody managed them because nobody had to.
Generated code severs that coupling. The implementation arrives without the understanding ever passing through a human head, and the intent that shaped the prompt evaporates the moment the output is accepted. Meanwhile the sheer rate compounds the problem: AI produces code faster than any team can absorb it, so the gap between what-exists and what's-understood widens by default, invisibly, sprint after sprint. The likely trajectory is stark — the debt we're best at managing (technical) shrinking under automation, while the two debts we barely notice (cognitive, intent) accumulate at machine speed. Teams celebrating their velocity are often watching one balance decline while two others silently balloon.
The debts feed each other
What makes this a genuine model rather than a taxonomy is the interaction. Missing intent breeds cognitive debt: without recorded purpose, nobody — newcomer or veteran — can form an accurate model of the system. Cognitive debt breeds technical debt: people who don't understand a system make worse changes to it. Technical debt amplifies cognitive debt: messy code resists comprehension. And the loops run in reverse too — a team that understands its system writes better rationale; clean code is easier to theorize about. The three ledgers compound each other, which is why optimizing the one measurable layer while ignoring the others is how you get codebases that pass every quality gate while the team around them becomes unable to change anything.
Manage all three, or you're not managing
The practical upshot is a genuinely different management posture. For code health we have dashboards, linters, coverage metrics, review gates — an entire industry. For the other two layers, most teams have nothing: no measure of onboarding time, no map of knowledge concentration, no audit of the gap between documented purpose and actual behavior, no practice that even asks "who still understands this?"
Start by running the three-ledger check on your own team, honestly. Layer one: what does our code health tooling say? (You have an answer.) Layer two: if our most knowledgeable person left tomorrow, what fraction of the system could the rest of us confidently change? (Sit with that one.) Layer three: if a new engineer — or an AI agent — asked what is this system for and what must it never do, does any artifact answer, or only oral tradition?
Software health was never just code health; the friction of hand-writing simply let us pretend otherwise. AI removed the pretense along with the friction. The teams that thrive at generation speed will be the ones who noticed that three debts exist, and started keeping three books.
