You call your codebase an asset. On the balance sheet it even is one. Two million lines, ten years, the moat no competitor can copy.
It leads the deck, ahead of revenue. In the data room it's the first thing you walk a buyer through, because the number does the work. You'd sell the furniture before you'd delete a line of it.
And that number is all you can show. You can't put “we made the right calls” on a slide. Taste doesn't chart. So the one part of ten years you could count became the whole pitch, and the judgment that actually made the difference never came up. You didn't choose to sell the line count. It was the only thing that would hold still long enough to be measured.
Two million lines. A machine writes them again by the weekend, and no competitor wants yours anyway. You've been guarding the vault for a decade. You never once checked whether anything in it was worth stealing.
For fifty years, code was an asset for one plain reason: it was expensive. Every line cost a trained person real time. A million of them meant years of scarce, skilled labor a rival would have to spend all over again to catch you. That was a moat, a real one.
You were not wrong to guard it. The line count tracked something true: more code, more work banked, more that a competitor could not cheaply copy. It was never clean. Bloat counted the same as brilliance, and a bigger codebase looked safer. But the slippage was small and impossible to prove, so the count stood in for the worth, and everyone let it.
The whole belief rests on one word. Expensive. The value was never in the lines. It was in the difficulty of writing them.
Then the machine learned to write code, and the one word the whole thing stood on fell over. Expensive. A component that took a team a quarter takes an afternoon. Your two million lines can be regenerated in a week, and a competitor wouldn't bother, because they would generate their own, cleaner, without your ten years of scar tissue. The moat was only ever the cost of writing the code, and that cost just went to zero.
So mark it to market. Dijkstra saw it in 1988: count lines of code not as lines produced but as lines spent, and stop booking them on the wrong side of the ledger. Nobody listened, because code was expensive enough to pass for an asset. It isn't anymore. Every line is a thing you have to read before you touch, patch when it breaks, and defend when it's attacked. The people who measure this price the debt at three dollars and sixty-one cents a line. At two million lines, the asset on your balance sheet is seven million dollars in the hole, and you have paid the interest every year without once calling it a debt.
The banks are already living it. The most valuable companies on earth run on a language almost nobody under sixty still writes. Two hundred and twenty billion lines of COBOL, three trillion dollars a day, and not one of them can get out. They pay the last engineers who understand it a fortune to keep it breathing, because ripping out the asset would kill the company. You cannot survive deleting it. That is not what an asset is. That is what a hostage is, and you have spent a decade paying the ransom and calling it your moat.
You are not a bank. You could delete the whole thing and regenerate it clean, and it would not kill you. So why won't you? Not because it's dangerous. Because the code is the only part of your company you can see. Judgment has no repository. Taste has no line count. The decade of right calls that made you worth buying left no artifact, nothing to book, nothing to put on a slide. The one asset that was ever real is invisible, and you have never managed it, because you have never been able to find it.
Fifty years ago a man named Daniel Yankelovich watched this exact thing run through American business and broke it into four steps. Measure what is easy to measure. Ignore what is not. Decide that what you cannot measure does not matter. Then decide it does not exist. He called that last step suicide. It is how you reached two million lines: every one was a thing you could count, and “we chose right” was not, so you rewarded the count and starved the judgment, one legible line at a time.
You built a monument to the only thing you could count.
The fallacy is named for a man who ran a war by body count, because bodies could be counted and winning could not. He counted, and he lost. You count your lines, and you are losing the thing they were only ever a record of.
The way out is the thing you can't stand: let it go. Not the company. The code. Delete it the moment it stops earning its keep, and regenerate what you need from the one thing you actually own, the decision about what to build. The judgment was always the asset. The code was only ever its receipt.
You can't just throw away working software. Nobody said throw it away. Keep what runs, regenerate what rots, and stop treating a git history like a vault of gold. The parts you are most afraid to touch are the parts most overdue for deletion. That fear is the interest, finally coming due.
Doing it is trivial. The machine regenerates whatever you aim it at. The only thing in the way is the flinch in your chest right now, the one insisting those two million lines are yours, precious, proof. Beat that flinch and you win. Keep it, and you become the bank: guarding a language no one under sixty will write, waiting for the last engineer who understands you to retire.
So delete it. Not the company, not the taste it took ten years to earn. The code. It was never the asset. Delete it, and go build the next one.
We build. They bill.