AI Made Software Cheap. Now Finding Something Worth Building Is the Hard Part.

I was at a hackathon recently, staring at a blank screen.

Not because I didn't know how to build something.

That part was almost trivial.

We had AI coding tools, APIs, frameworks, databases, deployment platforms, and enough caffeine to make several questionable architectural decisions. If we had an idea, we could probably turn it into a working prototype before the weekend was over.

The problem was that we didn't have an idea we believed was worth building.

And the more I thought about it, the more interesting that felt.

Because AI was supposed to make building products easier.

It did.

It also made finding a product worth building much harder.

We used to have an execution problem

For a long time, software had an obvious bottleneck.

You had an idea, and then reality arrived.

Someone had to write the backend.

Someone had to build the frontend.

Someone had to figure out authentication.

Someone had to integrate the APIs.

Someone had to deploy the thing.

Someone had to spend three hours figuring out why the database connection worked locally but not in production.

That friction was annoying, but it was also useful.

It forced ideas through a filter.

If an idea wasn't strong enough to survive weeks of engineering effort, you probably weren't going to build it.

Now that filter is disappearing.

Give a reasonably technical person an AI coding agent and a weekend, and they can build an alarming amount of software.

The cost of going from:

"I have an idea"

to

"Here is a working prototype"

has collapsed.

And when something becomes cheap to produce, something else becomes scarce.

In this case, it's not code.

It's good problems.

We are creating products faster than people can find reasons to use them

This is the part that feels strange.

The amount of software being produced is exploding.

But human attention isn't.

There are only so many problems people care enough about to change their behavior for.

Only so many tools someone is willing to add to their workflow.

Only so many subscriptions someone is willing to pay for.

Only so many browser tabs someone can keep open before the browser itself starts judging them.

So we end up with a weird imbalance.

The supply of software is increasing dramatically.

The supply of meaningful problems is not.

And that changes the economics of building.

When software was expensive to produce, the question was:

"Can we build this?"

Increasingly, the question is:

"Why should anyone use this?"

Those sound similar.

They aren't.

AI can make a bad idea look like a good one

This is where things get particularly dangerous.

Before AI, a bad product idea had a natural enemy:

implementation.

You'd start building it and discover that everything was harder than expected.

The API didn't exist.

The data wasn't available.

The workflow had twelve annoying edge cases.

The UI needed far more work than you expected.

Eventually you'd realize:

"Wait. Nobody actually needs this."

And you'd move on.

AI changes that.

Now you can take a mediocre idea and make it look incredibly convincing.

Give an AI agent a description and a few hours.

You can get a landing page.

You can get a dashboard.

You can get authentication.

You can get a database.

You can get API integrations.

You can get documentation.

You can even get tests.

The thing can look like a startup before you've established that it deserves to exist.

That's a dangerous illusion.

Because a working product is evidence that you can build it.

It is not evidence that anyone wants it.

We've started confusing novelty with demand

Hackathons make this especially visible.

You see a new model, a new API, an agent framework, some ridiculous new piece of infrastructure, and immediately your brain starts doing this:

"What can I build with this?"

I've done it.

Most developers have.

It's fun.

It's also backwards.

Technology is a tool for solving a problem.

But when the technology itself becomes exciting enough, we start looking for problems that justify using it.

That's how you end up with products that are technically impressive but fundamentally unnecessary.

The demo gets applause.

The GitHub repository gets stars.

The project gets posted on LinkedIn.

And three weeks later, nobody opens it.

The problem wasn't execution.

The problem was that there was no pull from the other side.

The most valuable skill might become problem discovery

If AI keeps making execution cheaper, then the relative value of execution keeps falling.

That doesn't mean engineers become less valuable.

It means the valuable part of engineering changes.

Knowing how to build something will still matter.

But knowing what deserves to be built becomes much more important.

And that skill is surprisingly difficult to automate.

You can't just ask:

"Give me 50 good startup ideas."

You can.

You'll get 50 ideas.

You can ask for another 50.

You'll get those too.

But now you have 100 ideas instead of zero, and somehow you're not any closer to knowing what to build.

Because ideas are becoming abundant.

Judgment isn't.

So where do good ideas come from?

Probably not from sitting in front of ChatGPT asking for startup ideas.

They come from being annoyed.

Seriously.

Pay attention to the stupid things people do every day.

The spreadsheet someone updates manually.

The information someone copies from one dashboard into another.

The task everyone on a team hates but nobody has bothered automating.

The software people complain about every Monday but still use every Monday.

The five-step process that exists because ten years ago someone decided that was the easiest way to do it.

The developer who has a 200-line script sitting in their home directory because their company doesn't provide the tool they actually need.

These are interesting.

Not because they sound like billion-dollar startups.

They usually don't.

They are interesting because someone is already spending time, money, or frustration solving the problem.

That's a much stronger signal than novelty.

Don't ask "What can AI do?"

Ask "What are people already trying to do?"

This distinction matters.

The first question produces technology demos.

The second produces products.

Suppose someone spends two hours every week doing a repetitive task.

You don't need to convince them that your technology is cool.

They already have a reason to care.

Your job is to figure out whether you can make that task significantly better.

That is a much less glamorous starting point.

And probably a much better one.

Because you're not creating demand from scratch.

You're walking into an existing demand and trying to serve it better.

The bottleneck moved upstream

This is the part I didn't expect AI to change so dramatically.

AI didn't just make software development faster.

It moved the bottleneck.

We used to spend most of our time asking:

"How do we build this?"

Now we can increasingly ask:

"Should this exist?"

And I think that's going to change how products are built.

The first phase of the AI software boom was about generation.

Generate code.

Generate UI.

Generate tests.

Generate documentation.

Generate content.

Generate entire applications.

The next advantage might come from something much less flashy:

selection.

Which problem?

Which customer?

Which workflow?

Which feature?

Which idea is worth throwing away?

Which one deserves another month?

When everyone can generate ten products, the person who knows which nine to kill has an advantage.

Maybe the best builders will become better editors

I've started thinking about product development a little differently because of this.

The ability to create things is becoming incredibly cheap.

That means creation itself becomes less differentiating.

Editing becomes more important.

Not editing code.

Editing ideas.

Cutting the unnecessary feature.

Rejecting the attractive but useless direction.

Talking to five users before building the next feature.

Throwing away a prototype that took two days to make.

Saying "this is cool, but nobody needs it."

That last one might become one of the most valuable sentences in software.

Because AI will happily help you build almost anything.

It won't automatically tell you that you shouldn't.

The AI era might produce more software and fewer products

That's the paradox I'm increasingly interested in.

We could enter a world where building software becomes almost trivial, while building something people genuinely care about becomes even harder.

There could be millions of perfectly functional applications.

Most of them could be good.

Most of them could be powered by excellent models.

Most of them could have beautiful interfaces.

And most of them could still be irrelevant.

Because usefulness isn't produced by code alone.

It comes from understanding a problem deeply enough to know what should be built in the first place.

That is the part AI hasn't made cheap.

At the hackathon, we eventually found something to build.

But I left thinking less about the project and more about the question that came before it.

If AI can give every developer the ability to build almost anything, then the next competitive advantage isn't necessarily building faster.

It might be seeing something worth building before everyone else does.

And I'm starting to think that might be a much harder problem.