The hidden cost of AI code accumulation
AI lowers the cost of writing code to almost nothing, and that changes the economics of a codebase. When adding is cheap and removing still requires judgment, code accumulates faster than it is pruned. The result is volume that looks like progress but behaves like debt: more to read, more to maintain, more surface area for bugs.
Cheap to add, expensive to own
The cost of code was never mostly in writing it. It was in reviewing, understanding, testing, and maintaining it over years. AI collapses the writing cost while leaving every downstream cost intact. A 400-line generated helper is fast to produce and just as slow to own as a hand-written one.
Volume is not velocity
Lines added is one of the most misleading metrics in AI-assisted work. More code is not more value; often it is the opposite. Duplicated helpers, speculative abstractions, and unused branches all register as output while making the system harder to change.
- A new abstraction for a single caller
- Error handling for cases that cannot occur
- A second helper that does what one already does
- The smallest change that solves the actual task
Healthy growth is bounded growth
The defense is scope. When each task declares what it should change and that boundary is enforced, generated code stays proportional to the problem instead of expanding to fill the cheapness of writing it. Bounded change is reviewable change.
The goal is the smallest correct change, not the most code. Cheap writing makes discipline more important, not less.
How Avorelo helps
Avorelo declares the write boundary at task start and flags changes that fall outside it before the run continues. Generated code stays scoped to the task, which keeps growth proportional and reviewable. The session receipt records exactly what changed, so accumulation is visible rather than silent.