Software Was Always Stored Expertise
On the October 17 All-In episode, Ben Horowitz described what he called decompiled software: AI can now reproduce the functional equivalent of a commercial product from scratch at a small fraction of the original development cost. He named no targets and offered no case. The implied conclusion travels well anyway, and I have heard it repeated in procurement conversations since: if the code is cheap to regenerate, the product is cheap to replace, and the price of the license should fall toward the price of the rebuild.
That conclusion treats the code as the thing being sold. I think the code was always the container. What a buyer paid for, for forty years, was the learning that the code records, and the reliability that learning produced.
Consider what a mature payroll system knows. It knows that tax rules change mid-year in some jurisdictions and retroactively in others. It knows what happens to an employee who changes states during a pay period, and what happens when a time zone shifts for daylight saving in the middle of a shift that crosses midnight. Each of those rules entered the product because something broke for a real customer, someone diagnosed the failure, and an engineer wrote the fix. The same is true of a payment processor's retry logic, which exists because a network timeout once produced a double charge. The code carries the lesson. The lesson cost the vendor real money, real customer trust, and real years to acquire.
Reliable software is therefore an unusual product, because its value is invisible. A system that works shows no sign of the failures it avoided. The charge that never doubled, the payroll run that handled the leap-year edge, the migration that preserved every record: none of these events happened, and their absence is the product. A buyer sees a quiet system and can easily conclude that quiet is the default state of software. It is the output of accumulated expertise, produced one incident at a time.
This is where the replacement argument lets down the people who make it. A rebuild reproduces what the product does on the paths someone thought to test. It starts with none of the history of the paths nobody thought of. A model generating a replacement writes from its training, and that training does carry knowledge of common failure modes: encoding bugs, race conditions, off-by-one errors in date arithmetic. The long tail, the failures specific to a domain, a customer base, and a decade of integration partners, was found in production by the people operating the original. A replica starts that discovery process over, and runs it against the buyer's own customers.
The economics of that restart are what I find most underappreciated. The cost of writing code is falling quickly, and I take that as given. The cost of learning what the code has to handle has not fallen at all, because the lessons arrive only through operation. Regenerating a codebase in a week does not compress the years during which the original met its failures. It defers those failures to the first production quarter of the replacement, where they surface as data discrepancies, compliance gaps, outages at peak load, and a support queue full of cases the old system handled without anyone noticing.
I expect that bill to be large. This is a prediction, and I label it as one, but the mechanism is easy to follow. Thousands of organizations will each make a locally reasonable decision that a rebuild costs a fraction of a renewal, and each will carry the true cost of the missing expertise on a delay. Individually, the failures look like ordinary project overruns and ordinary incidents. In aggregate, across an industry, I would expect the figure to reach billions, with the cause attributed to bad luck or bad vendors long after the decision that produced it. The savings are visible on the day of the decision. The losses arrive scattered across years and cost centers, where nobody ties them back to it.
The expertise also lives outside the repository. A vendor's operations team knows which upgrade orders break which customers. Its support engineers know which configuration looks harmless and causes trouble at scale. Its on-call history records how each class of outage was diagnosed. A SOC 2 Type II report attests that controls operated over a period of time, which makes it a dated record of operational discipline, something a rebuilt system lacks on day one regardless of how clean its code is. All of that is part of what the license price purchased, and none of it travels with a regenerated codebase.
What does change is the cost of the surrounding labor. Building integrations, scaffolding, and routine features gets cheaper, and vendors who priced mostly on the volume of code they had written will feel real pressure at renewal. The vendors whose price reflects genuine accumulated expertise, reliability that customers can verify, and an operations record that anyone can inspect, hold a stronger position than the replacement argument allows. The difference between the two kinds of vendor is how much of the product's value sits in the learning and how much sits in the typing.
One caution on evidence. The rebuild claim rests today on a conference-stage argument and on experience with how capable code generation has become. A named commercial product rebuilt at a documented fraction of its cost, with documented parity under production load, would settle how much weight the argument carries, and my own claim about the cost of the missing expertise awaits the same kind of evidence in the other direction. The first few years of replacements will supply it.
What the software industry sold for four decades, I think, was avoided problems. The code was how the avoidance got delivered. A buyer who prices only the delivery mechanism will learn the value of the contents later, and at a much higher price.
Sources: All-In Ep. 293, "CoreWeave Crash, AI Trade Cracks, Anthropic IPO Red Flags, Bill Gates Doomer" (Oct 17, 2026); Industry Intelligence Digest, Oct 19, 2026. The cost prediction in this post is the author's own and is not drawn from cited data.