Code is a Liability
As corporate giants drown in auto-generated bloat, startups win by treating code as a toxic liability and keeping their systems strictly human-verifiable.
By Alan Reed
Sparked by If coding has been solved, why does software keep getting worse? · discussion
If you spend any time reading the internet lately, you'll notice a weird paradox. A recent post called "Nothing works and everyone is euphoric" captures the exact ambient annoyance of modern computing. We have the most powerful coding tools in history, yet everyday software is noticeably degrading. Basic applications feel sluggish, synchronization processes quietly fail in the background, and standard user interface components routinely break. The overwhelming agreement in the accompanying Hacker News comment thread confirms this is an observable, systemic reality. We are living in a golden age of developer velocity, yet the end product feels incredibly lame.
Why does this happen?
We can diagnose the root cause by treating programming as an optimization equation mapping human cognitive limits. Writing software essentially consists of two distinct variables: generating code and verifying code. Historically, this equation was inherently self-correcting because generation was physically slow. You had to actually type the syntax, compile it, and wait. We know from standard historical baselines like The Mythical Man-Month that verification and testing have always mathematically dominated the engineering schedule. The actual typing part was merely a trivial lower bound — a rounding error in the cognitive budget. Programmers didn't spend their days writing code; they spent their days carefully tracing the state of the system in their heads to ensure the logic they just wrote wouldn't silently corrupt the database.
Artificial intelligence just introduced a catastrophic variable change to this equation.
Large language models drove the cost of the generation variable down to near-zero. If you assume software development is simply an assembly line, you would conclude that engineering velocity should immediately go infinite. But the verification variable does not stay flat when generation spikes. Verification scales superlinearly with volume. Every new function interacts with existing functions, expanding the surface area of potential edge cases and orthogonal bullshit exponentially.
Because human working memory is strictly bounded, trying to comprehend an increasingly massive, auto-generated codebase forces engineers to hit a cognitive asymptote rapidly. Empirical data from GitClear demonstrates this exact phenomenon in the wild, showing that AI coding assistants are massively increasing code churn. Developers are accepting large blocks of suggested syntax without fully internalizing the logic. We are generating infinite unverified debt, and the system is buckling under the weight.
The implication is a massive arbitrage opportunity for startups.
Large organizations are highly inefficient because they are optimized for the wrong metrics. Corporate managers measure productivity in sheer volume. Because they view code as a capital asset on a balance sheet, the pointy-haired boss will inevitably mandate AI tools to pump out maximum volume — a strategy that mathematically guarantees failure. They will force their teams to generate millions of lines of boilerplate, turning their entire infrastructure into a stateless, incomprehensible tamagotchi. They will mistake the blur of algorithmic typing for actual engineering progress.
The fatal flaw in this corporate thinking is a complete misunderstanding of what software actually is. As E.W. Dijkstra noted decades ago, code is not an asset; it is an expenditure, and we should measure programming in "lines spent" rather than "lines produced". Code is a toxic liability. Every single line you write is a line you have to debug, maintain, and secure against future platform updates.
When the cost of generation drops to zero, the only surviving metric that matters is human comprehension. Once a codebase exceeds a team's capacity to hold its architecture in their heads, verification consumes one hundred percent of an engineer's cognitive bandwidth. Feature velocity halts completely. You drown in your own output.
If the legacy giants are blindly marching into an avalanche of zero-cost, unverified spaghetti code, the winning move is completely orthogonal. You exploit their structural inefficiency by refusing to play their volume game. The corporate giants will use AI to bloat their products into a brittle, crashing mess of auto-generated crap, collapsing under the weight of their own maintenance costs. The startups that win the next decade will be the ones that understand code is a cost to be minimized.
Instead of using infinite generation to build a sprawling, complex monolith that requires an army of frantic engineers just to keep the servers from melting down under the weight of unverified hallucinations, you must mercilessly garbage-collect your own ambition until you are left with a system so simple that a single human brain can verify its complete state. You stay small.
Don't use AI to write more code than the incumbents. Use it to build a smaller surface area that never breaks.