IBM's moat was never the mainframe. It was the cost of leaving.
TL;DR [show]
IBM's worst single-day stock drop in 115 years reads as a bad quarter. It is a moat dissolving. The mainframe franchise was never defended by product superiority; it was defended by switching cost, a forty-year COBOL install base too expensive and too risky to move. Once LLM-assisted porting collapses migration cost toward zero, the workload leaves the platform, not just the budget cycle, and incumbency stops being defensible. The inverse of the position-not-model thesis: here the position was the moat and the model is what dissolves it. Generalizes to every legacy-lock-in franchise, on-prem ERP, proprietary EHR data layers, any business whose defensibility is that it is too expensive to leave.
IBM had the worst single day of its 115-year life last Tuesday. The stock fell about a quarter, wiped out on a mainframe software miss, and the tidy explanation arrived before the closing bell. A timing problem. Clients pulled spending forward into supply-constrained servers and memory ahead of price hikes, the software line took the hit, and the mainframe franchise rebounds next quarter once the budget cycle resets. A bad quarter, not a bad decade. Nothing here a calmer Q3 does not repair.
Ben Thompson read it differently, and he is right to. Writing in Stratechery the next morning, he argued the thing that should frighten IBM is not the capex cycle at all. It is that the workloads sitting on those mainframes, the COBOL, the Z software, the four-decade sediment of code that no living employee fully understands, are for the first time cheap to move. Point a capable model at a pile of COBOL and it will hand you a working port to something modern. The capex story describes the symptom. The migration is the disease.
That reframing does the real work. For forty years the mainframe was sold as a superior machine, and for a good while it genuinely was. But that stopped being the reason anyone kept paying. The reason a bank still runs its core ledger on Z in 2026 is not that nothing better exists. It is that moving off would mean rewriting millions of lines of COBOL that encode business rules nobody currently employed ever wrote, with no spec, no tests, and a failure mode that ends with payroll not clearing. The quote for that project came back in the hundreds of millions, with a live chance of taking the bank down mid-migration. So nobody moved. The moat was never the mainframe. It was the size of that bill.
I have sat in the rooms where that bill gets estimated, and the estimate is the entire game. You do not stay on a legacy platform because you love it. You stay because the migration quote came back at eighteen months, forty engineers, and a number with too many zeros, and the CFO looked at the risk-adjusted version and said not this year. Every year, not-this-year won, and the install base got read as loyalty. It was arithmetic wearing loyalty's clothes.
People have been predicting the mainframe's death since roughly 1994, and they have been wrong every single year, which makes any new version of the claim easy to wave off. But every prior prediction was about the destination. Client-server would replace it, then the web, then the cloud, and each time the target platform got better while the thing that actually pinned the workload in place, the cost of rewriting the code, did not move an inch. This is the first prediction that is about the rewrite instead of the destination. The target has been good enough for twenty years. What changed is that the rewrite got cheap, and the rewrite was the only thing that ever held the customer there.
Collapse the quote and you collapse the reason to stay. That is what a model that ports COBOL does. Not cleanly, not yet, and the demos oversell it the way demos always oversell. But the direction is not in dispute. The eighteen-month project becomes a three-month project, the forty engineers become six people and a model, and the number the CFO risk-adjusts comes back small enough to sign. A workload captive for forty years turns portable inside a single planning cycle. And a missed quarter of mainframe software revenue stops being a missed quarter, because the revenue was attached to a workload that is now walking out the door.
None of this is really about IBM. IBM is only the first franchise old enough and large enough for the effect to land on a single trading day. The same bill sits under every business whose defensibility is the cost of leaving it. On-prem ERP that took three years and a consultancy to stand up. The proprietary data layer inside an electronic health record that no hospital can abandon because two decades of patient history live in a schema only the vendor documents. The billing platform, the industrial control system, the custom scheduling engine at the airline. Each has spent decades pricing its renewal against the pain of the customer's exit rather than the value of its product. Each has been quietly charging rent on the difficulty of leaving.
There is a winner in this, and it is not the incumbent. When the cost of leaving falls, the money that used to sit frozen as renewal revenue on the old platform gets freed, and it flows to whoever runs the port: the integrator, the tooling vendor, the model provider that reads legacy code well. The captive-renewal line on the incumbent's income statement becomes a migration budget on somebody else's. That is the same dollar, re-pointed. It is why a mainframe software miss is not a rounding error the market can wave off. Frozen revenue and captive revenue look identical on a chart, right up until the freeze breaks. The market is watching a revenue stream discover it can leave.
When the exit gets cheap, the whole model reprices, and it reprices without the product changing at all. The mainframe is the same machine it was last week, still fast, still reliable, still running the ledger at three in the morning. What moved is the number on the far side of the door. For forty years the operative question in enterprise software was how sticky the install base is. That question is finished. The one that replaces it is how portable the workload is, and portability is a property the customer now holds, which means it is not a line a vendor can put on an invoice. The pricing power was living in the friction of leaving. The model dissolves the friction.
The objection writes itself, and it is not wrong. Porting a core banking system is not a weekend project. The generated code has to be validated against forty years of edge cases, the regulators have opinions, and the first bank that tries it and fails becomes a cautionary slide in everyone else's board deck. All of that is true, and all of it buys the incumbents time. What it does not buy back is the moat. Time is what you have when the outcome is settled and only the schedule is still open. Every one of those objections argues about how many years, not about whether. The valuation was built on whether.
So IBM did not get outbuilt. Its strongest defense, the sheer misery of leaving, was the one asset a language model was always going to come for first, because the misery of leaving is undocumented complexity, and undocumented complexity is precisely the thing these models turn out to be good at. The machine still works. It was never the machine that held the customers. It was the wall around the exit, and the wall comes down at the speed software comes down, which this year is fast. Forty years of captivity was a business model. It is about to read as a warning.
—TJ