Intent Debt: The AI-Era Debt Nobody Is Tracking

Technical debt is in the code. Cognitive debt is in your head. Intent debt is in the artifacts.

Martin Fowler published a short fragment on April 2 that is quietly the most important framing I have read on AI-era software engineering this quarter. The HN thread is sitting at 192 points and 46 comments as I write this, and the conversation under it is the kind of conversation every team shipping with coding agents needs to be having out loud.

The core idea comes from Margaret-Anne Storey, which Fowler summarizes. System health is not a single axis. It is three layers. Each one can fall behind independently. Each one has a different remediation path. And if you are only tracking the first one, you are flying blind on the other two.

Technical debt lives in code

The original definition, unchanged. It accumulates when implementation decisions compromise future changeability. Shortcut here, duplicated helper there, stringly-typed API that grows three dialects over six months. Tech debt limits how the system can change.

Tech debt is the easy one to see. You can grep for it. You can measure it with linters, cyclomatic complexity, duplication percentage, and the smell-of-the-week. Every engineering team in the world has a shared language for this kind of debt.

Cognitive debt lives in people

This is the one the AI discourse has already latched onto. It accumulates when shared understanding of the system erodes faster than it is replenished. Cognitive debt limits how teams can reason about change.

A team can have perfectly clean code and still carry crushing cognitive debt. Someone wrote the module six months ago, shipped it, left the company. The tests pass. The code is tidy. Nobody left on the team understands why the retry logic uses exponential backoff with jitter rather than a fixed interval. Cognitive debt is the gap between "the code works" and "the team can still explain why it works."

AI agents accelerate cognitive debt. They generate code that nobody on the team has held in their head. Even when the code is good, the act of writing is what builds comprehension, and skipping that act skips the comprehension.

Intent debt lives in artifacts

Here is the new one. It accumulates when the goals and constraints that should guide the system are poorly captured or maintained. Intent debt limits whether the system continues to reflect what we meant to build. And critically for the AI era, it limits how humans and AI agents can continue to evolve the system effectively.

Read that second sentence again. Intent debt is the debt that directly throttles how well an agent can work on your codebase.

Your CLAUDE.md is an intent artifact. Your AGENTS.md is an intent artifact. Your ADRs, your design docs, your acceptance criteria, your README, your README's "non-goals" section, your issue templates, your docs/ folder, your internal glossary - all intent artifacts. When the code drifts away from the intent and nobody updates the artifact, intent debt accumulates. When no intent artifact ever existed, intent debt is maximal by default.

Why this framing matters right now

The reason the three-layer model lands differently in 2026 than it would have in 2019 is AI agents. The agent cannot read your mind. It cannot recover tacit knowledge. It cannot infer unwritten constraints. The agent reads whatever artifacts you wrote down. If those artifacts do not match what you actually meant, the agent confidently implements the documented wrong thing.

Intent debt used to be a soft cost. A new hire ramped slower. A PM asked a question that should not have needed asking. The system eventually absorbed the knowledge back through tribal repetition. In the agent era, intent debt is a direct throughput cost on every single agent run. Every ambiguous spec, every stale ADR, every missing constraint document compounds across every future iteration.

Fowler cites a recent paper from Shaw and Nave at Wharton that extends Kahneman's two-system model by adding AI as System 3. The paper introduces a distinction I have been chewing on since I read the fragment.

• Cognitive offloading is strategic delegation of thinking during deliberation. You use the agent as leverage, you stay in the loop, you verify.
• Cognitive surrender is uncritical reliance on externally generated reasoning. You outsource the thinking, you exit the loop, you trust.

Intent debt is the mechanism that turns offloading into surrender. When the artifacts do not capture intent, the agent has nothing to check its own work against. The human reviewer also has nothing to check it against. Both parties shrug at the diff and merge it. Surrender by omission.

Diagnosing intent debt on your own project

Here are five quick checks I would run today against any repo that AI agents touch.

First, the five-minute test. Open the repo fresh. Can you, inside five minutes, articulate what this system is for, what it is not for, and the three hardest constraints that shape every decision in it? If the answer is no, intent debt is present at the architecture layer.

Second, the agent prompt test. Open your CLAUDE.md or AGENTS.md. Is it a working document you have updated in the last thirty days, or is it a stub that was written once and abandoned? Stale agent config is pure intent debt.

Third, the non-goals test. Find your most recent README. Does it have a non-goals section? A description of what the system will not do, by design, even if it looks like a natural extension? Systems without documented non-goals accumulate the worst kind of intent debt because they get constantly extended into shapes the original authors would have rejected.

Fourth, the ADR test. Walk the last ten material commits. Is there an Architectural Decision Record, a PR description, or a linked issue that explains the why behind each material choice? Or is the history a stream of "update thing" commits? Commits without captured reasoning are intent debt being generated in real time.

Fifth, the ubiquitous language test. Ask three teammates to define the three most important domain terms in the codebase. Do the definitions match? If they drift, your code has drifted too, because the terms are the hooks the code hangs on. Fowler quotes Unmesh on this point directly: good names cut through complexity and turn code into a schematic everyone can follow. Drifted names are intent debt made visible.

What to do about it

Fix intent debt with artifacts, not with meetings. The meetings dissolve. The artifacts persist and the agent can read them.

• Write the CLAUDE.md or AGENTS.md before the first agent run, not after. Capture what the system is, what it is not, the tone of the codebase, the constraints that must be respected, and the commands the agent should know about. This is the single highest-leverage intent artifact you can create.
• Write ADRs cheaply and aggressively. One page. Why this decision, what we rejected, what we would revisit. Three sentences beats nothing. Your future agent will cite them.
• Add a non-goals section to every README. The things the system will not do are often more important to an agent than the things it will do. Agents love to add features you rejected on purpose.
• Update the intent artifact in the same PR that breaks the intent. If the commit changes what the system means, the artifact that describes the meaning has to change in the same commit. This is the single best discipline for keeping intent debt from accumulating invisibly.
• Make intent artifacts executable where you can. A failing test codifies intent better than a paragraph. A type system codifies intent better than a comment. A linter rule codifies intent better than a code review. Executable intent does not rot because CI enforces it.

The second-order argument

Fowler also quotes Ajey Gore in the same fragment, making an argument that deserves its own post but is worth surfacing here. If coding agents make the writing of code cheap, the expensive thing becomes verification. What does "correct" mean. What does "good enough" look like. Which edge cases matter and which do not.

Gore takes this all the way to the org chart. He argues the team that used to have ten engineers building features now has three engineers and seven people defining acceptance criteria, designing test harnesses, and monitoring outcomes. The uncomfortable demotion is of the act of building and the promotion is of the act of judging.

Read that in the intent-debt frame. Acceptance criteria are intent artifacts. Test harnesses are executable intent. Monitoring outcomes is intent verification at runtime. The whole shift Gore describes is a shift from producing code to producing intent.

That is the direction the craft is moving. The teams that invest in intent artifacts now will have agents that can run faster, on longer tasks, with fewer reviews, and with fewer regressions. The teams that treat CLAUDE.md as a one-time setup will watch the gap widen every week.

The honest bit

I do not think Fowler has fully landed the argument yet. The fragment is brief by design. The framework is Margaret-Anne Storey's. The experimental backing from Shaw and Nave is still lab-stage. The three-debt taxonomy will probably get refined, maybe renamed, maybe absorbed into something broader. Debt metaphors proliferate, as Fowler himself notes with visible fatigue.

But the direction is right. The second layer, cognitive debt, has already become common vocabulary in the agent discourse. The third layer, intent debt, has not. It deserves to. It is the layer that most directly determines whether your agent stack compounds or decays.

Read the original fragment. It is a fast twenty minutes. Then open your repo and look at your CLAUDE.md.

Further reading

• Over-Editing: Why Your AI Coding Agent Rewrites What Isn't Broken - the flip side of the cognitive-surrender problem
• AI-Native Development Workflow
• How to Write CLAUDE.md: The Complete Guide - the single highest-leverage intent artifact