Software Is Going to Zero

Something has changed in software, and I don't think we've fully absorbed it yet.

Over the past few months, we've watched individual developers build increasingly credible open-source alternatives to products that once required large teams and years of work.

First came recreations of Adobe-style creative tools.

Then Word. Excel. PowerPoint.

They're not equivalent to the originals. Some are alpha software. Some are missing major features. Nobody has rebuilt Microsoft Office over a weekend.

That's not the interesting part.

The interesting part is that we can even have this conversation.

A few years ago, the idea that one developer, assisted heavily by AI, could make meaningful progress toward recreating applications of that complexity would have sounded ridiculous.

Today it doesn't.

And that has consequences far beyond Microsoft or Adobe.

I think the cost of software itself is heading toward zero.

When I say software is going to zero, I don't mean software stops creating value. I mean the marginal cost of producing many kinds of software is collapsing.

For decades, software economics were fairly straightforward.

Writing software was expensive.

You needed developers, designers, QA, infrastructure, product management and a lot of time.

So the rational thing to do was build one product and sell the same product to as many people as possible.

That gave us the software industry we know today.

Microsoft Office.

Adobe Creative Cloud.

Salesforce.

HubSpot.

And thousands upon thousands of SaaS products built for increasingly specific industries.

The compromise was obvious.

The software wasn't built for you.

It was built for everyone who looked vaguely like you.

So companies changed their processes to fit the software.

A business would buy a CRM and then reorganize its sales process around the way the CRM worked.

A clinic would adapt its workflow around its practice-management software.

An insurance brokerage would figure out how to squeeze twenty years of institutional behaviour into whatever fields and screens its vendor had decided were appropriate.

We accepted that because the alternative was custom software.

And custom software was expensive.

That assumption is starting to break.

There's a tendency to describe AI coding tools as productivity tools.

That's true, but I think it's becoming an inadequate description.

They're beginning to change the economics of creating software.

A developer can now hand an agent an unfamiliar codebase and ask it to investigate how something works.

It can implement features.

Write tests.

Trace bugs.

Study file formats.

Build interfaces.

Refactor large sections of code.

Translate an application into multiple languages.

Not perfectly. Not autonomously. And certainly not without someone competent making decisions along the way.

But fast enough that the amount of human effort required to produce software is falling dramatically.

More importantly, the work compounds.

You solve authentication once.

Payments once.

Localization once.

Deployment once.

Your design patterns improve.

Your testing improves.

Your instructions to the agents improve.

Your infrastructure improves.

Your next application starts several steps ahead of the previous one.

Eventually, you aren't just building software.

You're improving your ability to produce software.

That distinction matters.

Most people look at this trend and conclude that software will get cheaper.

I think it goes further.

Generic software starts becoming less attractive.

Consider a small business using a piece of vertical SaaS.

Maybe it costs $100 per employee every month.

It has fifty features.

The business uses twelve of them.

Three important things are missing.

Two workflows are backwards.

Employees maintain a spreadsheet beside it because the software doesn't quite match reality.

There's an integration they desperately want, but it has been sitting on the vendor's feature-request board for three years.

Until recently, that was normal.

What else were they going to do?

Spend hundreds of thousands of dollars building their own system?

But now imagine that the economics change.

Instead of buying software designed to work reasonably well for 10,000 companies, you build software designed around one company.

Its terminology.

Its employees.

Its customers.

Its approvals.

Its documents.

Its accounting system.

Its strange exceptions.

Its actual workflow.

Historically, that was bespoke software with bespoke prices.

AI is pushing us toward something very different:

bespoke software with mass-production economics.

That's where this gets disruptive.

Push the idea a little further.

Today, when you need software, you search for an app.

You compare five products.

One has the feature you need but costs too much.

One looks terrible.

One stores your data somewhere you don't want it stored.

One is almost perfect except for that incredibly annoying thing it does every day.

Eventually, you choose the least-wrong product.

That's how we've used computers for decades.

But why should that remain the model?

Imagine an AI system that understands your work well enough that you can simply say:

"I need a small tool that does this."

And it builds it.

A week later:

"Add this."

It changes it.

Then:

"Connect this to our invoices and show me when these two numbers don't match."

Done.

The software doesn't have a roadmap because it doesn't need one.

It evolves around its user.

There might be millions of applications in this world that have only ten users.

There might be software created for a single person and never distributed at all.

That sounds inefficient by today's standards.

But only because we're still assuming software is expensive to manufacture.

Open source adds another dimension.

This isn't only about price.

It's about control.

Governments and businesses are increasingly paying attention to where their technology comes from, who controls it, where their data lives and what happens if a vendor relationship disappears.

The sanctions involving the International Criminal Court made that risk particularly visible.

Microsoft didn't create those sanctions. Governments did.

But the episode illustrated something important: if critical operations depend on technology controlled by companies operating under another jurisdiction, geopolitical decisions can become technical problems very quickly.

Europe has increasingly described this in terms of technological sovereignty.

Open source is attractive in that environment for a simple reason:

You can take it somewhere else.

You can inspect it.

Host it yourself.

Modify it.

Replace pieces of it.

Continue operating it even when the original supplier is no longer part of the equation.

The historic weakness of open source was often the last mile.

A product might do 80% of what an organization needed, while the remaining 20% made adoption impractical.

AI changes the economics of that last 20%.

You don't necessarily need to wait for an open-source project to become a perfect replacement anymore.

You can increasingly build the missing pieces.

That makes vendor independence substantially more realistic.

There is an important distinction here.

Code is becoming cheap. Systems are not.

It may become incredibly easy to build an invoicing screen.

That doesn't recreate Stripe.

You can generate an online store.

That doesn't recreate Shopify's ecosystem.

You can build a financial dashboard.

That doesn't give you Bloomberg's data.

You can reproduce the interface of a marketplace.

That doesn't give you its buyers and sellers.

The durable value in software increasingly sits outside the code itself, in the systems behind the app.

Data.

Distribution.

Networks.

Integrations.

Infrastructure.

Regulatory knowledge.

Trust.

Operational experience.

Customer relationships.

The difficult workflows nobody notices until they break.

Those are much harder to generate with a prompt.

So the companies I'd worry about aren't simply "software companies."

They're companies whose primary moat is that they already wrote the software.

That's becoming a weaker advantage every year.

There's an enormous category of business software that is fundamentally some combination of:

a database,

forms,

permissions,

dashboards,

business rules,

notifications,

and a handful of integrations.

There's nothing wrong with that. Some of those products are excellent.

But historically, a large part of their value came from one simple fact:

Building the alternative yourself would have been absurd.

That calculation is changing.

And when it changes far enough, customers will start asking:

Why am I paying forever for somebody else's approximation of how my business works?

Sometimes the answer will be compelling.

The product may have valuable data.

A powerful network.

Deep integrations.

Compliance certifications.

A mature ecosystem.

Exceptional operational reliability.

In those cases, paying makes perfect sense.

But when the answer is essentially:

"Because writing this much software used to be difficult."

That's going to become a problem.

Quite the opposite.

I think we're heading toward vastly more software.

Software for smaller groups.

Software for individual departments.

Software for temporary problems.

Software that exists for six months and gets replaced.

Software that continuously reshapes itself around the people using it.

Software that would never have been economically reasonable to create before.

The strange result may be that software becomes ubiquitous while the software itself becomes less valuable.

Software isn't going away.

We're probably going to create more of it than at any point in history.

The difference is that merely having written the code will no longer be particularly scarce.

The scarce things will be understanding the problem, knowing what should exist, owning something difficult to reproduce, and turning increasingly cheap technology into something genuinely useful.

That's a very different software industry.

And I think we're already entering it.