The New Economics of Building Software

In the previous articles, I explored how AI changes the way we build software — from guiding an orchestra instead of playing every instrument, to using it for documentation, tests, and scaffolding.

All of that leads to a bigger shift.

Not just in how we build software, but in what it costs to build it.

When Building Becomes Cheap

Building software has never just been about money.

It has always been about time, effort, and attention.

Writing code.
Designing systems.
Testing edge cases.
Documenting behavior.

All of these steps used to take significant effort.

AI doesn’t remove that effort entirely. But it reduces it enough that something important changes:

It becomes much cheaper to create working software.

Prototypes that used to take days can now take hours. Ideas that weren’t worth the investment before suddenly become viable.

And when something becomes cheaper to produce, we tend to produce more of it.

More Software, More Variety

We’re already seeing the effects.

More small tools
More experimental projects
More niche applications
More “good enough” solutions

We are entering the era of disposable software. Just as digital photography made 'taking a picture' free, AI makes 'writing an app' almost free.

We can now build 'doodle apps'—tools meant to solve a single problem for a single afternoon—without worrying about whether they'll be maintained for years. The economics of 'built to last' are being challenged by the speed of 'built for now'.

That’s not necessarily a bad thing.

It means more ideas get explored. More problems get solved. More people can build things.

But it also changes the landscape.

We’ve Seen This Before

Other industries have gone through similar transitions.

Music is a good example.

There was a time when music was tied to physical presence. You needed musicians, instruments, and a place to perform. Production was expensive, and distribution was limited.

Then came recording.
Then radio.
Then digital distribution.
Then streaming.

Today, music is everywhere. The cost of producing and distributing it has dropped dramatically.

That led to:

• More music than ever before
• A wider range of quality
• Easier access for creators
• More difficulty deciding what’s worth listening to

And something else happened.

Older, trusted music didn’t disappear. It got remastered, replayed, and rediscovered.

Software Might Be Heading the Same Way

If building software becomes cheap, we can expect patterns similar to what happened in music: more options, more experimentation, and a wider range of quality.

That leads to a question for existing software: when it becomes easier to build alternatives, what happens to the standards we used to rely on?

• Competition increases
• Pricing pressure increases
• Iteration cycles become shorter

Software that used to take months to build can now be approximated much faster.

Are We Opening the Door for “Sub-Standard” Software?

Lower cost means lower barriers.

That leads to:

• More tools that “work” but aren’t robust
• More edge cases left unhandled
• More software that doesn’t stand the test of time

Not because people don’t care about quality, but because the cost of trying something has dropped.

The risk isn’t that the software won’t work — it works, but no one really understands it.

AI can generate a UI that looks professional and a backend that passes initial tests. But if the developer hasn’t struggled through the implementation, subtle signs of decay can be missed.

We risk a generation of 'black box' applications: systems that run perfectly today but are poorly understood. Developers can become spectators to their own codebase, struggling to troubleshoot when things inevitably break.

We aren’t just lowering the barrier to entry; we’re lowering the barrier to technical debt.

Does Quality Become the Differentiator?

In this sea of fragile, AI-generated tools, a new kind of 'premium' emerges. When 'good enough' is everywhere, extraordinary becomes the only way to stand out.

When almost anyone can build something that works, the question shifts:

Not: Can you build it?

But: Can you build it well?

Reliability, maintainability, and long-term thinking start to matter more.

Software that continues to work — under load, over time, across edge cases — becomes more valuable.

Just as the digital music revolution didn’t kill 'The Band,' it forced them to rethink their business model—shifting from record sales to live performances and merchandise. Software could be hitting that same wall: when the 'record' (the feature) is cheap, the 'performance' (the reliability and execution) is where you make your stand.

The Real Scarcity: Attention

There’s another shift happening underneath all of this.

When production becomes cheap, something else becomes scarce: attention.

If there are thousands of tools solving similar problems:

• How do you choose one?
• How do you trust it?
• How do you even find it?

Abundance alone doesn’t guarantee discovery. In a world of infinite 'good enough,' the bottleneck isn't the capacity to build, but the capacity to be heard. That means attention itself becomes a bottleneck.

And here’s the catch: the tools that get noticed won’t always be the best. Often, they’ll be the ones with the resources to draw attention — through ads, platform amplification, or marketing muscle. Smaller, high-quality projects may remain invisible, buried under the noise. In effect, abundance could make visibility a commodity, rather than something earned through quality or trust.

This makes reputation, clarity, documentation, and consistency more important than ever. Not just building software, but being understood, trusted, and discoverable becomes part of the craft.

What This Means for Developers

For developers, this changes the focus.

Shipping something quickly becomes easier. That becomes the baseline.

The differentiators shift toward:

• Making systems understandable
• Building things that last
• Handling complexity well
• Knowing where shortcuts are acceptable — and where they are not

In other words, the craft doesn’t disappear. It just becomes more visible in different places.

And Then There’s the Question

All of this leads to a natural question.

If software becomes easier and cheaper to produce…

Are we willing to accept that it may also become more fragile?

In the next article, we’ll look at what that could mean in practice — and whether we’re entering an era where software breaks more often, and what that means for developers and users alike.

Let’s explore!