What happens when companies generate more code than any human can realistically review?
What happens when nobody reads the code?
The risk of AI-generated code may not be that it's bad. It may be that there's more of it than anyone has the attention to understand — and understanding was doing work we never priced.
The usual worry about AI-written code is quality: that it will be subtly wrong, insecure, or badly structured. That worry is reasonable and also self-correcting — bad code produces failures, failures produce pressure, pressure produces fixes.
The worry I find harder to dismiss is quantitative. What happens when the volume of code produced exceeds the attention available to understand it?
Review was doing more than catching bugs
Code review is usually justified as defect detection, which is the least interesting thing it does. It also:
- spreads knowledge of the system across more than one head;
- forces an author to make their reasoning explicable;
- creates the shared mental model that lets a team make consistent decisions later.
None of those survive a review where the reviewer skims a large diff they didn't write, can't fully hold, and has no strong incentive to block.
The plausible failure mode
Not a dramatic outage. Something slower: systems that work, that nobody fully understands, where every change is empirical rather than reasoned. Teams already recognise this state — it's what a legacy system feels like. The difference is the timeline. Legacy used to take a decade to accumulate. There's no obvious reason it couldn't now take a year.
The question underneath
Every abstraction we've accepted became acceptable because it was reliable enough that not understanding it stopped being a risk. The open question is whether generated code reaches that bar — and whether we'll notice if it doesn't, given that the failure mode is silence rather than error.