Technical Debt in the Age of AI

There's a seductive idea floating around: if AI can write code this fast, technical debt stops mattering — just regenerate it. It's wrong, and the reasoning behind why it's wrong is worth getting precise about.

AI lowers the cost of writing, not of owning

The expensive part of software was never typing it out. It's understanding it, changing it safely, debugging it under pressure, and keeping it coherent as it grows. AI collapses the cost of *production* to nearly zero while leaving the cost of *comprehension* almost untouched. That asymmetry doesn't eliminate debt — it accelerates how fast you can create it.

The debt you can't see

When code is generated faster than anyone reads it, you accumulate a specific and nasty kind of debt: code that works but that no human on the team actually understands. There's no comment thread, no design doc, no person who can explain why it's shaped that way. The system becomes a black box you're afraid to touch — and fear is the most expensive state a codebase can be in.

Guardrails that scale

The answer isn't to slow down — it's to make understanding non-optional. Strong types and tests so the machine can't quietly break invariants. Architecture and boundaries a human defines, so generated code has a shape to fit into. And a simple rule: nothing merges that someone on the team can't explain. Generate fast, but own deliberately. The teams that ignore the second half will be the ones drowning in code they're too scared to change.