How Does AI Change Technical Debt Cleanup (CCA-F D3)?

What changed

The old model of technical debt was a backlog of small, local problems: code smells, brittle tests, stale docs, mystery modules. AI helped at the snippet level but could not see enough of the system, and it sometimes created fresh mess while fixing the old.

That has flipped. When an agent can touch hundreds of files in one run (🟢 first-hand: Claude Code can fan work across a fleet of sub-agents), code generation stops being the bottleneck. The new bottleneck is coordination: deciding what changes, gating what merges, and keeping the change reversible.

So the nature of debt work changes:

• Micro-debt becomes cheap. The agent clears smells, renames, and dead code at scale.
• Architectural debt dominates. Wrong boundaries and tangled dependencies need human-set direction and verification, which the agent cannot supply for itself.
• Hallucinated fixes are a new debt source. A fix that passes tests but breaks a boundary compounds debt faster than it removes it.

Old workflow vs. governed workflow

How governance actually works

A debt-reduction run has three control points, and you own all three.

• Scope (before). Use plan mode to define exactly what the run may touch and what done means. An unscoped agent loose in a repo is how boundary breaks happen.
• Gate (during). Every AI change passes a review gate that checks it against the scope and the architecture, not just the test suite. Tests-pass is necessary, not sufficient.
• Rollback (after). Keep checkpoints so a large autonomous change can be reverted cleanly if a gate catches a problem late.

Worked example - "let an agent retire a deprecated module."

1. Scope: plan-mode brief naming the module, the call sites, and the boundary that must not change.
2. Fan out: the agent updates call sites in parallel, returning diffs, not narration.
3. Gate: a reviewer (human or a verifier agent) checks each diff against the boundary contract before merge.
4. Checkpoint: commit in reversible slices so a missed break is one revert away, not a rewrite.

That is governed debt work: scoped, gated, reversible.

A name for the shift: Governance Debt

Governance Debt - the gap between how fast an agent can change code and how well you can verify those changes. When generation outruns verification, every autonomous fix is an unreviewed liability. You pay Governance Debt down with scope, review gates, and checkpoints, not with a smarter model.

The reframe that matters: an agent that can say "this might be wrong" is safer than one that sounds confident (🟢 first-hand: Claude is built to flag uncertainty rather than fabricate), but the safety only lands if a gate is there to act on the flag.

Why it matters for CCA-F

This is core D3 - Claude Code Configuration & Workflows, which is 20% of the exam and leans on plan mode, checkpoints, and evaluation.

The proprietary read: D3 questions reward workflow control, not code output.

• Old instinct: get the agent to write the fix.
• D3 instinct: scope the run, gate the merge, keep it reversible.

The distractor pattern to memorize. On D3 scenarios where an AI change passes tests but breaks something, the trap answers are "use a more capable model" or "add more tests." The architecturally correct move is one of:

1. Scope the run (plan mode defines what may change), or
2. Add a review gate (verify against the boundary, not just the tests), or
3. Checkpoint for rollback (make the scale reversible).

See Claude Code for CI/CD for the canonical D3 workflow shape.

How to apply it

1. Scope before you run. No agent touches a repo without a plan-mode brief naming boundaries and done-criteria.
2. Gate every merge. Tests-pass is the floor; verify the change against the architecture.
3. Commit in reversible slices. Checkpoints turn a scary autonomous change into a safe one.
4. Track work-packets, not just tickets. Make the unit of work the AI change plus its review outcome.
5. Treat confidence as a flag, not a fact. Route the agent's uncertainty to a human, do not merge through it.
6. Measure Governance Debt. If changes merge faster than they are verified, that gap is the real backlog.

The meta-skill, and the D3 exam skill, is the same: once AI writes the fix, your job is to govern it - scope, gate, and roll back.