AI coding agent debt does not stay confined to messy code. This study note examines how debt builds up in missing records and in human understanding when building software with a generative AI tool, and which everyday habits keep those debts down.

Summary

Delegating work to an AI coding agent produces code quickly, but alongside code-level problems (technical debt), it can accumulate intent debt—where what is being built and why is never recorded—and cognitive debt, where the team loses understanding of the system. Habits such as pulling out requirements one by one, scoping each prompt, cross-checking numbered requirements against evidence, recording the “why”, and delegating in small chunks reduce these debts.

What are the three debts of AI coding agents?

One-line answer: They are technical debt in the code and structure, cognitive debt as shared human understanding erodes, and intent debt when goals, constraints and rationale are missing from artifacts—and they reinforce one another.

Margaret-Anne Storey explains that a software system exists across layered dimensions: goals and intent, code and structure, and shared understanding (Peter Naur’s theory of the system). Assessing AI coding agent debt therefore requires looking at the interacting debts that correspond to those layers.

  • Technical debt: problems in the code layer. It lives in code and makes systems harder to change.
  • Cognitive debt: the erosion of shared understanding across a team over time. It lives in people and developers’ minds, making systems harder to understand.
  • Intent debt: the absence or erosion of explicit goals, constraints and rationale that both humans and AI agents need. It lives in artifacts such as requirements, decision records, implementation plans, tests and specifications, making it hard to know what the system is for.

These debts reinforce each other. Intent debt causes cognitive debt when nobody knows why the system behaves as it does; cognitive debt causes technical debt when people change code they do not fully grasp; and technical debt in the form of messy code further amplifies cognitive debt.

Technical debt, cognitive debt, and intent debt reinforcing one another

Why do intent and cognitive debt accumulate faster when delegating to an agent?

One-line answer: Because generative AI tools generate code faster than people can read or understand it, fill gaps in underspecified prompts with plausible-looking results, and invite uncritical acceptance.

A generative AI tool can help reduce technical debt through refactoring, test generation and review automation. At the same time, it accelerates cognitive and intent debt because velocity outpaces understanding: the tool generates code faster than developers can read or absorb it. It also accepts underspecified prompts, fills in the gaps on its own, and produces plausible-looking results that may miss the actual intent.

Storey distinguishes between two ways of relying on tools. Cognitive offloading is deliberately delegating a discrete task to a tool, such as a linter. Cognitive surrender is adopting AI output with minimal scrutiny. Cognitive surrender can inflate confidence even when the AI is wrong, and even when agents produce easy-to-read code, developers can still “lose the plot”.

Signals of cognitive debt include:

  • Reluctance to change the system.
  • A change producing unexpected results.
  • Slow onboarding for joining team members.

Signals of intent debt include:

  • System behavior drifting from what stakeholders expect.
  • AI agents needing extensive clarification, or producing solutions that are technically correct but miss the point.
  • Forgotten constraints.

What habits are needed before delegating to an agent?

One-line answer: Before asking for code, pull out requirements one by one through clarifying questions, lock down the modification scope in every prompt, and delegate in small units.

The habits below are general recommended practices for keeping these debts under control during everyday work with an agent.

Start with context questions and pull out requirements one by one

Before asking for code, ask the agent what it needs to know and have it ask clarifying questions. Instead of dumping every requirement at once, pull requirements out through conversation one by one.

Closing those gaps upfront keeps the agent from guessing silently and reduces intent debt.

Specify the scope in every prompt

State the boundary in every prompt—for example, instruct the agent to modify only the target file and feature while leaving other modules untouched.

This prevents unrelated changes that create technical debt and keeps you aware of what changed, reducing cognitive debt.

Delegate in small chunks

Asking an agent to implement everything at once makes later fixes much more expensive. Hand over a small unit, review it until you understand it, and only then move to the next unit.

This aligns with Storey’s suggestion that someone on the team should fully understand each AI-generated change before it ships, reducing both cognitive debt and technical debt.

What should you verify after receiving the results?

One-line answer: Cross-check each numbered requirement against its code location and actual result, separate fallbacks, estimates and failure paths from real results, and strip out over-engineering.

Number requirements in PLAN.md and cross-check evidence

Assign an identifier to each requirement in PLAN.md. When the task finishes, point each item to the exact code location and the verified result that satisfies it; any unmatched item is unfinished work.

R1 …: 근거 = 파일/함수, 결과 = 확인함
R2 …: 근거 = 파일/함수, 결과 = 미확인

In the example above, each numbered requirement records its evidence (file or function) and whether the result was verified. Pairing rigorous review with tests and checks that capture intent keeps velocity from outpacing understanding and reduces intent debt and cognitive debt.

Numbering requirements in PLAN.md and cross-checking code locations and verification results

Distinguish fallbacks, estimates and failure handling from real results

When an agent fills in a fallback or default value, an estimate, or an error-handling path, mixing that output with normal results makes plausible-looking output look real. Mark the source in a separate flag column when inspecting tables or logs.

값 | 출처(실제/대체/추정/실패)

The column header above separates the value from its source (real, fallback, estimate, or failure), preventing false confidence and reducing cognitive debt.

Prevent over-engineering

A read-only API, for instance, does not need write-protection logic. Check whether the agent added unrequested defensive layers or abstractions, and keep only what the requirement needs.

Trimming unrequested complexity reduces technical debt.

Where should you record the “why”?

One-line answer: Capture what was decided, why, and what was not done in DECISIONS.md at the moment the decision is made, and keep AGENTS.md and handoff documents updated as you go.

Storey notes that intent is best captured when the decision is made; recovering it later can be hard or impossible. She also emphasizes documenting not just what changed, but why, and keeping design documents continuously updated.

Use an intent-first workflow by recording each decision on a single line in DECISIONS.md—what was decided, why, and what was not done, like a lightweight architecture decision record (ADR)—and by keeping context artifacts such as AGENTS.md (agent instructions and playbooks) and handoff notes current while you work rather than at the end. For a closer look at how context and constraints are structured around agents, see Prompt, Context, Harness, and Graph Engineering: What Is the Difference?.

결정: … / 이유: … / 하지 않은 것: …

The template above records the decision, the rationale, and what was intentionally left out. Take caution here: you can let the agent draft documentation, but you must read and understand it yourself. As Storey warns, teams must resist the automation of understanding, because AI-generated documentation can give the appearance of understanding without the real thing. Reading and managing these records yourself reduces intent debt.

What are the frequently asked questions?

One-line answer: Below are answers on why managing technical debt alone is not enough, what to watch for when letting agents write documentation, and how cognitive debt affects solo developers.

Is managing technical debt alone not enough?

It is not enough. Even when code is clean and technical debt is low, a team cannot safely change the system if nobody understands how the code works (cognitive debt) or if it no longer reflects its original purpose and constraints (intent debt).

Can I let the agent write the documentation?

Letting the agent draft is fine, but reading, understanding and verifying it must be done by a human. Storey also points out that whether AI should be used to auto-generate such documentation remains an unsettled open question.

Does cognitive debt also happen when developing alone?

Storey mainly frames cognitive debt as the erosion of shared understanding across a team, but solo developers also experience it through confusion about structure, fear of making changes, and loss of confidence—because your future self is your next teammate.

One-line answer: Read our notes on engineering concepts for passing context and constraints to agents, and on a memory-checking tool for actually testing C/C++ code, including code an AI wrote.

What are the sources?

One-line answer: The primary source is Margaret-Anne Storey’s ACM Queue article, together with the public version of the same article on arXiv and two of her blog posts.