Most of the new software being built right now will never have more than one user. One person, one team, or one company. The industry thinks that is a failure. I think it is the entire point; and that it signals the end of the fifty-year compromise that created the SaaS industry, and the beginning of the “SaaSpocalypse.”
Software started out as a jungle of bespoke offerings. In the beginning, before computers were on every desk and then in everyone’s pockets, every program was written for a specific machine, a specific problem, and a specific organisation. Individual banks wrote their own banking software. Airlines wrote their own reservation systems. Governments wrote census tabulators. If you needed software, you hired a programmer, and then they built exactly what you needed, because there was no mass-market for software.
Then computers became pervasive much faster than the supply of programmers could grow. By the early eighties there were more problems that needed software than there were people to write it. The economics forced a compromise. Instead of building exactly what each organisation needed, the industry productised. General-purpose tools emerged. Spreadsheets. Word processors. Databases. CRMs. ERPs. Each one was nobody’s ideal solution, but everybody’s adequate one. VisiCalc, and then Lotus 1-2-3, and then Excel did not win because they were the best possible tools for any particular accounting problem. They won because hiring programmers to build a bespoke accounting system cost much more than buying a licence to run Excel, and Excel was good enough.
General-purpose applications became entrenched and expected; and then the arrival of the internet meant that every machine was now networked. SaaS was the logical endpoint of the productisation of software in that new environment. These days, instead of buying general-purpose software outright, we rent it.
Salesforce is not the CRM any specific company would design for itself. But building your own CRM would cost hundreds of thousands of pounds in developer time, so the subscription makes sense. The entire SaaS layer exists because bespoke is too expensive, and because general-purpose is good enough most of the time.
That “good enough” compromise is the thing that is dying.
The cost reversal
A quarter of Y Combinator’s Winter 2025 batch had codebases that were 95% AI-generated. Andrej Karpathy’s “vibe coding” went from neologism to Collins Dictionary’s Word of the Year. The cost of producing software has collapsed in step functions. In January last year DeepSeek showed that AI inference was cheaper than anyone had priced in; and then earlier this year the “SaaSpocalypse” erased $285 billion in software market cap. The following month Google’s TurboQuant reduced LLM memory requirements by a factor of six. Goldman Sachs warned it could be “the beginning of a structural decline similar to newspapers.“
But software is not newspapers. Software demand is not fixed.
Aaron Levie pointed out the mechanism that applies here. It’s the Jevons paradox. When technological efficiencies meant that less coal was needed for existing tasks in nineteenth-century England, coal consumption did not fall. Instead, it went up, because those efficiencies made coal more economical to deploy in places it had never reached before. Jim Rutt wrote the best analysis I’ve seen of why this applies more forcefully to software than it does to coal. Coal has diminishing returns; software is combinatorial. Every new piece of software creates integration surfaces that demand yet more software. Software also has near-zero marginal distribution cost, but near-infinite marginal customisation cost; and the physical world remains massively under-digitised.
Rutt’s example is a 50-person manufacturing company which is currently running the shop floor on a mix of spreadsheets and a whiteboard, which probably has a bunch of Post-It notes stuck to it. If you collapse the cost of building software by an order of magnitude, it becomes economical for this company to build custom tooling for its specific machines, specific compliance obligations, and specific workflows. Now think of every individual hospital, law firm, school district, and farm co-op that has never been able to justify bespoke software, and you start to see the scale of latent demand that cheaper production unlocks.
That manufacturer does not need Salesforce, and they do not need 90% of the features in any general-purpose tool that services their niche, likely including the spreadsheets they’re using right now. They need one specific thing, and if they’re using a SaaS platform at all instead of a whiteboard covered with Post-It notes, they have been paying through the nose for a platform because of that one thing that happened to be bundled inside it.
Agents can now build that one specific thing for them. Because of that, software is returning to a world where it’s a bespoke product.
Prototype quality is fine
This is where most people in tech get things wrong. The instinct, deeply ingrained, is that all software needs to be robust, scalable, well-tested, and maintainable. Clean code. Proper abstractions. Code review. CI/CD. The full engineering discipline.
That instinct is correct for general-purpose software. It is wrong for single-organisation, single-purpose software.
The 50-person manufacturer’s scrap-rate tracker does not need to scale to a million users. It needs to work for one company, for one purpose, and on one shop floor. Theirs. If the code is ugly, nobody has to read it. If the architecture does not scale, it does not need to. If it breaks in six months, when something changes that the original software just didn’t anticipate, an agent can rebuild it in an afternoon. The fragility is a feature, not a bug.
This is what the accusation that vibe coding produces unmaintainable slop misses.
The criticism applies the general-purpose quality bar to software that was never meant to be general-purpose. A prototype you would normally throw away is exactly the right level of quality for software that only one organisation or person will ever use, in a single location, for one task, where they previously used a spreadsheet, a whiteboard, and some Post-It notes. The single-shot software that agents generate is not a failure of engineering discipline. It is a return to the original model: software built for a specific problem, used until the problem changes, then replaced.
Klarna is the canonical case study of where this leads at scale. CEO Sebastian Siemiatkowski announced that Klarna was shuttering use of roughly twelve hundred different SaaS platforms, and building internal replacements with AI. They replaced commercial SaaS with internally-built software, because AI tooling let them build bespoke replacements at less expense than renting general-purpose solutions.
But despite this, and despite the headlines, job market data shows there isn’t a contraction in demand for software engineers. There are 67,000 open engineering roles at tech companies globally, the highest any time in the last three years, and up 78% from the 2023 trough. AI-specific roles are up 438%. The industry is not shrinking. Instead it is shifting from building general-purpose products to building specific solutions.
A distribution of one
There is another mistake the industry is making, and it is the mirror image of the first.
John Burn-Murdoch’s analysis in the Financial Times pointed out that mobile app releases have surged since the arrival of agentic AI, but downloads and reviews have not followed. Most of the new apps are failing to capture even a modest audience. The conclusion, from both the paper and the coverage of the piece, is that AI is producing more software but not more value.
I think this misreads what is actually happening.
If we’re returning to bespoke software, then many of those apps were never looking for an audience. They were built by one person, or one team, or one company, for their own use. A scrap-rate tracker for a single shop floor. An internal scheduling tool for one clinic. A compliance form generator for one firm’s specific regulatory obligations, and rather odd workflow, that nobody else will want. The developer may well be the user. They do not need downloads. They do not need reviews. A distribution of one is not a failure: it was the whole point.
The flat download curve might not be evidence that AI-generated software lacks value. Instead it could well be evidence that the nature of software production has changed. The industry is measuring new software with the old ruler again. They’re measuring reach, adoption, and market share. Those metrics made sense when software was a product. But when software is bespoke, the only metric that matters is whether it solved the problem it was built to solve. That metric does not show up in download statistics.
The division
Not all SaaS dies. Instead the market seems to be splitting along an obvious line.
Simple tools that charge serious money for something relatively straightforward are getting repriced. If you can build something in a weekend with an agent, the subscription has to match the complexity of the product, not the historical cost of building it. A lot of SaaS organisations are about to discover that their pricing assumed a forever world where building software was hard.
However: complex, critical software gets stronger. Nobody is going to vibe-code their compliance platform. Nobody is going to let an agent build the system that handles regulated client data. CrowdStrike’s share price was up 51% in 2025. Data infrastructure trades at 6.2× next-twelve-months revenue, the highest of any software category. Sales and marketing automation trades at 1.9×. AdTech at 1.1×. The market is rewarding software that customers literally cannot live without, and punishing everything else.
Vendep Capital put it most bluntly, “In the age of AI, clinging to the idea of a data moat is a fatal strategic error. Real defensibility now comes from owning the workflow — embedding in the flow of money, physical things, or compliance.”
The open source knock-on
There is a knock-on effect for open source that I think most people are missing.
When software was expensive to produce, source code availability was a developer feature. Only developers could read it, modify it, compile it, and deploy it. The GPL mattered because it governed what developers could do with code. The licence wars of the 1990s, and the relicensing wave that followed between 2018-2024, were fights between developers and companies about who captured the value from code.
Agents change the audience. If your operations manager can ask an agent to read an open source tool’s source code, understand what it does, modify it for a specific workflow, and deploy the modified version, then source availability is no longer a developer feature. It is a user feature. The non-technical person does not need to read the code. They need the agent to read the code on their behalf.
Bret Taylor sees this and identifies two possible futures. In one, open source becomes less important because everyone independently regenerates functionality with agents. In the other, open source platforms survive by being agent-hackable, shipping with interfaces that make them easy for agents to extend and modify. The second future is the interesting one, because it implies that the value of open source shifts from the code itself (which anyone can regenerate) to the documentation that describes what the code does and how to work with it. The specification becomes the durable artefact. The code becomes disposable.
I wrote about this recently. The specification is the program. The code is a byproduct.
But culture is sticky
If the economics are this clear, why isn’t SaaS dying more quickly?
It is dying a slow lingering death because people are habituated to subscriptions, and habituation runs deeper than practicality. Streaming accounts for 84% of US recorded music revenue, while almost 80% of adults worldwide have at least one paid subscription, and most of them substantially underestimate what they spend on them.
Gen Z home ownership sits at just 27%, they’re the only renter-majority generation. We lease cars, dresses, telephones. What started with economics has now become cultural. We have moved from an ownership economy to an access economy, and subscription models are now embedded at that cultural layer.
The SaaS model has cultural inertia. Organisations are habituated to paying monthly for software they do not own, and the psychology of small recurring payments is deeply embedded. SaaS will erode rather than collapse. But nonetheless, the direction is set.
What survives?
The death of SaaS is not the death of software. The software industry is not dying. Instead it is reorganising around a different scarcity.
Code was scarce. It is not anymore. What is becoming scarce is everything else. The compliance and regulatory depth that lets you tell an auditor the system works as promised. The accumulated data, the embeddings and conversation histories and fine-tuned models; those things that make a system actually useful rather than merely functional. The specifications that tell the next agent what was built and why, without which every modification is a gamble.
The SaaS companies that survive will be the ones whose value lives in trust, data, and specification. The open source projects that matter are the ones with interfaces rich enough for agents to read and modify. The manufacturers, hospitals, and law firms that Rutt describes will build bespoke software, because they finally can again.
Software started as a bespoke product. It became general-purpose because building bespoke was too expensive. It is becoming bespoke again because agents have collapsed the cost. The general-purpose compromise that created the SaaS industry was an artefact of scarcity. The scarcity is gone. The compromise is going with it.