Nowadays, everyone believes they are capable of delivering production software. This is the actual disruption - it's not about the code, it's about the confidence people have.
Pieter Levels made a post on X that went viral. In it, he mentioned how AI was turning software into a commodity, and shared that he’d been canceling a bunch of SaaS subscriptions and instead building small custom solutions for himself using AI. The reactions to that post were like lightning. Indie hackers the world over suddenly started muttering: wait, why exactly am I paying for that? I could just build it myself.
It's a fair question. It's also a dangerous one.
The demo is the easy part
AI has made it stupidly easy to get something working. You can go from idea to functional prototype in an afternoon. That's genuinely incredible.
The thing is, a "functional prototype" and something you can actually put into production is a different story altogether. And AI just handed everyone a running start toward the edge of that canyon.
What Figma actually is
Consider Figma for a moment. It is more than just "a design tool." It encompasses many years of addressing edge cases for live collaboration over unstable networks. It's conflict resolution when two people edit the same frame. It's accessibility compliance, enterprise SSO, version history that actually works, and a plugin ecosystem with thousands of integrations.
You can build a design tool demo in a weekend. You cannot build Figma. The gap between those two things is measured in years and hundreds of engineers.
Salesforce is in the same boat. Everyone loathes it. Everyone believes they can build something to replace it. Nobody who's tried has come away thinking it was simple. The product isn't the UI — it's the decade of workflow edge cases baked into every dropdown menu.
Where AI-generated code actually breaks
Here's the pattern I keep seeing. AI-generated code works great in isolation. One API, one database, one happy path. 🎉
Afterward, you establish a connection with a second system. Subsequently, a third one. Soon after, you have to manage retrying, partial crashes, expiry of auth tokens, rate limitations, and ensuring data consistency among services, as well as dealing with the vendor's API that, for some unknown cause, returns XML solely on Tuesdays.
AI-generated code may still not work for such complex multi-system integrations. Not because the models are bad -- they are scarily good at isolated problems. But real-world software is not an isolated problem. It is a thousand isolated problems duct taped together with error handling and prayers.
Confidence is the actual product now
Here's my interpretation of what really transpired. AI did not actually make it easier to build software. It just gave the impression that software development was becoming easier.
It's essential. Very important.
When a compelling demo can be created at no cost, it becomes challenging for people to appreciate the efforts put in after the demo. The unglamorous work. The monitoring. The migrations. The "a customer in Japan found a bug that only happens with double-byte characters in the billing address" type work.
The gap between a demo and an actual product has always existed. AI just made it invisible to anyone who hasn't crossed it before. 😅
So what do we actually do with this?
I'm not trying to imply that AI tools are negative. As a matter of fact, I rely on them all the time. They've changed how I work in ways I genuinely love.
However, I've observed a change in the narrative. People are associating "I built a working thing" with "I built a product." They are not identical statements.
The skill that matters most right now isn't prompting or vibe-coding. It's knowing what you don't know — recognizing when your working demo is 5% of the actual problem.
→ The demo proves the concept.
→ The product proves you understand the edge cases.
→ The business proves you can maintain it at 3 AM when something breaks.
AI made the first step a commodity but the other two are still as costly as ever.
What's the widest gap you've seen between a demo and the actual production version? I'd love to hear war stories.
Top comments (2)
Really strong framing — I like the shift in perspective here. The most important takeaway for me is that AI didn’t actually change the difficulty of building software, it changed the perception of certainty while building it.
The “commoditized confidence” idea shows up a lot in real systems work:
people feel more confident shipping AI-generated code than they should
decisions get made faster, but with weaker understanding of failure modes
review and validation become the real bottleneck, not generation
In practice, this is where I think the real split emerges: not between “AI vs humans”, but between confidence and correctness under uncertainty.
The interesting engineering skill moving forward isn’t just writing or even reviewing code — it’s knowing when confidence is misleading, and where the system still needs slow, deliberate validation (tests, observability, architecture constraints).
Feels like we’re entering a phase where the hardest skill is no longer producing solutions, but calibrating belief in those solutions before they hit production.
Curious if you think “trust engineering” will eventually become its own explicit discipline inside software teams, similar to how DevOps emerged from infra + ops.
The framing lands. One push, because I think the gap is sharper than "edge cases".
The Japanese double-byte bug isn't in your codebase because the problem was complex. It is there because someone was on the on-call shift the night the billing portal crashed in Tokyo and patched it at 3am. The XML-on-Tuesdays workaround exists because some engineer in 2022 burned an afternoon discovering the vendor's batch job runs on a different schedule midweek.
That knowledge isn't complex. It is contingent. It was cheap to capture the moment it cost you, and impossible to reconstruct from outputs after the person leaves. AI produces competent generic code because pretraining captures the average. It cannot produce your decade of edge-case patches because nobody published them. They exist as scars on the people who survived them.
So "commoditized confidence" reads almost exactly right. The demo is free because generic engineering is in the weights. The product is expensive because it carries write-time-bound information nobody else has. AI did not narrow that gap. It made it invisible to people who have not crossed it.
Two pieces on dev.to today landed on the same boundary from different sides: Marco Somma on memory architecture, shyamala_u on prompt engineering. Yours is the third angle, from the product-vs-demo side. Same cut.
War story on request.