Your next legacy estate is being generated right now

Every estate we inventory got that way the same way: the code outlived the people who understood it. The 2005 estates took twenty years to lose their owners. The one being written right now, by tools that produce a sprint of code in an afternoon, will not need ten. Generated code nobody read is legacy on the day it merges. It just has not had its first incident yet.

The numbers are already in. Google's DORA team measured it in the 2024 report: AI adoption raises individual productivity while pushing delivery throughput and stability down, not up. GitClear read the commit histories of AI-assisted repositories and found churn rising and reuse falling: more code pasted in, less code consolidated into shared places. Faster hands, worse estate. Neither study surprised anyone who walks estates for a living. We have spent two decades pricing what happens when writing outruns understanding. The only new part is the speed.

Here is the mechanism, and it is the same one that built every mess we get called into. Review capacity is fixed: the same engineers, the same forty hours. Generation capacity just went up an order of magnitude. When a team can produce code ten times faster than it can inspect it, the gap does not vanish. It accrues, quietly, as merged code that no human can explain. A wall you can lay ten times faster than anyone can inspect it is not a faster wall. It is an uninspected wall, and you will meet it again during an incident.

We did this to ourselves first, so the serial numbers on this story are ours. A generated data-migration module, green tests, clean structure, merged in an afternoon. Four months later a reconciliation number went wrong and it took three people two days to establish what the module actually did with duplicate keys, because the person who prompted it into existence had never read it either. Two days, for code that was four months old. That is a legacy-estate failure mode on a newborn system.

The counter-practice exists, and it is not complicated. The best written version we know is the case for human review of AI-generated code, published this month by an engineering lead who runs the practice on a real team. The discipline in it: when the tool compresses a month of implementation into a day, the estimate stays at two weeks, and the recovered time is spent reading the code together, challenging what it assumes, and rewriting what does not survive the conversation. His team books standing sessions and reads pull requests the way you read a book, not the way you skim a diff. Their production defect rate dropped, and the sessions delete as much code as they approve. AI adds code. Review is where code gets removed.

Run the same inventory discipline you would run on a 2005 estate, at merge speed. Four steps, none optional:

1. Count the generated share. Lines merged per week that came from a tool, next to review hours available per week. Two numbers, one ratio. When it moves, and it will, you want to be the shop that noticed the month it moved, not the shop that discovers it in an incident review in 2028.
2. Name an owner at merge. Owner means a person who can explain the module during an incident, not the person who prompted it. If nobody will sign, the module does not merge. Blank cells in the owner column are the finding, same as always.
3. Book the reading time as delivery work, on the schedule, with the feature it belongs to. Time saved by generation is the budget. Spend it before it evaporates into the next feature request.
4. Delete something every pass. Generated code arrives padded: defensive branches for states that cannot occur, abstractions for futures nobody ordered. If a review session has not removed code in a month, it has become a ceremony.

None of this is a case against the tools. We use them daily, and the productivity is real. It is a case against unread code, which was ruining estates long before the machines learned to type. The tools changed the rate, not the rule.

The cheapest modernization engagement is the one you never need. Twenty years out, somebody will walk the estate you are generating this quarter, and what they find is being decided in your merge queue, not in your architecture deck. Whether they find owners and runbooks, or the batch job nobody knew four hundred times over, is a choice you still get to make. Count first. Name an owner. Read the code.