SaaS is Dead

When apps become conversations

For decades, if you needed a specific software tool – be it a personal recipe book or a niche finance tracker – you had two choices: find a one-size-fits-all SaaS product, or write the code yourself (or beg a developer friend). Those days are ending. Thanks to large AI models, we’re now on the cusp of user interfaces built from simple prompts. You don’t install software anymore; you ask for it. Apps like ChatGPT and Claude are starting to blur the line, moving beyond text answers toward generating working UIs on the fly. New tools like Vercel’s v0 and prototypers such as Lovable even let you describe an interface and watch an app materialize. Anthropic’s Claude can execute code via its Artifacts feature. These early glimpses all point in the same direction: software that builds itself at your request. The interface becomes a conversation, and anyone can be the builder.

Build it, use it, throw it away

If software can be summoned in moments, we should stop treating every app as a lasting asset. Not every program needs a years-long lifespan or a dedicated team behind it. In fact, a whole class of applications will be ephemeral by design – made to scratch a particular itch and then disappear. Think of it as disposable software you spin up for as long as you need it and toss aside when you’re done. For example, imagine conjuring any of these micro-apps on a whim:

• A personal recipe book app for tonight’s dinner.
• A mini-game you design to entertain friends for an evening.
• A dashboard combining all your scattered finance data into one view.
• A live F1 season tracker showing just the stats you care about.
• A “rate-my-pizza” journal for your weekend food adventures.

In the time it once took to hunt down a generic SaaS solution (with its sign-ups, subscriptions, and feature bloat), you could have an AI generate a tailor-made app that does exactly what you want. And when you’ve gotten your value from it, you simply let it fade away. This isn’t play software either – these throwaway apps can tap into real data sources on the fly. Want to import recipes from a website or pull your bank transactions into your new dashboard? Just ask. In this future of open pipes and on-demand integration, your ephemeral app can connect to any API or data source as needed, then vanish without a trace. The result is software that exists only as long as it’s useful. Use it, solve the problem, then build the next thing.

No code, no problem

What does it matter how these prompt-built apps work under the hood? Frankly, it doesn’t – and that’s the point. When an AI can write all the code behind an experience, we stop caring whether it’s JavaScript or Python, iOS or Android, SQL or NoSQL. All that matters is that it works and it works now. At Review, we chose Python and React as our building blocks not because we love those technologies for their own sake, but because they’re so well-documented that an AI can wield them with ease. The large language model has effectively read the entire internet’s worth of React docs and StackOverflow threads, so it produces reliable code in that stack with minimal fuss. But fast-forward a bit, and even that implementation detail melts away. In a world of on-demand apps, the language and framework don’t matter at all – in fact, what language? The code becomes an ephemeral byproduct of your request, akin to assembly output from a compiler. You won’t read it, you likely won’t even see it. As I suggested in The End of Code, software may “crystallize only when a user shows up… then evaporate when no one needs it”. The concept of “code” starts to feel like a historical implementation detail. We stop thinking in terms of code and begin thinking purely in terms of experiences.

SaaS is dead, long live the prompt

This shift has big implications for how we think about software products. The traditional SaaS model – monolithic apps built to serve millions with a fixed set of features – begins to crack when every user can have a custom app tailored to their exact needs. Why pay for a bloated service (and contort your workflow to fit it) when you could ask for exactly what you want and get it instantly? The idea of installing and subscribing to a dozen one-size-fits-all apps for different needs starts to feel outdated. Instead of Software-as-a-Service, we get Software-as-a-Prompt. It’s software that isn’t a long-lived product at all, just a transient solution, spun up just in time for the task at hand. Today’s software feels like a product you “use”; tomorrow’s software will feel like a conversation you’re having. The SaaS era was about providers and platforms; the SaaP era (if we dare name it) is about you and your momentary problem. This doesn’t mean every piece of software on the planet becomes ephemeral overnight – infrastructure, back-ends, and mission-critical systems will still value stability and longevity. But for a huge swath of apps we interact with, the default assumption will shift. If it’s not an always-on core system, why shouldn’t it be a temporary, on-demand experience? Software is eating the world, yes – but now it’s learned to digest in real-time and then evaporate.

Where does that leave developers?

Handing the keys of app creation to everyone sounds liberating – and it is – but it inevitably changes the role of those of us who write code for a living. What do “dev tools” even mean when the builder is often not a developer at all, but an AI responding to a natural-language prompt? In this new paradigm, the best “development environment” might be a chat box and a brain full of ideas. The future of dev tools in this space isn’t about our text editors or build pipelines – it’s about democratizing creation. It’s interfaces and feedback loops that help non-developers shape software, safely and intuitively. As for the engineers: we won’t vanish, but our focus shifts. Our job stops being cranking out code by hand and becomes curating, guiding, and supporting these AI-driven builders. We’ll craft the platforms that make prompting an app feel seamless. We’ll bake in the guardrails and policies that ensure the right app gets built – securely, ethically, efficiently. In a recent post I argued that as code fades, we become “guardians of outcomes rather than caretakers of source files”. That remains true. Developers will spend less time wrestling with low-level syntax and more time defining what the software should do and why. Product thinking and problem definition replace line-by-line programming. The skill to clearly articulate intent becomes as critical as the ability to debug a null pointer was in the old era. In short, we become the teachers, troubleshooters, and quality assessors for a software engine that largely writes itself.

Software engineering isn’t going away – it’s evolving. When anyone can build an app by simply describing their idea, the world gets a lot more software. Our responsibility as technologists is to embrace this abundance, guide it, and ensure it runs safely. But we also get to embrace a newfound freedom: not every app needs to be a polished, perpetual monument to our coding prowess. Sometimes, a quick-and-dirty tool is exactly what the moment calls for.

So go build something – then go ahead and throw it away. Why not? Software is cheap now, ephemeral and abundant. As my co-founder, Maisem Ali, put it in his post Ephemeral Software, we’re entering an era of “personal, disposable, just-in-time software”, software that’s meant to be modified, broken, and tossed aside once it’s done its job. The sooner we stop clinging to the idea that every app must be a lifelong product, the sooner a billion more people can start creating software to solve their own problems. The future of software is just-in-time, on-demand, and made for one (or few). And when apps are as fleeting as our ideas, the only limit is how clearly we can express what we want. The next killer app might last only an afternoon – and that’s perfectly fine.