AI Isn’t Killing Developers—It’s Creating a $10 Trillion Maintenance Crisis
On the debt without authorship, why "Lines of Code" is now a dangerous metric, and how to survive the hangover
Alex is a Senior Developer who, three months ago, felt like a wizard. Using a suite of AI coding agents, Alex “built” an entire automated billing microservice over a long weekend. He didn’t just write the logic; he generated the modules, the API wrappers, and the deployment scripts.
His manager was ecstatic. The “Lines of Code” (LOC) metric on Alex’s dashboard looked like a rocket ship taking off. He was hailed as the “10x Engineer” the company had always dreamed of.
Fast forward to last Tuesday at 3:00 AM. The billing system crashed. A subtle rounding error in a currency conversion module was leaking thousands of dollars. Alex opened the codebase and realized something terrifying: He had no idea how it worked.
The code was “correct” in that it ran, but it was written in a style that didn’t exist, using abstractions that weren’t necessary, and containing “hallucinated” logic that had no coherent rationale. There was no “shared memory” between the human and the machine.
Alex wasn’t looking at a codebase; he was looking at a crime scene where the primary suspect was an algorithm that had already moved on to its next job.
Welcome to the “AI Coding Hangover.”
The Dopamine Hit of “Production” vs. “Productivity”
As Matt Asay recently pointed out, the tech industry is currently obsessed with “Production”—the sheer volume of stuff we can churn out. We’ve automated the “writing” part of software development, which, ironically, was never the actual bottleneck.
Think of it like this: If you give a chef a machine that can chop 10,000 onions a minute, you haven’t necessarily made the restaurant better. You’ve just created a massive pile of onions that someone now has to cook, season, and serve before they rot.
In software, AI is the onion-chopper. We are generating “mini-enterprises” inside our companies—full systems spun up without architecture reviews or operational planning. It feels like speed in the moment, but as David Linthicum warns, it’s often just unpriced debt.
The Rise of “Manufacturing Liability”
We’ve spent decades trying to kill the “Lines of Code” metric because it’s a terrible way to measure value. Measuring a developer by LOC is like measuring a pilot by how many times they toggle the switches—it tells you nothing about whether you’re landing in the right city.
In the AI era, LOC isn't just a bad metric; it's a dangerous one. When AI agents generate thousands of lines of code in seconds, high velocity doesn't mean you’re building an asset. It often means you are manufacturing liability.
Every line of code is a line that needs to be secured, updated, and understood. When that code is "authored" by an LLM, we encounter “Debt Without Authorship.” There is no "Why" behind the "How." There is no seasoned engineer who remembers why we chose that specific library or why that edge case was handled that way. There is only an output that "passed the tests" (if the AI even bothered to write them).
The $10 Trillion Maintenance Crisis
Why $10 trillion?
