The ACM Queue August issue published two related papers. The myths paper got the coverage — fourteen percent coding time, misapplied line-of-code metrics, the usual. The second paper, "From Technical Debt to Cognitive and Intent Debt," received less attention and makes the more durable argument.
It names a third type of debt most teams haven't started tracking: intent debt. Technical debt is about code quality. Cognitive debt is about understanding — the erosion of shared knowledge about how a system works. Intent debt is different. It's the absence of externalized rationale: the goals, constraints, and tradeoffs behind implementation decisions that developers used to record somewhere and now increasingly don't.
AI is producing intent debt at scale, and the tools we use to measure codebase health are not looking for it.
What the Three Debts Actually Mean
Technical debt is concrete. You run a static analyzer, you see issues per line, you fix them. Cognitive debt is harder to see but recognizable: a developer who has been out sick for two weeks returns to find they can no longer confidently predict the effects of changes in a module they wrote six months ago. New team members take months to become productive because nobody fully understands the system they're entering.
Intent debt is subtler than either of those. A codebase with high intent debt can have clean code and documented behavior. The tests pass. The architecture is clear. But when you need to change something — add a feature, fix a performance issue, refactor a module — you find you cannot reconstruct why the implementation took the shape it did. Was the unusual approach chosen because of a specific constraint from a third-party library? A security requirement that was later removed? A performance tradeoff that was accepted because of a now-irrelevant scale assumption?
The code doesn't say. No commit message explains it. The PR description describes what changed, not why this specific approach satisfied whatever constraints existed at the time. The people who made the decision have moved on, or don't remember, or were never asked to write it down.
This kind of debt has always existed. Teams have always had gaps between what they knew when they made a decision and what they preserved for the next person. What's changed is the rate at which those gaps accumulate — and the source of the problem.
Why AI Specifically Makes This Worse
When a human developer writes complex code, the rationale tends to leak into surrounding artifacts whether the developer intends it to or not. "Using the cursor-based approach here because the offset-based one breaks on concurrent writes" ends up in a commit message or a Slack message or, sometimes, a comment. The reasoning exists somewhere, even if it isn't formally documented, because a human held it in mind while writing.
AI doesn't do this. A coding agent produces the implementation. It does not produce the constraint-map that the implementation was satisfying. When Cursor or Claude Code or Copilot writes a module, it knows what code to write — and it does that part well — but it doesn't know why a previous developer rejected an alternative approach, what production failure shaped the current validation logic, or which requirements made this data model the right one versus three others that would also have compiled correctly.
The generated code is the answer without the question. Anyone reading it later — whether human or AI — can see what was done. They cannot recover why.
This isn't fixed by asking the model to add comments. Comments generated after the fact describe behavior, not reasoning. An AI-generated comment that says "validates user input before processing" doesn't tell you why this validation runs here instead of earlier in the pipeline, or what broke in production before someone added it. The rationale that would explain the decision isn't in the model's context; it was never captured anywhere. Comments without rationale are documentation theater.
What Intent Debt Actually Costs
The most concrete signal is code churn. A GitClear analysis of 153 million lines found that 40% of AI-assisted code gets rewritten within two weeks — up from 33% in pre-AI baselines. Some of that churn is inevitable: requirements change, approaches turn out to be wrong. But a significant fraction represents the specific failure mode of intent debt: code that passed review and even tests but violated a constraint that wasn't written down anywhere. The review surfaced the constraint. The code had to be scrapped and rebuilt with it in mind.
The Opsera benchmark found AI-generated pull requests wait 4.6 times longer for review than human-authored ones. Partial cause is unfamiliarity and trust gaps. But another cause is that reviewers are doing archaeology — trying to reconstruct whether the implementation accounts for constraints they remember but can't find documented anywhere. The code doesn't answer that question. Someone has to ask.
The harder version of this problem is AI agents compounding AI debt. When a coding agent in 2026 works on a codebase that a coding agent built in 2025, the new agent reads code without rationale and generates more code without rationale. Each generation of AI-produced code without accompanying reasoning artifacts makes it harder for the next generation to work safely with the system. Technical debt is visible to tools. Cognitive debt is visible to humans who know the system. Intent debt is invisible to both.
Where Intent Currently Lives
Teams that manage intent debt are capturing it before code gets written, not after. Architecture decision records, design docs, pre-implementation memos that specify not just what will be built but what constraints the implementation must satisfy and what alternatives were rejected. These artifacts exist independently of the generated code and don't require the AI to produce them.
The ratio of planning time to coding time is a rough proxy for how much intent is being captured. A developer who spends two hours in a design document before writing a line of code is externalizing constraints. A session that moves directly from a vague issue description to a coding agent has no externalized constraints — the agent infers what it can and the reasoning remains inside the model's context window, which expires.
At xeve, we track time at the application level across your full day. The pattern we see in developers who accumulate less technical debt isn't necessarily less AI use — it's a distinct gap between thinking time and coding time. Design tools, documentation editors, and structured planning appear in the session log before the IDE does. It's not a perfect signal. But it's a signal that intent was being captured before the code was generated.
The Accounting Problem
The ACM paper's triple debt model is useful because it separates things that behave differently and require different interventions. Technical debt can be addressed by tooling. Cognitive debt can be addressed by knowledge management, onboarding, and review culture. Intent debt requires a different discipline: externalizing reasoning before implementation, consistently, even when AI makes implementation feel instant.
The economic pressure runs the other direction. When AI can turn a spec into a PR in twenty minutes, everything upstream of that — the thinking, the design, the constraint-capturing — feels like overhead. Most development metrics don't count it. The pull request exists; the commit is real; the feature shipped. The reasoning behind it aged out of everyone's memory and was never written down.
That gap doesn't show up in velocity dashboards this quarter. It shows up when someone needs to change the code and can't figure out what they'd be breaking.