Is Pure Software Dead? The Moat Was Never the Code

For sixty years, code was the toll booth. If you wanted a machine to do something, you learned its language — C, SQL, regex, the precise dialect a compiler would accept — and that fluency was scarce enough to build careers and companies on. The premise underneath every software business was simple: writing the thing is hard, so charge for the thing.

That premise is now breaking, and the cleanest framing of why comes from a recent conversation on Naval’s AI Industrial Revolution episode: “we had to learn code to communicate with the models. Now the models speak English.” When the interface to software creation collapses from a formal language into fuzzy natural language, the thing you were charging for — the act of translating intent into syntax — stops being scarce. The provocative version of the claim is that pure software is dead. The useful version is narrower and more interesting: the code was never the moat, and now we can finally see what was.

This post takes the thesis seriously and then tries to break it, because the honest answer is in the tension between the two.

The barrier really did fall #

Start with the part that is no longer arguable. Natural language is now the dominant on-ramp to building software. The adoption numbers have stopped looking like a frontier experiment and started looking like plumbing: 84% of developers now use or plan to use AI tools, GitHub Copilot crossed 15 million users in early 2025, and the tool is in use at 90% of the Fortune 100 (Second Talent). This is not an edge case anymore. It’s standard infrastructure, the way version control or a package manager is standard infrastructure.

If the ability to produce code is becoming ambient, then any business whose defensibility rested on “we can build this and you can’t” is standing on sand. That is the load-bearing claim, and it’s correct as far as it goes.

Value is visibly moving down the stack #

Watch where the money went. The top ten global semiconductor companies carried a combined market cap of roughly $9.5 trillion in mid-December 2025 — up 181% from $3.4 trillion two years earlier, with a $6.5 trillion waypoint in 2024 (Deloitte 2026 Semiconductor Industry Outlook). AI chips, overwhelmingly NVIDIA GPU platforms, are projected to approach half of all semiconductor revenue in 2026 while making up less than 0.2% of unit volume. When intelligence becomes a commodity input, the scarce complement is the hardware that runs it. The episode’s instinct — value shifts toward hardware and model-building — is exactly what the capital markets priced in over twenty-four months. The substrate is eating the abstraction’s margin.

So what actually survives? #

Here is where “pure software is dead” gets too lazy, and the better question — which moats were never about code in the first place? — gets sharp. A February 2026 analysis from Attainment Labs names three that outlast the shift, and none of them is code complexity (AI Is Eating Software: The Three Moats That Survive):

1. Proprietary data accumulated over years. Bloomberg, CoStar, and Veeva are not valuable because their codebases are hard to clone. They are valuable because of decades of data ingestion that an LLM cannot conjure — the model needs that data to train on, which means the data, not the software wrapped around it, is the product.
2. Compliance infrastructure and regulatory certification. Epic and nCino sit behind long, expensive certification cycles. An agent can write the form; it cannot retroactively earn ten years of audited regulatory standing.
3. Deep systems-of-record integration. Ripping out Salesforce, Workday, or SAP means renegotiating hundreds of live dependencies at once. The switching cost lives in the wiring, not the source.

This is the reframe that actually pays. “Pure software” — code whose only defense is that it was difficult to write — is genuinely exposed. Software fused to data, regulation, or integration is not. The thesis isn’t wrong; it’s poorly bounded. Bound it correctly and it becomes a strategy, not an obituary.

The Klarna inflection — read the caveat, not the headline #

The crispest public test came on September 27, 2024, when Klarna CEO Sebastian Siemiatkowski announced on an earnings call that the company had shut down Salesforce and was weeks from shutting down Workday, crediting a generative-AI simplification push built on its internal assistant “Kiki.” Headcount fell from 5,000 toward 3,800, with a stated target near 2,000 (Salesforce Ben; Analytics India Magazine).

It’s a real inflection point — a CEO publicly framing SaaS cancellations as an AI decision. But the detail that matters is the one the headlines skip: Klarna did not replace Salesforce and Workday with raw LLM-generated code. It moved to Deel for HR and stitched together other SaaS tools. The moat did not vanish. It became negotiable. That distinction is the whole ballgame, and any builder reasoning from this example should hold onto it.

Now break the thesis #

A claim this clean deserves an adversarial read. The brief’s counterpoints are not decoration; they are where the strategy gets stress-tested.

The entry cost dropped; the mastery cost may not have. The most uncomfortable data point comes from a July 2025 randomized controlled trial run by METR-affiliated researchers: 16 experienced open-source developers, 246 real tasks, best-available tooling (Cursor Pro with Claude 3.5/3.7 Sonnet). AI made them 19% slower — while they believed they were 20–24% faster (METR, arXiv:2507.09089). Sit with that perception gap. If senior developers using the best tools on real codebases are slower and can’t feel it, then “anyone can build it now” overstates how far the barrier fell. Generating code got trivial. Generating correct, maintainable code in a system you understand did not.

Day 1,000 is where it bites. MIT Technology Review’s December 2025 investigation found AI tools shine on boilerplate, tests, and docs — and struggle badly with large codebases, producing verbose output where code smells exceed 90% of detected issues, hallucinating nonexistent packages, and driving a measurable rise in copy-pasted code per GitClear’s data (MIT Technology Review, Dec 2025). The zero-to-one is easy. The system you have to secure, debug, and keep alive a thousand days later is not. Complexity, not quantity, is the real wall — and it’s exactly where a lot of “AI built my whole app” stories quietly fall over.

Switching costs are compressing — but mind the source. A genre of widely repeated figures claims AI agents crush ERP migrations from the usual 18–36 months down to a handful of weeks. Squint at where those numbers come from, though, and they tend to be forward-looking projections and vendor scenarios rather than measured before-and-after results. Directionally they rhyme with Klarna, which actually did cancel Salesforce and Workday on an AI rationale. But a projection is not yet evidence. Treat the compression as a real hypothesis about where friction is headed, not a specific number you can underwrite a plan on.

And the labor signal is mixed, not apocalyptic. A Stanford study cited in the same MIT review found employment for developers aged 22–25 fell about 20% between 2022 and 2025 — real pressure at the entry rung. But it lands alongside the maintainability problems above, which is the tell: the work that’s evaporating is the junior, boilerplate tier, exactly the tier AI does well. The work that’s getting more valuable is the senior judgment that catches the hallucinated package and the 90%-code-smell PR before it ships.

The synthesis for builders #

Put it together and the slogan resolves into something you can actually act on. Pure software — code defended only by the difficulty of writing it — is dead, or close to it; the toll booth is unmanned. But software was almost never only code. The durable businesses were always standing on data, regulation, integration, distribution, and the hard-won judgment to ship something that survives contact with year three. AI dissolves the cheap moat and throws the expensive ones into sharp relief.

If you’re building today, the move follows directly: stop selling the act of writing code, because that’s converging on free, and start compounding the things that don’t — proprietary data, regulatory standing, deep integration, and the verification muscle to stand behind a system you didn’t type line by line. The barrier to entry has collapsed. The barrier to mastery just got more valuable, and more lucrative, than it has ever been.