Software Goes to Zero

Here's a thought experiment I've been running in my head. It starts with something I keep seeing and ends somewhere pretty uncomfortable.

The thing I keep seeing

Open your LinkedIn feed right now. Or X. Or Hacker News. You'll find, conservatively, a dozen posts that all read like this: "Check out this open source agent pipeline I built! Here are the features: tool use, RAG, memory, multi-step reasoning..." and every single one of them is building the same thing. Different README, same bones.

I'm not throwing stones. I'm one of these people. I've literally built my very own tailored pipeline. I've been trying to build things with AI that would take a team and months of work, and it's genuinely thrilling. But when I step back and look at what everyone else is building, the pattern is impossible to ignore. We're all building the same stuff. The tools made it easy enough that thousands of people independently converged on the same outputs.

That's not a bug in the system. That's the system telling you something.

The thought experiment

Take what's happening now and follow it forward. Not to next year, but to the logical conclusion.

AI gets more capable. That's not a prediction, it's a trajectory. Same kind of trajectory the likes of which Ray Kurzweil has been saying for decades at this point. The models get better at writing code, understanding systems, reverse-engineering existing software. At some point a sufficiently capable AI can look at any piece of software and reproduce it. Not approximately. Functionally. Maybe even improved. I'm talking years here, not decades.

When that happens, what is software worth?

If I can point an AI at your SaaS product and say "build me this, but with these three changes," and it just... does it — then your software isn't a product anymore. It's a suggestion. A reference implementation that anyone can regenerate on demand. You didn't build a moat. You built a blueprint that the machine can read.

This isn't about AI "taking developer jobs." That framing is too small. This is about code itself losing its status as something that holds value. Software stops being a product and becomes a behavior. Something that just happens, on demand, like generating a paragraph of text. You don't sell paragraphs of text. You don't sell software either. Not when anyone can conjure it up by asking.

A thousand copies of everything

Here's where it gets weird. If software is trivially reproducible, you don't get one winner per category. You get a thousand copies of everything, each slightly tailored to whoever requested it. A thousand project management tools. A thousand CRMs. A thousand analytics dashboards. Each one built in minutes, scoped to exactly what that particular person or company wanted.

That sounds like abundance. It is abundance. But abundance of something is just another way of saying that the thing has no economic value. Water is abundant and essential and you still can't build a business selling it out of a river. The value moved to the pipes and the filtration and the delivery infrastructure a long time ago.

Software is becoming water.

The collapse downward

So if the software layer is worthless, where does value live?

Follow the stack down. The app layer goes to zero — we've established that. The platform layer is interesting for a minute, because platforms control distribution. But platforms are also software, which means they're also reproducible. The only thing keeping a platform alive is network effects and switching costs, and those get weaker when spinning up an alternative is trivial.

Keep going down. What's actually scarce? What can't be conjured out of thin air by a model?

The physical stuff. The chips that run the models. The energy that powers the data centers. The infrastructure that makes all of this generated software possible in the first place. That's where you hit bedrock.

We started this era with "software is eating the world." The punchline might be: software ate the world, then ate itself, and what's left is silicon and electricity.

The uncomfortable middle

Again, this is a thought experiment and not a prophecy. There are pieces I'm not sure about.

Distribution might survive as a value layer even if the underlying software doesn't. Getting the right thing in front of the right person at the right time has always been valuable, and "the ability to generate anything" doesn't solve the problem of knowing what to generate. Curation might matter more than creation.

There's also the question of taste and judgment. I've written previously about agency being the skill that matters in an AI world, and about designing tight, scoped micro businesses around that judgment. If software is free, does that make human judgment more valuable because it's the only scarce input left? Or does it make it irrelevant because the whole system is now just compute?

I don't know. But I think the honest answer is that judgment matters until the models have it too. And if you believe capability keeps climbing, that's a temporary advantage, not a permanent one.

What's left

Maybe I'm supposed to offer a hopeful reframe. I don't really have one that feels honest.

The people who see this clearly have a window. The value of software is declining on a curve now, but that curve could become a cliff. There's still time where the combination of human judgment and AI execution creates something worthwhile. The micro business pattern I've been thinking about still works (for now) precisely because most people haven't internalized that the execution layer is approaching zero.

But the window has a shape. And the further out you look, the narrower it gets. What's on the other side is a world where the real businesses are the ones closest to the physical layer — the compute providers, the chip makers, the energy companies — and everything above them is a thin, disposable, infinitely replaceable film.

Software goes to zero. The value goes to the ground. I don't know what you do with a thought experiment like this, but it's hard not to think about.