If Any Software Can Be Cloned, What Is the Future of SaaS?

Lately, I've been thinking about a trend gaining momentum in the developer community: software reverse engineering, fueled by projects such as REA on GitHub and by AI agents becoming increasingly capable of analyzing, reconstructing, and replicating existing applications.

What once required entire teams, months of development, and deep knowledge of a particular tool is becoming much more accessible. Not necessarily because the original source code is available, but because it is getting easier to observe how a system behaves, understand how it works, and build something that delivers a similar experience.

And that opens up an interesting discussion.

What happens when replication is no longer so difficult?

For a long time, much of a software product's value came from how difficult it was to build. Developing a competitive tool required technical knowledge, time, infrastructure, and money.

Now, with AI agents capable of analyzing repositories, exploring behavior, and helping reconstruct systems, that barrier is beginning to change.

This doesn't mean any software can be copied perfectly. Integrations, business rules, infrastructure, security, and years of engineering decisions are not so easy to replicate.

But perhaps the most important question is this: what if a software product's competitive advantage no longer lies only in what it does?

If a feature can be rebuilt in days or weeks, how long will it remain a competitive differentiator?

What does this mean for the SaaS model?

SaaS became established by delivering software over the internet, usually through a subscription. Instead of installing and maintaining an application, users pay for access to a service that another company continuously updates and operates.

This model still makes a lot of sense. Hosting, collaboration, synchronization, support, security, and maintenance are real problems that don't disappear just because we can write code faster.

But there's an interesting question for the coming years.

If a company pays a subscription mainly to access a set of features, and those features can be reproduced with less and less effort, will the price still make sense?

In some cases, building an in-house tool tailored to a company's exact workflow might be simpler than continuing to pay for generic software that includes dozens of unnecessary features.

In other cases, the complexity of maintaining that custom solution will continue to justify paying for a specialized service.

The likely outcome isn't the end of SaaS, but greater pressure on products that offer little beyond easily replaceable features.

What about software that runs directly on your machine?

There's another discussion here that I find even more interesting.

We're used to thinking of applications as finished products, built by a company and distributed to thousands of users. Users install them, use them, and expect the vendor to keep improving them.

But what if, instead of installing closed-source software or paying a subscription, we could rebuild parts of it to meet our specific needs?

Imagine a tool that costs hundreds of dollars a month. In some scenarios, a developer could create a local alternative that runs directly on their machine, without relying on a recurring subscription or an external service for its core features.

This won't work for every product. Applications that depend on large-scale infrastructure, shared data, or remote processing still face significant challenges. And there's a huge difference between building a functional alternative and maintaining a secure, reliable product over the years.

Still, this possibility changes how we think about software distribution.

Perhaps the future will combine centralized services with more personalized local applications. Maybe some tools will be distributed as adaptable code rather than rigid products.

Or perhaps companies will find new ways to add value and make subscriptions just as relevant as they are today.

In the end, who decides what comes next?

As much as developers and AI agents are expanding the possibilities for building and reconstructing software, there's a variable we don't fully control: the decisions made by large companies.

They define how their products are distributed, their licensing terms, the APIs they make available, and, in many cases, the limits on access to their features.

If the trend of rebuilding software based on its behavior continues to grow, these companies could respond in different ways: strengthening their services, changing their business models, restricting certain kinds of access, or making their products harder to replace.

We don't know which strategy will prevail. And it would be premature to claim that SaaS is living on borrowed time.

What's more likely is that the cost of building software will keep falling, while the value of maintaining a reliable, useful, and sustainable product remains much harder to reproduce.

For developers, this changes the question too. It may no longer be enough to think about how to build a feature. It will become increasingly important to understand why someone would keep using a solution even when they have the option to build an alternative.

What do you think the future looks like?

If AI is making software easier to reconstruct, what will truly differentiate one product from another?

Will the future belong to those who build the best software, those who distribute it most effectively, or those who control the infrastructure it depends on?

And, most importantly, what will happen to SaaS and to software we install and run directly on our own machines?

Perhaps it's still too early to answer. But I have a feeling that the decisions large companies make over the next few years will have an enormous influence on that answer.