The Law of Code Mass
Because typing is cheap and code is a depreciating liability, AI swarms that endlessly generate it bury companies under permanent maintenance debt.
By Saul Berger
Sparked by Agent swarms and the new model economics · discussion
I was reading this incredibly breathless blog post about agent swarm model economics over on the Cursor site, and suddenly I felt this overwhelming, icy dread. It’s the exact same sensation you get watching a guy confidently attempt open-heart surgery with a weedwhacker. You walk into the virtual room and find the VC-funded Architecture Astronauts practically weeping with joy because an AI just typed out a million lines of code before breakfast. Everybody seems to think this is a miracle. (Attention, AI-hype fanboys: keep your self-righteous emails about your scrillions of synthesized tokens to yourselves, OK? Go start your own blog.)
When you actually scroll down into the trenches and read the Hacker News reaction, the working developers accurately describe this miraculous output as a "universe of slop" and a "cancer cluster of ever expanding code." Which brings us to a very basic microeconomic conundrum I like to call The Economist's Question. Does producing massive amounts of code actually create value? The conventional wisdom dictates that typing equals software, and more software equals more value. You pay programmers to type, so if a machine types ten thousand times faster than a human, you get ten thousand times the value.
Wrong.
As Jeff Atwood famously pointed out years ago, code is a depreciating liability. Code is a brutal, unrelenting debt you have to service until the end of time. You cannot safely lock it inside a vault like a shiny asset. Every single line of code you write requires compiling, testing, source control, deployment, and security patching. Every line has to be migrated when a vendor changes an API. Every line has to be explained to the new junior developer who joins the team next October.
Let's force this abstract token-burn down into a brutal, physical reality. Imagine a gigantic industrial bread factory. You have a factory floor, a loading dock, and a fleet of delivery trucks. Management decides they want to radically increase their key performance indicators, so they rip out the old machinery and install a magical new oven that violently vomits 10,000 loaves of bread onto the factory floor every single minute. The Architecture Astronauts are popping champagne because their production velocity is up astronomically. Look at all this bread! We are disrupting the flour industry!
But there are no trucks idling at the loading dock. There are no grocery stores asking for an exponential increase in whole wheat. There are absolutely no customers eating it. The factory floor simply starts filling up to the ceiling with depreciating, rotting bread. Eventually, the workers literally cannot walk across the room without drowning in a suffocating, putrid sea of decomposing rye. When a conveyor belt jams, they have to tunnel through six feet of stale sourdough just to find the power switch. The CEO, naturally, is oblivious to the stench, currently busy giving a TED talk about his unprecedented baking metrics.
Software is inventory. We keep pretending it isn't. We act like code is magic fairy dust that makes computers do profitable things, but in reality, an autogenerated million-line pull request sitting on your hard drive does exactly the same thing as a mountain of rotting bread. It takes up space, obscures the pathways, and demands endless attention from people who already have far too much to do. AI agent swarms act like that malfunctioning oven, completely ignoring the fundamental physical constraints of the factory to maximize a metric nobody actually needed maximized.
Why is this inventory so acutely toxic? Because typing has always been practically free. The unyielding, unromantic microeconomic bottleneck of software engineering is, and always has been, reading.
If I were to draw you a simple, side-by-side bar chart titled "The AI Delusion," the left side would show what VCs think we do: 95 percent furiously typing at our keyboards, 5 percent sipping coffee. The right side would show reality: 1 percent typing, 99 percent squinting at existing code, and the rest weeping softly into our hands. Look at the actual math. As Robert C. Martin observed, the ratio of time spent reading code versus writing it is well over 10:1. We spend all day agonizing over existing logic, tracing variables through endless callbacks, and building massive, fragile mental models in our heads just to ensure our one new conditional branch doesn't accidentally trigger a catastrophic failure in the billing system.
AI agent swarms completely bypass this microeconomic reality. They exclusively optimize for the absolute cheapest, easiest part of the job, generating limitless supply for a system that possesses exactly zero spare reading bandwidth. The ovens keep firing. The bread keeps piling up. The workers are suffocating. You are paying for a machine that optimizes the 10 percent of the job that nobody was actually struggling with, while exponentially increasing the 90 percent of the job that makes developers want to jump out of a window.
Picture Mikey, the poor duct-tape programmer, at 3:30 AM on a Tuesday. Mikey is desperately trying to debug a 40,000-line, autogenerated Rust SQLite implementation which is, in reality, just a stochastic uncompression of Turso's Limbo codebase, generously padded with three thousand useless helper functions that a language model regurgitated because it pattern-matched a GitHub repository from 2018. Reading this perfectly typed, logically hallucinated, synthesized slop feels like trying to untangle a mile of wet spaghetti in the dark using only your teeth.
At this exact moment, Mikey is functionally an industrial worker trapped under six tons of half-baked pumpernickel, holding a tiny flashlight and screaming for someone to turn off the machine.
We need to formalize this absurdity into a universal framework before we all drown. I submit to you The Law of Code Mass: A company's survival rate is inversely proportional to the volume of code it maintains. These AI swarms act exclusively as a mechanism to accelerate the rate at which you bury your own company under an inescapable mountain of maintenance debt. Every time an agent spins up to dump ten thousand files into your repository, your organizational mass increases, your agility drops to absolute zero, and the actual humans who have to understand the system die a little bit inside.
So if your brilliant business strategy is to let a swarm of language models vomit a million unread lines of code into your repository every night, go right ahead. But when your entire engineering team is weeping under their desks because they can't figure out which of the 400 autogenerated UserAuthStrategy classes is deleting the production database, don't say I didn't warn you. Typing is cheap. Maintenance is forever. Everything else is just commentary.