For most of the history of SaaS, software itself was scarce.
Building a decent product required engineers, designers, infrastructure, time and money. Even relatively simple features could represent months of work. If you built something useful before everyone else, that head start mattered.
That is changing very quickly.
AI is making the production of software dramatically cheaper. A feature that once justified an entire startup can increasingly be recreated in days, sometimes hours.
It's tempting to conclude that software is becoming commoditized.
I don't think that's quite right.
Code is becoming commoditized. Products aren't necessarily becoming commoditized.
There's an important difference.
Being able to reproduce the visible functionality of a product is not the same as understanding its customers, fitting into their workflow, earning their trust, integrating with everything around it or knowing what to do when the obvious answer is wrong.
Those things may actually become more valuable as software becomes easier to create.
Features are losing their moat
For years, SaaS companies competed largely through features.
Product A had something Product B didn't. Product B spent six months catching up. Product A used those six months to build the next thing.
That loop is collapsing.
If competitors can reproduce your best new feature shortly after seeing it, then a roadmap becomes a much weaker defensive strategy.
This doesn't mean features stop mattering. It means features increasingly become ingredients rather than the product itself.
The interesting question becomes: what happens when every company can build almost anything?
One answer is consolidation.
Instead of paying for eight separate tools, why not use one product that does all eight things?
That's probably going to happen.
But I think "all-in-one" undersells what becomes possible.
The advantage isn't having everything. It's knowing everything.
Imagine a company using eight different SaaS tools.
Each has its own account system, database, permissions, integrations and partial understanding of the company.
Now imagine replacing those tools with eight small applications built internally using AI.
That might save money, but it also creates eight pieces of software you now have to operate and maintain.
The interesting third option is a single environment where those capabilities share context.
A system that already knows:
- what your company is trying to accomplish
- what your team is working on
- how your product works
- what your customers actually do
- what changed recently
- which decisions have already been made
- which actions require human approval
- which agents can be trusted to do what
Every additional capability added to that system becomes more valuable because it doesn't start from zero.
It inherits the context that already exists.
That is much harder to reproduce than a feature.
Context may be the new moat
People talk a lot about proprietary data as an AI advantage.
I think "data" is too narrow.
The valuable thing is context.
Context is why a team made a particular decision six months ago.
It's knowing that a metric going down is expected because the company intentionally changed who the product is for.
It's knowing that one customer workflow is unusually important even though it represents a small percentage of traffic.
It's understanding that an engineer rejected one implementation three times already, and why.
It's knowing that the signup flow technically works, but returning users suddenly behave differently after a release.
That last problem is part of what led me to build UXSense.
Traditional software tests can tell you whether the software behaves the way the code says it should.
They cannot necessarily tell you whether the people using it still behave the way you expected.
That distinction becomes especially important as more software is written by machines.
The faster we can produce software, the more important it becomes to understand the consequences of what we produce.
Software is becoming agent-first
There's another shift happening at the same time.
Most SaaS was designed around the assumption that a human would sit in front of the application and operate it.
Log in.
Navigate somewhere.
Click a button.
Fill out a form.
Repeat tomorrow.
Increasingly, that human may instead ask an agent to accomplish the task.
That changes what a product actually is.
The traditional SaaS bundle looked something like:
database + business logic + user interface
The emerging version may look more like:
context + capabilities + permissions + machine interface + human oversight
The graphical interface doesn't disappear.
Its job changes.
Humans become more involved where judgment is required: setting goals, resolving ambiguity, reviewing unusual outcomes, granting authority and making decisions.
Machines handle more of the repetitive execution.
That means some of the most important software of the next decade may not be software people spend eight hours a day clicking through.
It may be software they glance at for twenty minutes because it tells them exactly where their judgment is required.
The price of software may fall while the value of software rises
There's an obvious economic consequence to all of this.
If software becomes cheap to build, many software features will become cheap to buy.
I think that's inevitable.
But it doesn't necessarily follow that software companies become less valuable or that customers will spend less money on software.
We may simply stop pricing software primarily based on access to features.
A system that performs meaningful work for a company can be worth considerably more than a traditional SaaS subscription even if its underlying software was cheaper to produce.
If a product replaces ten hours of human work every week, the customer doesn't particularly care whether it took twenty engineers or one person and a fleet of agents to build it.
The economic value comes from the work being accomplished.
That suggests pricing increasingly moves toward things like usage, outcomes, volume and work performed rather than simply seats and feature tiers.
Small teams are going to become strange organizations
This is the part I find most interesting.
We're heading toward companies consisting of surprisingly few people overseeing surprisingly large amounts of productive capacity.
Maybe six people.
Maybe ten.
But those people could be directing dozens or hundreds of specialized agents working across engineering, research, support, analytics, operations and marketing.
Those companies are going to need a different kind of software.
Not simply more applications.
They'll need systems that know what the agents are doing, understand what changed, recognize when something looks wrong and bring the right decisions to the right human.
The core interface might be less like a traditional dashboard and more like an inbox for judgment.
Here are the five things the machines need from you today.
Everything else continues.
The next generation of SaaS may be less about apps
The first generation of SaaS moved software from the desktop to the browser.
The second connected those applications together through APIs.
I think the next step may be the gradual disappearance of the application as the fundamental unit of software.
Instead of buying dozens of isolated tools, companies may increasingly operate inside environments containing shared context, specialized capabilities and fleets of agents.
The individual feature becomes easy to reproduce.
The individual application becomes less important.
What matters is the system around them:
the accumulated context,
the trust model,
the workflows,
the permissions,
the history,
and the decisions.
Software isn't going away.
We're going to produce more of it than ever.
But the scarce thing may no longer be our ability to build software.
It may be our ability to make all that software understand what matters.