Writing Code Was Never The Bottleneck

An alternative version of https://ordep.dev/posts/writing-code-was-never-the-bottleneck focusing on product making

For years, I’ve felt that writing lines of code was never the bottleneck in building a product as an indie developer.

The actual bottlenecks were, and still are, finding a problem worth solving, validating a market, product design, user experience, and the sheer human overhead of marketing and distribution. All of this is wrapped inside the lonely labyrinth of prioritizing features, finding customers, and staying motivated.

These processes, meant to build a successful product, often slow us down more than the act of writing code itself because they require customer insight, strategic thinking, and sound judgment.

Now, with LLMs making it easy to generate working code faster than ever, a new narrative has emerged: that writing code was the bottleneck for solo founders, and we’ve finally cracked it.

But that’s not quite right.

The marginal cost of building a new feature is approaching zero, especially with LLMs. But what is the price of discovering, designing, and delivering a product people actually want? Higher than ever.

LLMs shift the workload — they don’t remove it

Tools like Claude can speed up initial development. Still, the result is often more features flowing into a product and more pressure on the solo developer responsible for making sure the product is coherent, valuable, and marketable.

This becomes especially clear when:

• It’s unclear whether the feature being built solves a real user problem.
• The generated user interface is functional but not intuitive or appealing.
• The core value proposition gets lost in a sea of easy-to-build but unnecessary features.

We end up in a situation where products are easier to build but harder to sell, which doesn’t necessarily make indie developers more successful overall.

It’s not a new challenge. Developers have long joked about “building in a vacuum,” but the velocity and scale that LLMs enable have amplified those build-first-ask-later habits.

Understanding the user is still the hard part

“The biggest cost of a product is building the wrong thing — not how long it takes to code.”

LLMs reduce the time it takes to produce code, but they haven’t changed the amount of effort required to talk to users, identify their pain points, or ensure the product is a joy to use. That work can be even more challenging when the temptation is to retreat to the comfort of coding, where LLMs provide instant gratification, rather than face the uncertainty of customer interviews.

Indie success still relies on vision and validation

The indie developer journey has always been one of lonely conviction. It depends on a clear product vision, relentless customer validation, and ruthless prioritization. However, when features can be generated faster than ideas can be validated, indie developers risk falling into a mode where utility is assumed rather than ensured. That creates a bloated product that is hard to market and even harder to sell, slowing down the path to revenue in much more meaningful ways.

LLMs are powerful — but they don’t build a business

There’s real value in faster prototyping, building landing pages, and automating scripts. But LLMs don’t remove the need for deep customer empathy, careful product design, and effective marketing. If anything, those become even more important as the friction to simply build something disappears.

Yes, the cost of writing code has indeed dropped. But the cost of finding a market and building something people will actually pay for hasn’t.

That’s still the bottleneck. Let’s not pretend it isn’t.