The Death of Software Is Greatly Exaggerated (and the Market Read It Backwards)
This year the market decided software is dying.
The headlines talk about a kind of SaaS apocalypse: a stack of publicly traded software companies have watched a huge chunk of their market cap vanish — trillions of dollars, all told — under a thesis that's simple and brutal. If an AI agent can do the job your product used to do, why would anyone pay for your product? The argument is clean, it fits in a tweet, and it has moved a lot of money.
And, like almost every clean thesis that moves a lot of money, it's a backwards reading of what's actually happening.
I'm not writing this from the investor's seat. I'm writing it from the builder's. I've been shipping software to production long enough to have watched the industry buried a few times, always with the same pattern: a new technology makes one piece of the value obvious, the market mistakes that piece for the whole, and while everyone's at the funeral, the real work quietly relocates to another part of the stack. This time is no different. What got cheaper isn't the software. It's the model.
The market didn't kill software; it repriced the model
The confusion underneath all of this is treating "model" and "software" as the same thing. They aren't, and the difference is the whole story.
A language model is an impressive statistical engine and, every quarter that passes, a cheaper and more interchangeable one. Today you've got half a dozen frontier models doing, for all practical purposes, comparable work, and you can swap one for another with a config change. That is, literally, the definition of a commodity: a powerful input, sure, but with no defensive moat, because the guy across the table has the same input at the same price.
What the market punished isn't the death of software. It's the sudden, badly digested discovery that the model isn't a moat. And it was right to punish the companies that had convinced everyone it was. What it read wrong is the next step: assuming that if the engine is cheap, the whole car is worth zero.
Anyone who's built real systems knows the engine was always the easy part.
We've seen this exact movie before
In the early 2000s, when SaaS started eating packaged software, the fear was identical: the cloud will commoditize software, margins will evaporate, the giants are finished. Perpetual licenses, install CDs, servers in the customer's basement — all of it was dying, and it genuinely did die.
And the software industry, meanwhile, multiplied. What was a market of a couple hundred billion dollars a year ended up moving something like a trillion and a half in little more than a decade. The supposed corpses — the Microsofts, the Adobes, the Oracles — didn't just survive: they became several times larger than they'd been before the disruption that was meant to kill them.
The lesson isn't "everything will be fine." Some companies did die, and plenty of specific jobs genuinely disappeared. The lesson is more precise: disruption is not the same as death. What happened with the cloud wasn't a contraction of software, it was a change of shape — and, in the process, a brutal expansion of how much there was to build. Anyone who mistook "my ten-year-old business model is dying" for "software is dying" sold at the single worst moment in history to do it.
"AI won't replace software: it'll use it"
Here's the line that flips the whole pessimistic thesis on its head, and it's worth reading slowly: the AI agent isn't a substitute for software. It's its most demanding new user.
Think about what an agent actually needs to do useful work against your systems. It needs a clean, versioned API to call. It needs granular permissions, because you're not handing it the keys to everything. It needs idempotency, because an agent retries. It needs rate limits, because an agent stuck in a loop can hammer an endpoint a thousand times a second. It needs traceability and auditing, because when an automated action touches a customer's accounting, someone is going to have to know who decided it and why. It needs guardrails, sandboxing, and a tool surface designed so that a non-deterministic actor can't trash the place.
None of that exists on its own. All of it is software, and engineers build it. When your hungriest user stops being a person clicking a button and becomes an agent firing a thousand actions a minute, the software surface you have to build and operate doesn't shrink: it explodes. Every capability you used to hide behind a human interface now has to be exposed, secured, throttled, and monitored like a first-class tool. That's more engineering, not less.
The call center that answers questions off a script — yes, that one the agent genuinely replaces, and pretending otherwise helps no one. But the system the agent uses to actually resolve the case — pulling the order, validating the policy, issuing the refund without breaking anything — someone has to build that, and it doesn't build itself.
Value moves up the stack; it doesn't disappear
If the model is the cheap, interchangeable engine, where does the value go? Up. Toward the layer the model can't hand you: your data and, above all, your trusted workflows.
A frontier model doesn't know how your company processes a return, what your compliance rules are, what "high-risk customer" means in your sector, or which step in that six-link process is the one you never, ever skip. All of that knowledge — codified, verified, integrated with your real systems — is exactly what you can't download from a model provider. It's the moat. And it happens to be the hardest and most expensive part to build: the integration, the data quality, the verification, the guardrails, knowing when to escalate to a human.
I argued in more detail why this layer — the harness around the model — is where the engineering actually lives, and why its growing complexity points to more work for engineers, not less, in Agentic-as-a-Service and the Return of the Engineer. The short version, for those in a hurry: the model commoditizes the easy 80%, and the differentiation moves entirely into the system wrapped around it. That system doesn't generate itself.
Pricing changes shape; it doesn't disappear
The other half of the panic is the business model. If you stop selling "seats" because there are no humans sitting in front of the screen anymore, how do you charge?
You change the axis. Instead of billing per user, you bill for work done: per agent action, per case resolved, per outcome. And that shift, far from being a threat, is the dream of anyone selling software that actually does things: you stop charging for how many people open the app and start charging for how much value it generates. Companies already making this transition report that a substantial share of new business is no longer sold by the seat. This isn't the end of software monetization. It's a more honest way to monetize it.
A business model that evolves is not an industry that's dying. It's an industry growing fast enough to scare the people watching from the outside.
What I'd do this quarter if I were your CTO
Three concrete bets, because a diagnosis without action is just a nice opinion:
- Don't bet the moat on the model. If your differentiation depends on which LLM you use, you don't have differentiation — the guy across the table can rent the same one tomorrow. Put the moat where it can't be rented: your data, your workflows, your verification, your integration.
- Treat every agent as a first-class user. Design your APIs, permissions, auditing, and guardrails assuming your primary customer will be non-deterministic and tireless. What you build here is the part that's genuinely hard to copy.
- Count engineers up, not down. The headline temptation is to cut because "AI does it now." The bet from someone who's seen the movie before is the opposite: the expansion of the software surface demands more people who can reason about probabilistic systems under load, not fewer. Whoever cuts today will spend 2027 rehiring — exactly as happened to the ones who jumped ahead of the layoff fashion.
The line I've always defended is the same, and now the market is illustrating it for me with an expensive funeral: AI doesn't replace software, it uses it; and it doesn't replace the engineer, it leverages them. What died is the comfortable idea that the engine was the moat. Everything else — the whole car — still has to be built, and there's never been more of it to build.
The death of software, like that of a certain writer, has been greatly exaggerated. And the ones who can read it right-side up will be the ones shipping the systems that actually matter this decade.
Are you building the layer that genuinely makes the difference — workflows, integration, verification — and you need senior engineers who know where AI augments and where it doesn't? Talk to a CTO about deploying a nearshore squad that builds the moat, not just wires it up.
