The Future of Software Is Personal

What happens when software can adapt to us, rather than the other way around?

There's been a lot of discussion lately about the potential "SaaS apocalypse" (or "SaaSpocalypse"), the idea that AI could eventually replace much of the software we use today. Around the time OpenClaw started gaining popularity, I noticed people creating their own small applications, including to-do lists and other productivity tools tailored to their specific needs.

As someone who develops software myself, this got me thinking about why more people aren't doing the same, particularly now that AI has made the technical side of creating software so much easier. Perhaps more interestingly, I started wondering why I wasn't doing it more often myself, despite having the skills and tools available.

I've been exploring some of these ideas while experimenting with my own website, but the more I've thought about it, the more I've started to wonder whether the future of software might involve something beyond simply creating applications on demand. What if software could become considerably more malleable, adapting to our individual needs rather than requiring us to adapt to it?

Software That Adapts to You

Today, when we need software, we typically search for an existing application, compare our options, and choose the one that most closely matches our requirements. Rarely is it a perfect fit, but we've become accustomed to working within the limitations of the applications we choose, sometimes changing our habits to accommodate the way they were designed.

I've been thinking about how medicine is expected to become increasingly personalized, partially through advances in AI. Rather than relying on treatments developed around the average patient, we could eventually have treatments selected or developed based on an individual's particular needs. Ideally, patients wouldn't even need to know which treatments were available, because the system would understand enough about them to help determine what would work best.

I imagine something similar happening with software. Instead of choosing between applications that only partially meet our needs, we could have software created specifically for us, taking into account our preferences, circumstances, and the ways we like to work.

Software That Anticipates Your Needs

One of the challenges with software on demand is that people aren't accustomed to thinking about software as something they can create. Even developers, who now have increasingly powerful AI coding tools at their disposal, don't necessarily think to build something every time they encounter a problem. I certainly don't, despite spending a considerable amount of my time working with software.

Part of this may simply be habit. We've spent decades living in a world where creating software required specialized skills, significant time, and often considerable expense, so we've learned to look for existing solutions rather than imagine creating our own. AI is changing the technical requirements, but that doesn't automatically change the way we think.

And while coding has become dramatically easier, creating good software still takes time, focus, and creativity. The applications I build aren't typically completed in a single prompt. I spend time thinking through how they should work, experimenting with different approaches, and refining them as I go. Removing much of the difficulty of writing code doesn't necessarily remove the effort involved in deciding what to build.

This makes me wonder whether the future isn't simply software we can request, but software that recognizes our needs before we do. If an application understands how we use it, learns our preferences, and recognizes patterns in our behavior, perhaps it could gradually make improvements without requiring us to identify every opportunity ourselves.

Imagine an application that notices you're repeatedly performing a task in a particular way and adjusts its interface to make that task easier, or recognizes a need for a feature that doesn't currently exist and creates it. Rather than having to search for a different application or learn how to accomplish something through a complicated series of steps, the software could simply evolve.

Personally, I'd lean toward a system that makes these improvements automatically, informs the user afterward, and provides an easy way to undo them. Requiring approval for every change could introduce enough friction that people simply decline, potentially missing out on useful improvements, while making changes without informing them could create confusion. Finding the right balance between autonomy and predictability would be important.

Not Everyone Wants the Same Experience

Of course, people benefit from consistency, and not everyone would necessarily be comfortable with software that changes frequently or creates entirely new experiences whenever a need arises.

I imagine that some people, particularly those who are more technically inclined or comfortable adapting to new tools, might embrace an environment where applications can be created almost instantly. Others may prefer to continue using familiar applications that gradually evolve based on their habits and preferences, allowing them to benefit from personalization without constantly having to learn something new.

Even the same person might prefer different approaches depending on what they're doing. Someone might appreciate having a new application created for a particular project while preferring that the software they use every day remains relatively consistent.

I don't necessarily see one approach replacing the other, and I suspect we'll see different companies experimenting with different degrees of adaptability. What interests me is the possibility that software becomes less rigid overall, with the experience increasingly shaped by the individual rather than by a set of decisions made for everyone.

The Importance of Knowing You

For AI to create software that meets someone's needs almost perfectly on the first attempt, it would need to understand that person remarkably well. Their preferences, habits, circumstances, and perhaps even how they've interacted with other software in the past could all influence what the ideal application looks like.

I think we'll eventually reach a point where that level of personalization is possible, but it would require a considerable amount of information about the individual. In the meantime, it seems more likely that software will begin with an imperfect understanding of its user and continuously refine itself through observation, experience, and feedback.

This introduces another challenge, which is privacy. The people most willing to share their personal information may benefit the most from highly personalized software, but there's an obvious question of trust when that information is collected and controlled by the companies providing the applications.

One possible solution I've been considering is a personal AI agent that operates locally, or perhaps a separate layer of personal data that individuals own and control. Rather than every application independently collecting information about you, an agent could maintain that understanding and make relevant information available to applications when needed.

That could also mean that personalization becomes portable. Instead of every new application having to learn your preferences from scratch, it could benefit from what your personal agent already knows about you, without necessarily having access to your entire history.

I can imagine some people interacting with their software primarily through such an agent, while others continue using distinct applications with the agent operating behind the scenes. As with the broader question of how software adapts, I suspect both approaches could coexist.

Of course, this would introduce its own technical and security challenges, particularly around deciding which applications can access what information. But it might offer a way to benefit from deeply personalized software without requiring us to surrender control of our personal data to every company whose products we use.

A Different Relationship With Software

Much of the discussion about AI replacing software focuses on what happens to the companies that make it, and whether people will continue paying for applications when they can create alternatives themselves. That's certainly an interesting question, but I'm more interested in what happens to the people using the software.

For decades, we've treated software as something we acquire, learn, and accommodate. Even as applications have become more capable, the basic relationship has remained largely the same. Someone designs a product, and the rest of us decide whether it meets our needs well enough to use it.

Perhaps the more interesting consequence of AI isn't that we'll be able to create an endless number of applications, but that we'll gradually stop thinking about software as something fixed.

I wonder what that would mean for the way we use computers, and perhaps more importantly, what we expect from them.