Lately I've had this feeling that something fundamental has shifted in the way we design and build software.
Not in a hype-driven way. More in a quiet, slightly uncomfortable way. I can build things faster than ever. Features that used to take weeks now take days. Prototypes that once felt too big to justify now feel almost trivial to spin up.
And every time I bring this up, someone says some version of the same thing: engineering isn't the bottleneck anymore.
I want to push back on that... because I don't think engineering ever really was.
Yes, writing code is faster now. Dramatically faster! Tools like Claude Code and Codex have genuinely changed the cost of turning an idea into working software. That's real. But the problems that actually kill products, the wrong problem, the wrong user, no distribution, no clarity... those aren't new, and faster code generation doesn't fix them.
Think about the products that failed. Most of them weren't blocked on implementation. The engineering got done. The app shipped. The bottleneck was never the code; it was figuring out what should exist in the first place, who it was for, and whether anyone wanted it or could even find it.
That hasn't changed. If anything, it's been exposed.
When implementation was slower, the gap between idea and shipped product bought you time. Time to think. Time to reconsider. Complexity was accidental cover for unclear thinking. Now that cover is gone. You can build something that looks finished with a polished UI, clean architecture, all the right screens etc without ever seriously answering whether it's useful, usable, or wanted. Speed doesn't save you from that. It just gets you there faster.
And then there's the noise.
We're shipping into a world where every solo developer and two-person team can spin up a small product in a weekend. The volume of software being created is increasing faster than anyone's attention. Getting something built is cheaper than ever; getting it noticed is harder than ever. Distribution, positioning, cutting through the signal, those were always hard, and they're only getting harder as the supply of software keeps climbing.
So when people say the bottleneck has moved upstream to product thinking, to user understanding, to judgment, I'd say: yes, but that was always the hard part. We just had an excuse not to confront it directly.
What's actually changed is that the excuse is gone.
This is where I think small teams and solo developers have real leverage, but only if they're honest about it. If you can think clearly about the problem, the user, and the business at the same time, these tools are genuinely empowering. You don't need a big team to execute. But you do need clarity and clarity was always the scarce thing.
Engineering still matters. It always did. Someone still has to own the system, keep it coherent, and make sound architectural decisions. None of that got easier. But it was never the thing standing between a good idea and a successful product.
What's standing there now is the same thing that was always standing there. The questions just got harder to avoid.