I think vibe coding is misunderstood.
Most discussions focus on how quickly AI can build software.
The interesting part isn't the speed.
It's what happens to the design process when creating functional prototypes becomes almost effortless.
A few years ago, my workflow looked like this:
- Idea → Figma → Prototype → Stakeholder Feedback → Development
Today it often looks more like this:
- Idea → Functional Prototype → Stakeholder Feedback → Development
Sometimes I skip Figma entirely.
I open Cursor, start building the prototype, refine the design there, test interactions, gather feedback, and only then decide what should move forward.
The biggest change isn't that I can prototype faster.
It's that I prototype differently.
The problem with traditional prototypes
Figma is great.
I still use it.
But Figma prototypes are ultimately simulations.
The more complex the behavior becomes, the harder they are to create.
Things like:
- animations
- transitions
- microinteractions
- different states
- dynamic behaviors
- interactive logic
require increasing amounts of effort.
At some point, many teams stop prototyping these details altogether.
Not because they don't matter.
Because they are expensive to explore.
With vibe coding, the cost of exploring them drops dramatically.
You don't have to imagine how something feels.
You can experience it.
The moment that changed my mind
A small example.
I was working on a reward mechanic.
When a user claimed their reward, I wanted the experience to feel a bit more celebratory.
Traditionally, I probably wouldn't have bothered prototyping it.
The discussion would have been:
"What if we added some celebration animation here?"
And then it would remain a discussion.
With vibe coding, I just built it.
Now when the user clicks the button, confetti appears around it.
A tiny detail.
But I could immediately experience it, tweak it, and decide whether it improved the interaction.
The important thing isn't the confetti.
It's that experimentation became cheap.
Very cheap.
I care less about screens now
This was probably the biggest surprise.
When I designed primarily in Figma, I spent a lot of time thinking about:
- layouts
- spacing
- frames
- components
- variables
- visual polish
The screens were mostly static.
Naturally, I focused heavily on how they looked.
Today I care much more about:
- behavior
- interactions
- feedback
- psychology
- user flow
- momentum
- delight
In other words:
I care more about how the product feels than how it looks.
Because now I can actually experience those things during the design process.
I don't have to wait until development.
The blank canvas problem almost disappears
One thing I didn't expect was how much this helped with getting started.
Designers know the feeling.
You open a blank Figma file and wonder where to begin.
With vibe coding, I rarely start from a blank canvas anymore.
I can create something rough very quickly.
Then react to it.
Improve it.
Break it.
Rebuild it.
The process becomes less about creating something from nothing and more about refining something that already exists.
That shift alone has changed how I work.
Why founders should care
I think founders benefit even more than designers.
Not because they can suddenly build production software.
Because they can visualize ideas.
A founder can create a realistic version of a product, put it in front of people, and get feedback long before investing serious engineering effort.
The prototype becomes a thinking tool.
A communication tool.
A learning tool.
Not a final product.
And that distinction matters.
A lot.
The biggest mistake people make
I've seen many AI-generated MVPs.
Some look fantastic.
Modern UI.
Beautiful gradients.
Fancy interactions.
Lots of features.
And yet they're terrible products.
The user experience is confusing.
The workflows don't make sense.
The onboarding is broken.
The product solves the wrong problem.
But because the interface looks polished, people assume it's good.
This is probably the biggest trap in vibe coding.
AI is very good at creating something that looks convincing.
That doesn't mean it solves a problem.
That doesn't mean users understand it.
That doesn't mean people will use it.
A polished interface is not evidence of a good product.
It's just evidence of a polished interface.
Why I still don't treat these prototypes as production products
For me, vibe-coded prototypes exist to answer questions.
They help me:
- explore ideas
- test assumptions
- understand interactions
- communicate concepts
- gather feedback
What they don't do is automatically become production software.
Before something reaches production, I want real professionals to review it.
Developers.
Engineers.
People who understand maintainability, scalability, security, architecture, and everything else that a prototype doesn't need to worry about.
The goal is not to replace them.
The goal is to learn before asking them to build.
The skill that matters more than ever
The biggest lesson I've learned is that vibe coding doesn't replace product thinking.
It increases its importance.
When anyone can generate a decent interface in a few minutes, the bottleneck shifts.
The hard part is no longer creating screens.
The hard part is understanding:
- the problem
- the user
- the psychology
- the behavior
- the experience
That's where the value is.
Ironically, the more capable AI becomes at creating interfaces, the less I care about interfaces.
I spend less time moving pixels.
More time thinking about people.
And that's probably the biggest change vibe coding has brought to my design process.