AI Coding Tools and the New Shape of Technical Debt

Volume debt

The most basic effect is more code. More code means more surface to maintain, test, secure and understand, and generated code is rarely the minimal solution.

Watch for solutions that are three times longer than necessary because the model produced a general implementation of a specific need.

The review question that catches this: what would this look like at a third the length? Frequently the answer is better and obvious once asked.

Divergence debt

Each generated component tends toward its own idiom. Without deliberate alignment, a codebase accumulates six ways of doing the same thing, none of them wrong.

This is the most expensive form in practice, because it defeats the pattern recognition that makes a codebase navigable.

Central conventions plus a rules file plus review attention on convention alignment is the whole mitigation, and it works.

Comprehension debt

Code nobody on the team has ever reasoned through is a liability regardless of its quality. When it breaks at 2am, the mental model does not exist.

This is why explain-before-merge matters more than explain-before-accept at team scale. Someone must be able to describe what each component does without reading it.

Track it crudely: for each significant module, is there a named person who could debug it under pressure? Modules with no such person are the real debt register.

Test debt that looks like coverage

Generated tests raise coverage numbers while frequently testing the implementation rather than the requirement. The metric improves and the safety does not.

This is worse than low coverage, because it removes the pressure to write the tests that would have caught something.

Audit a sample: for each test, could the requirement change without the test failing? If yes, the test is measuring the wrong thing.

Dependency debt

Assistance makes adding a dependency frictionless, and each one carries maintenance, security and upgrade cost indefinitely.

Require a justification for every new dependency in review, and prefer standard library or existing dependencies wherever the gap is small.

Audit the dependency list quarterly. In heavily assisted projects it grows faster than anyone expects.

Controls that work

A written conventions document that is short enough to be read and is supplied as model context. Long ones are ignored by both humans and models.

Review attention weighted toward integration and convention rather than logic, as described in the review checklist.

A periodic consolidation pass — one day a month spent collapsing divergent implementations into one. This is unglamorous and it is what keeps assisted codebases navigable.

Worked example: a six-month audit

A team of five, heavy assistant use, six months into a new service. Line count roughly double the estimate for the feature set.

Divergence audit found four distinct HTTP client patterns, three error-shape conventions and two competing validation approaches — all functional, all added within the same quarter.

Comprehension audit found three modules with no team member who had reasoned through them, all three generated in a single sprint under deadline.

The remediation was two consolidation days: one collapsing the client and error patterns to one each, one walking through the three orphaned modules as a group and documenting them. Line count fell by about eighteen per cent and onboarding time for the next hire dropped noticeably.

How assistants quietly add debt

Generated code tends to be locally sensible and globally duplicative. It reimplements a helper that already exists two directories away, because the model cannot see that the helper exists.

It also copies the conventions of whatever it was shown. Point it at the oldest file in the repository and you will get more of that pattern, faithfully reproduced in new code.

The volume effect compounds both: more code written per hour means more code to review, and review is the step that gets compressed when everything else speeds up.

Controls that hold the line

Keep a short conventions file in the repository and include it in the assistant's context. It is the cheapest available intervention and it addresses the largest category of drift.

Search before generating. A ten-second search for an existing helper prevents the most common form of duplication, and it is a habit rather than a tool.

Budget explicit time for consolidation — an hour a fortnight to fold duplicated helpers together and delete dead paths. Teams that ship faster without this end up with a codebase nobody can navigate, and the speed gain reverses within a year.

Frequently asked questions

Tools mentioned in this article

More in Developer & Tech