💻 computer science

From Technical Debt to Cognitive and Intent Debt: Rethinking Software Health in the Age of AI

This paper proposes a "Triple Debt Model" for assessing software health in the age of Generative AI, arguing that as AI accelerates code generation, the primary risks shift from traditional technical debt to accumulating cognitive debt (eroded team understanding) and intent debt (lack of externalized rationale), necessitating new strategies for diagnosis and mitigation.

Original authors: Margaret-Anne Storey

Published 2026-03-25

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Margaret-Anne Storey

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you are building a massive, intricate Lego castle. In the past, if you wanted to build it fast, you might skip reading the instructions, use the wrong bricks, or glue pieces together messily just to get the tower standing. Later, you'd realize the castle is wobbly and hard to fix. In the software world, we call this Technical Debt. It's the mess in the code itself.

But now, imagine a super-fast robot assistant (Generative AI) that can build your Lego castle for you in seconds. It builds a perfect-looking tower instantly. You are thrilled! You can build a whole city in a day.

However, here is the catch: You didn't build it, so you don't really know how it stands up. You didn't feel the friction of snapping the bricks together, so you don't understand the structure. If you try to add a new wing, the whole thing might collapse because you don't know why the robot put that specific brick there.

This paper argues that while AI solves the "messy bricks" problem, it creates two new, invisible problems that are actually more dangerous: Cognitive Debt and Intent Debt.

Here is the breakdown of the "Triple Debt" model using simple analogies:

1. Technical Debt (The Messy Bricks)

What it is: Bad code, shortcuts, and messy architecture.
The Analogy: The Lego castle is glued together with sticky tape instead of snapping properly. It looks fine from a distance, but if you try to move a piece, it breaks.
The AI Effect: AI is actually good at fixing this. It can scan the messy castle and re-glue the bricks perfectly. So, the "messy code" problem is getting better.

2. Cognitive Debt (The Lost Knowledge)

What it is: The team doesn't understand how the system works. They can't explain why it was built that way.
The Analogy: You have a castle, but no one in your family knows the blueprint. You know the robot built it, but you don't know the rules it followed. If you need to change the color of the roof, you're terrified to touch it because you think, "If I move this, the whole thing might fall."
The AI Effect: Because the robot builds so fast, we stop thinking. We accept the robot's work without asking questions. We "surrender" our brainpower to the machine. Over time, the team loses the "mental map" of the castle. The code works, but the humans don't understand it. This is Cognitive Debt.

3. Intent Debt (The Missing Blueprint)

What it is: We forgot what the castle was supposed to be for. We lost the original goals and reasons.
The Analogy: The robot built a beautiful castle, but nobody wrote down that it was supposed to be a prison for toy soldiers, not a palace for princesses. Now, the robot keeps adding prison bars, but the team thinks it's a palace. The system is drifting away from its true purpose because the "why" was never written down.
The AI Effect: AI needs instructions. If you don't tell it the "why" (the intent), it just guesses. If the original goals aren't captured in documents or notes, the AI (and the humans) will slowly build the wrong thing. This is Intent Debt.

The Three Layers of a Healthy System

The author says a healthy software system needs three things to be in sync:

The Code (The Bricks): Is it built well? (Technical Debt)
The People (The Builders): Do they understand how it works? (Cognitive Debt)
The Plan (The Blueprint): Do we know what we are trying to build and why? (Intent Debt)

The Danger:
In the age of AI, we are fixing the Bricks (Technical Debt) so well that we are ignoring the Builders and the Blueprint. We are building castles faster than we can understand them or remember why we are building them.

How to Fix It (Without Stopping the Robot)

The paper suggests we need to change how we work:

Treat "Understanding" as a Product: Just like you deliver a working app, you must also deliver a team that understands it. Don't just ship code; hold meetings to explain why the code is there.
Write Down the "Why": Before you let the AI build, write down the rules and goals (the Intent). Think of this as the "instruction manual" the robot needs to read.
Don't Let AI Write the Manual for You: It's tempting to ask the AI to write the documentation. But if the AI writes the manual without the humans understanding the code, it's a fake manual. Humans need to do the hard thinking to create the understanding.
Walk Through the Castle: Regularly have team members explain parts of the system they didn't build to each other. This keeps the "mental map" fresh.

The Bottom Line

Generative AI is like a super-powerful engine. It can take you places faster than ever before. But if you don't know how to steer the car (Cognitive Debt) or where you are actually trying to go (Intent Debt), you're just going to crash faster.

The most successful teams in the future won't be the ones who write the most code; they will be the ones who best understand why their code exists and what it is supposed to do. They will manage their "understanding" just as carefully as they manage their "code."

Based on the paper "From Technical Debt to Cognitive and Intent Debt: Rethinking Software Health in the Age of AI" by Margaret-Anne Storey, here is a detailed technical summary.

1. Problem Statement

The paper addresses a critical shift in software engineering risks driven by the rapid adoption of Generative AI (GenAI). While GenAI dramatically accelerates code generation and feature delivery, it introduces a paradoxical risk: it may reduce technical debt while simultaneously accelerating the accumulation of "Cognitive Debt" and "Intent Debt."

The Core Issue: Traditional software health metrics focus on code quality (Technical Debt). However, GenAI enables developers to generate code faster than they can comprehend it. This leads to a situation where systems function correctly but lack a shared team understanding of how they work or why they were built that way.
The Consequence: Teams face "cognitive surrender," where they accept AI outputs without deep reasoning, leading to fragmented mental models, loss of rationale, and an inability to safely modify or evolve the system. The paper argues that the primary risk in the AI era is no longer just messy code, but the erosion of the "theory of the system" (shared understanding) and the loss of explicit design intent.

2. Methodology

The paper employs a conceptual framework analysis and qualitative observation rather than empirical quantitative experimentation.

Observational Case Study: The author draws on firsthand observations from an entrepreneurship course where student teams, despite rapid progress, stalled due to a lack of shared understanding and rationale, not just code quality issues.
Literature Synthesis: The argument is built upon a synthesis of existing software engineering theories (e.g., Naur's "Theory of the System," Cunningham's Technical Debt, Kahneman's System 1/2 thinking) and emerging research on human-AI interaction (e.g., Kosmyna et al.'s EEG studies on cognitive offloading, Shaw & Nave's concept of "cognitive surrender").
Framework Construction: The author proposes a new "Triple Debt Model" to categorize and analyze software health across three distinct layers.

3. Key Contributions: The Triple Debt Model

The paper's central contribution is the redefinition of software health through a three-layer model, moving beyond the traditional code-centric view.

A. Technical Debt (The Code Layer)

Definition: Problems in the code layer (messy code, architectural shortcuts) that make systems harder to change.
AI Context: GenAI can potentially reduce this debt through automated refactoring, test generation, and code review. It remains visible and manageable with existing tools.

B. Cognitive Debt (The People Layer)

Definition: Inadequate shared mental models across a team. It represents the erosion of the collective understanding of how the system works and why.
Mechanism: Arises from "Cognitive Surrender"—the tendency to accept AI outputs without the friction of deep reasoning (System 2 thinking). Unlike "cognitive offloading" (strategic delegation), surrender bypasses the learning process.
Symptoms: Resistance to change, unexpected results from modifications, low "bus factor" (only one person understands the system), and burnout.
AI Context: AI accelerates this debt because developers accept code without building the necessary mental models, leading to a gap between code existence and team comprehension.

C. Intent Debt (The Artifact Layer)

Definition: The absence or erosion of explicit rationale, goals, constraints, and specifications that guide system evolution. It is the lack of "externalized memory" (documents, ADRs, specs) that both humans and AI agents need.
Mechanism: Occurs when goals are unclear, decisions are not recorded, or constraints (e.g., privacy, performance) are forgotten.
AI Context: AI agents require context to function safely. Without explicit intent artifacts, AI may optimize for the wrong objectives or produce technically correct but semantically wrong solutions. This debt is critical because it prevents the repair of cognitive debt.

Interactions

The three debts are interdependent:

Intent Debt $\rightarrow$ Cognitive Debt: Without clear goals, teams cannot form accurate mental models.
Cognitive Debt $\rightarrow$ Technical Debt: Lack of understanding leads to poor implementation decisions.
Technical Debt $\rightarrow$ Cognitive Debt: Messy code makes reasoning and understanding difficult.

4. Results and Diagnostic Frameworks

The paper outlines specific diagnostic indicators and mitigation strategies for the new debt types.

Diagnosing Cognitive Debt:

Resistance to change due to low confidence.
Unexpected system behavior after minor changes.
High dependency on specific individuals (low bus factor).
Slow onboarding for new team members.

Diagnosing Intent Debt:

Behavior Drift: System behavior diverges from stakeholder expectations.
AI Struggle: AI agents produce technically correct but contextually wrong solutions or require excessive clarification.
Loss of Constraints: Non-functional requirements (security, privacy) are forgotten.

Proposed Mitigation Practices:

For Cognitive Debt: System walkthroughs (explaining code not written by the speaker), retrospectives to rebuild mental models, and deliberate onboarding/offboarding processes.
For Intent Debt:
- Executable Intent: Using BDD (Behavior-Driven Development) specifications to capture purpose.
- Decision Records: Architectural Decision Records (ADRs) and Domain-Driven Design (DDD) to capture rationale.
- Context Engineering: Creating specific playbooks and instructions for AI agents.
Strategic Shift: Treat "Shared Understanding" as a first-class deliverable, not a side effect. Adopt "Intent-First" workflows where goals are defined before code generation.

5. Significance and Implications

Paradigm Shift: The paper challenges the industry to stop viewing software health solely through the lens of code quality. In the AI era, understanding and intent are the new critical assets.
Risk Management: It warns that relying on AI for documentation generation without human cognitive engagement creates a "hallucination of understanding"—artifacts that look like understanding but lack the underlying mental models.
Future of Engineering: The role of the developer is shifting from "authoring code" to "maintaining correct understanding" and "curating intent."
Organizational Impact: Organizations must invest in "learning support" and "intent capture" with the same rigor as code quality. Failure to do so will lead to systems that are fast to build but impossible to evolve safely.

Conclusion:
Generative AI offers speed but threatens the alignment between Intent (Artifacts), Behavior (Code), and Understanding (People). To navigate this, software teams must actively manage Cognitive and Intent debt, ensuring that the acceleration of code generation does not outpace the team's ability to comprehend and guide the system.