Seven months ago, I briefly wrote about code being cheap.

Since then, AI models have become A LOT better. Current SOTA models are astonishingly good at coding. They can implement complex features, debug systems autonomously (with the help of MCPs), write tests, and refactor entire codebases with surprisingly little supervision.

It has never been cheaper to build software.

And yet, the fundamental problem has not changed.

You can generate the most performant, bug-free code imaginable and still end up with an unusable product.

The bottleneck has moved

For a long time, implementation was one of the biggest constraints in product development. Even when you knew exactly what you wanted to build, turning the idea into working software required significant time and money.

AI removed this constraint completely.

The difficult questions now come earlier:

• What should we build?
• Who is it for?
• Does it solve a real problem?
• How should it behave?
• Should this feature exist at all?

These are product questions, not coding questions.

AI can help answer them, but it cannot remove the need for judgment. It can generate ten possible solutions in minutes. But someone still has to decide which idea is worth pursuing (and whether any of them are good enough).

The bottleneck is no longer building software.

It is developing taste (it’s a cliche for good reason).

Good UX requires taste

Design and user experience remain enormous bottlenecks in agentic software development.

An agent will happily produce a technically correct interface that is confusing, cluttered, and barely usable. You can improve the result with more prompting, but that only moves the responsibility back to the person writing the prompt.

To ask for a better experience, you first need to recognize what is wrong with the current one.

You need to notice that the visual hierarchy is off. Or that the user is being asked to make too many decisions. Or an interaction technically works but does not feel natural.

The more targeted your direction, the better the result. But targeted direction requires a deep understanding of a problem and a good vision of how to solve it.

That is taste.

AI can help you turn your taste into a product faster than ever before. It cannot develop that taste for you.

Cheap features create expensive products

When adding a feature took weeks, it forced teams to think carefully about whether it is really needed. The friction created a natural checkpoint: is this actually worth building?

That checkpoint is now gone.

Now, when you are on a roll with your coding agent(s), it is tempting to just build everything at once. One feature suggests another. The agent finishes both and proposes three more. Before long, a focused product has become an “everything” platform full of settings, modes, and half-developed ideas.

Each feature might be useful in isolation but together, they make the product worse.

More features create more decisions for users. More interactions that need to somehow work together. And more opportunities for the product’s original purpose to become unclear.

The implementation may be cheap. But users will pay the price (with a complex product).

Product development needs friction

This may be an unpopular opinion, but good product development needs some friction.

Not pointless bureaucracy or six meetings before changing the colour of a button. The useful kind of friction: the pause between having an idea and deciding that it deserves to become part of the product.

That pause creates room for questions.

Does this solve a recurring problem or a one-off request? Does it strengthen the core product or distract from it? Can we solve the problem by simplifying something that already exists? What will this feature cost users in attention?

When building becomes nearly effortless, these questions become the most important.

The ability to build any feature in no time does NOT mean you should.

AI should accelerate the loop, not eliminate it

Great software is built incrementally. Build one or two features. Put it in front of users. Watch what happens. Gather feedback. Improve the experience. Repeat.

AI can make every part of this loop faster. A change that once required a month might now take a week. A prototype that took a week might take an afternoon.

That is an extraordinary advantage.

But faster iteration is not the same as skipping iteration.

One-shotting an entire product, with every feature you can imagine included from day one, removes the opportunity to learn. You are no longer responding to users. You are asking them to validate a pile of assumptions you have already turned into software.

Even if the implementation is flawless, the product can still be wrong.

Build quickly. Learn quickly. With a strong emphasis on “learn”.

Restraint builds trust

Incremental development is not only a way to improve the product. It is also how you build trust.

Users see that feedback leads to thoughtful changes. They learn that new features will improve the product rather than make it noisier. They begin to trust that you will protect the experience they already value.

That trust is easy to lose.

When a product suddenly fills with AI-generated features, users can feel the lack of intention. They may not know how the software was built, but they notice when every interaction is competing for their attention.

Restraint communicates that someone is still making decisions.

Someone is still responsible for the product.

Good products are still expensive

AI made code cheap. It did not make good products cheap.

Good products still require research, judgment, design, iteration, and restraint. They require someone to care about the details and reject ideas that do not belong. They require a willingness to slow down long enough to understand what users actually need.

Using AI to build your product will not guarantee that it is worth using.

Without deliberate product thinking, AI will simply help you build the wrong thing faster.

In a world filled with cheap, AI-generated products, the ability to build excellent products will be the edge.

Code is cheap. Good products are (still) expensive.