Coding Is Getting Cheaper. Thinking Never Will.

After 30 years in product and engineering, AI-assisted development is the most significant leap in software productivity I've seen. We're using these tools every day at Propel, and the acceleration is real. Features that used to take days take hours. Prototyping cycles that took weeks now happen in an afternoon. The cost of turning an idea into working software has dropped dramatically, and that's exciting.

The bottleneck was never writing code

However, everyone talks like the biggest constraint in software was the ability to produce code. But was it?

For over a decade, platforms like .NET, Spring Boot and the broader cloud-native ecosystem have abstracted away massive amounts of complexity. Enterprise teams could stand up services, integrate systems, and ship working software faster than ever. Low-code and no-code tools have existed for years. If removing code was the magic bullet, developer demand should have collapsed long ago.

It didn't. Because the real constraint was never syntax. It was thinking.

Problem framing. System boundaries. Data flow. Failure modes. Designing systems that survive contact with real users. These are the hard parts, and they remain stubbornly human. AI is making the mechanical side of coding dramatically faster — and that's a welcome change. The question is whether teams keep investing in the thinking now that the building feels effortless.

Constraints were a feature, not a bug

When implementation was expensive, teams were forced to think carefully. You debated trade-offs. You questioned whether a feature was worth maintaining. You killed mediocre ideas early because they carried real cost.

That pressure created discipline. The best products didn't win because they generated code faster. They won because they picked a narrow problem, executed well, and said no to a thousand tempting features.

AI doesn't remove the need for that discipline — but it does remove the forcing function. When the cost of shipping a feature drops close to zero, it's tempting to try five variations instead of picking the right one. The result, if you're not careful, is products bloated with half-baked ideas that become maintenance nightmares.

This is the risk I'd call "AI Slop" — bloated, generic features and experiences that technically work but nobody actually wanted. Not because AI is bad at writing code, but because nobody applied the product thinking to decide whether the code should exist in the first place.

More software, not less

There's an economic principle called the Jevons Paradox: when a resource becomes more efficient to produce, we don't use less of it. We use more.

Lower the cost of generating software, and you don't shrink the industry. You expand it. More internal tools. More experiments. More dashboards. More automation. More surface area. And that's largely a good thing — entire industries that once relied on spreadsheets and manual processes now have access to purpose-built software that would have been cost-prohibitive five years ago. We see this at Propel every day, organisations coming to us because they've outgrown their spreadsheets and need real software to operate at scale.

The opportunity is enormous. But more software also means more complexity, more maintenance, and a greater need for clear-headed decisions about what to build and what to leave alone.

The teams that win will be the ones that were already winning

The 2025 DORA Report captured something I keep seeing in practice: AI doesn't fix a team; it amplifies what's already there. Strong teams use AI to become even better. Struggling teams find that AI only highlights and intensifies their existing problems.

This makes intuitive sense. Give a well-structured product team AI tools and they'll move faster, prototype smarter, and validate ideas with less waste. They'll use the speed to iterate toward better outcomes, not just more output. Give a team with no clear product strategy the same tools and they'll ship more features nobody asked for — just quicker.

AI is a force multiplier. But a multiplier is only as good as what it's multiplying.

The real bottlenecks haven't changed

Even with code generation running 10x faster, you're still constrained by distribution, user attention, discovery, trust, and — let's be honest — bureaucracy. The app stores are full of millions of unused apps. Generating another thousand lines of code doesn't solve that. Speed of delivery was never the thing holding most products back.

So what actually matters now?

There will be more software. That much is certain. AI has permanently lowered the cost of building, and the Jevons Paradox guarantees we'll fill every gap we can find. That's exciting — it means more problems get solved, more workflows get automated, more organisations get the tools they need.

But more software doesn't mean better products. Good product management — the discipline of understanding what to build and, critically, what not to build — matters more than ever. Good design, the craft of shaping experiences people actually want, matters more than ever. Good engineering, the practice of building systems that are maintainable, secure, and fit for purpose, matters more than ever.

It's why at Propel, our roots in product management have become our sharpest edge. The ability to build is table stakes now. The ability to decide what's worth building — to hold the line on quality, to shape software around real user problems rather than letting AI fill every gap it can find — that's the differentiator. We've always believed the best software starts with the best product thinking, and AI has only made that conviction stronger.

The teams that thrive won't be the ones that generate the most code. They'll be the ones with the discipline to wield AI as a force multiplier while maintaining the product thinking that separates signal from slop.

Coding might be getting cheaper. Thinking never will.