It’s the End of SaaS as We Know It (And I Feel Fine)

In a recent interview on The Pragmatic Engineer YouTube channel, Peter Steinberger discusses agentic systems and makes a claim that is easy to dismiss but hard to forget. In his view, roughly eighty percent of the apps on your phone are going to disappear, not because software becomes less useful, but because the way we create and use it is changing so fundamentally that much of today’s apps will no longer make sense. Of course, this also applies to SaaS. 

What gives this claim weight is the context in which it is made. Steinberger is not speculating from the sidelines. With projects like OpenClaw and PSPDFKit, he is operating close to what currently seems like the upper bound of agentic coding and knows the app world better than many others. Even if we do not yet know how far this will go, it already makes one thing unmistakably clear: the dynamics of software creation have shifted completely. These tools put unprecedented leverage in the hands of individuals, and the speed at which one can ramp up from idea to working system is unlike anything we have seen before.

By the time I encountered that interview, I had already lived through parts of this shift myself, without fully realizing what it meant on a meta level.

In December 2024, I replaced a real, physical property management service with software I built myself. I did not care about the code, its structure, or its elegance. I did not care whether it would pass any conventional review. I only cared that it worked, and that it worked for me, for my situation, and for my purposes. Over slack time on a weekend with some refinements during the week, I put together an end-to-end application that handled voice transcription, coordination, and workflows I had previously outsourced to people. I built it on replit, using AI tools that, only a year earlier, would not have been capable of carrying that kind of responsibility.

That experience mattered because it quietly removed a source of significant friction from my life. AI was no longer assisting a process. It had replaced it entirely. It was no longer about productivity. It was about ownership.

Around the same time, we began experimenting more seriously with Hörnest (www.hoernest.com). This was not our first product. We have been building software for decades. However, this was the first time we allowed AI tools to sit at the center of our development process rather than at the edges. Our earliest attempts were rough experiments in replit, moments where the first real sense of power became tangible. Not because the tools were perfect, but because they allowed us to move from intention to execution with almost no friction.

At first, we treated this cautiously. We did not jump into what people now call “vibe coding.” Instead, we began deliberately integrating AI into more and more parts of our workflow. Design, prototyping, implementation, refactoring, testing, documentation. Step by step, it stopped being a helper and started becoming part of the system itself. What emerged was not chaos, but a different mode of engineering. Less about typing and more about orchestration, direction, and judgment.

Eventually, Hörnest became the first product we built substantially end-to-end with AI tools. Not entirely, but meaningfully so. It shipped. It worked. At the time, I believed the breakthrough was completeness. We could finally go from idea to product without a large team. We could collapse roles, shorten feedback loops, and move faster without sacrificing quality. I knew something important had happened, but I still framed it as a tooling upgrade, as a faster way of playing the same game.

What I missed was that the game itself had changed.

That realization came later, through something much smaller and much more personal. I built SVS Bot to help me handle reimbursements from my public and private health care providers. It had no positioning, no ambition, no market narrative. It existed solely to remove a recurring annoyance from my own life.

While building it, I noticed something uncomfortable. I kept trying to make it work for every imaginable scenario and to create a product. I kept widening the scope, abstracting prematurely, and worrying about edge cases I would likely never encounter. The impulse was automatic. It was the old SaaS reflex, still deeply ingrained, pushing me to generalize before I had earned the right to be specific.

That reflex exists for a reason. For most of the history of modern software, building was expensive. It required teams, planning, coordination, and overhead. When creation costs months, narrow tools feel irresponsible. You are pushed toward markets instead than people, toward scale rather than honesty. Out of that scarcity grew the familiar machinery of SaaS: roadmaps, prioritization rituals, and endless debate about what not to build.

At some point during the SVS Bot build, something finally gave way. I realized that it did not matter whether this tool worked for others or covered every conceivable use case. It worked for me, and that was enough. Once I accepted that, the entire project relaxed. The tension disappeared. I stopped fighting the scope and started shaping the experience. I allowed myself to care about how it feels to use, about making it calm and even beautiful, not as a strategy, but as a form of respect for my own time.

What still feels almost unreal is how little it cost. The entire thing took a weekend. That is only possible because the cost of building has collapsed to the point where specificity is affordable again.

This is the deeper meaning behind claims like Steinberger’s 80 percent. It is not that one universal agent will replace everything (at least not yet). It is that a vast amount of existing software exists primarily to justify the overhead of its own creation. SaaS did not become bloated because people made bad decisions. It became bloated because the economics demanded scale. When those economics change, the logic collapses with them.

What we are moving toward looks less like platforms and more like individual software. Personal agents. Small tools. One-off applications built because someone wanted them to exist. Many will never scale, and that will be perfectly fine. Some will spread naturally, not because they were designed to capture markets, but because they were built out of curiosity and joy.

There is a historical echo here. Doom is often mentioned in these discussions not as nostalgia, but as a reminder of what happens when constraints align. Its early development was driven by a small, focused group with a clear creative vision, long before it became a cultural landmark. The point is not romance. The point is that when overhead recedes, pure passion and craft have room to surface.

Agentic coding is collapsing constraints again, but this time the leverage is available to individuals. That is why projects like OpenClaw and, at its core, Mario Zechners Pi matter, even if we do not yet know their final form. They show that software engineering has crossed a threshold. Not just technically, but conceptually.

This is not merely a change in tools. It changes the metaphysics of software engineering itself. What it means to build, what it means to justify a piece of software, and who is allowed to create it at all.

That is why this moment feels less like a crisis and more like a release. The end of SaaS as we know it does not mean the end of software. It means the end of software that has to pretend to be an empire to exist.

We are entering a phase where it is acceptable again to build something small, personal, and complete. To build for yourself. To let it be beautiful. To call it finished without asking for permission. To let it bloom, perhaps even be adopted by an AI that evolves it further, or perhaps not.

It is the end of SaaS as we know it. It is the advent of individual software, and I feel fine.