Anyone Can Build Now (Sort Of): Why Real Coding Still Matters

The Vibe Coding Reality Check

The barrier to entry for creating functional prototypes has essentially disappeared. Tools like Figma Make, V0, Replit, and Lovable mean that ideas can become tangible experiences in minutes, not months.

We've officially entered the "vibe coding" era -- where anyone can build quick, functional prototypes that capture the essence of what you're trying to build -- as long as you can articulate what's on your mind.

But here's where many get it wrong: vibe coding is a first step, not the finish line.

As a Product Manager working in AI, I cringe every time I see another "coding is dead" hot take on Twitter. It's like saying chefs are obsolete" because we now have microwaves. ☠️ Sure, anyone can now spin up a decent-looking prototype, but try running a restaurant that serves hundreds of customers every night. Duh.

The truth is, vibe coding alone does not produce production-ready software.

Vibe coding v.s. product-ready software (generated with Magic Hour)

The difference between a working demo and production software is kinda like the difference between a paper airplane and a Boeing 737 -- rather similar concept, yet wildly different engineering.

Real software engineering is about understanding what happens when everything goes wrong -- network failures, database crashes, memory leaks, security breaches -- and building systems that handle it gracefully.

The complexity isn't in making code run. Rather, it's in making code run fast, securely, reliably, and maintainably when real users start hammering it in ways you never anticipated.

The engineer who can debug why your app crashes when 1,000 users hit it simultaneously? They're not worried about AI taking their job. In fact, their expertise is all the more valuable when you fall into an inescapable cycle of "debugging hell."

This is why claims that "coding will become an irrelevant skill" completely miss the mark.

So if coding isn't dead, what has changed? The real revolution, in my mind, is in supercharging how we communicate ideas.

Show, Don't Tell: How PMs Need to Evolve

However, I see the biggest gains are in overcoming the communication inefficiencies that plague the PRD socialization process.

We all know the old saying about pictures being worth a thousand words. A corollary is that a working prototype is worth more than a thousand-word PRD.

Having made dozens of demos using Figma Make, I've fallen in love with building functional prototypes. Here are a few (non-exhaustive) benefits of prototyping -- from the perspective of a PM working in a globally distributed team.

• Eliminates translation gaps (literally): Instead of having my engineers (often non-native English speakers) painstakingly interpret written requirements, I can have them interact with the intended user behaviors directly

• Faster alignment: Stakeholders can grasp the concept visually rather than imagine it based on documentation

• Tighter, better feedback loops: It's easier to critique and improve something you can actually play around with

• Reduced specification overhead: Complex interactions that take lengthy paragraphs to describe & explain become instantly obvious in a prototype

The Evolution of my PM workflow

Let me give you an example from the legal industry

Imagine trying to explain a contract review workflow with conditional approval chains based on deal size, jurisdiction, and risk factors.

The PRD would be a nightmare:

If contract value exceeds $100K AND involves EU data processing, route to Privacy team first, THEN to Legal, UNLESS it's a renewal with no material changes, in which case check if the counterparty is on the pre-approved vendor list...

I bet your eyes are crossing already! @#$%^&

Now imagine spending 90 minutes building a working prototype.

My engineers in Japan can actually upload different contract types and watch them flow through the approval paths. The legal ops team can test their edge cases ("What happens when a contract is exactly $100K with partial EU involvement?"). The General Counsel can verify that high-risk contracts never bypass legal review without reading through pages of business logic.

What would typically be a dozen back-and-forth Slack threads, multiple alignment meetings, and inevitable "wait, that's not what I meant" fixes becomes a single focused conversation around something everyone can actually touch and feel.

The conversation shifts from "What should this feature do?" to "Is this the user experience you envisioned?" - a much more productive starting point.

A new communications paradigm

The Real Revolution

Here's what the "coding is dead" crowd doesn't understand: We're not witnessing the death of computer science programming - we're watching its renaissance.

When everyone can sketch ideas in code, the edge of those who can architect cathedrals becomes even clearer. When PMs can prototype their vision in hours, engineers can focus on the genuinely hard problems: scale, security, performance, and reliability. When stakeholders can touch and feel an idea before a single sprint begins, we waste less time building the wrong thing right.

The tools flooding the market are creating a new common language between dreamers and builders. They're turning the traditional waterfall of "idea → spec → confusion → rework" into a rapid dialogue where everyone speaks in working software.

So yes, lean into vibe coding. Build those prototypes. Ship those demos. But also recognize that you're standing at the entrance, not the exit. The ability to translate a prototype into production-ready software (i.e., to turn that paper airplane into a Boeing 737) will only become more valuable precisely because prototyping has become trivial.

When everyone can build a demo, the real differentiator is who can make it real.

And if you think AI is about to change that fundamental truth, well... I've got a paper airplane to sell you.