Starting in April this year, I ran an experiment on our product development workflow.
The experiment
Most teams still build features the "old" way. The PM writes a PRD. A designer mocks it in Figma. Engineering reads both and translates them into code. Three roles, two handoffs, two translation gaps.
I wanted to collapse that with the new power of AI. So I changed the deliverable.
I required all PMs to ship two things: the PRD and a working interactive prototype, built with vibe coding — here we use Claude Code. Designers would move upstream and pair with the PM on that prototype, checking it against our design system at both the macro and micro levels. By the end of validation, Engineering would pick up the prototype and take it straight to production.
No Figma. No mockup-to-code translation. One artifact, validated early, built directly.
That was the plan.
What actually happened
The PMs adopted vibe coding faster than I expected. Describe the intent, watch the behavior, refine. It maps to how a PM already thinks. That part worked.
The designers struggled, mainly for two reasons.
First, it is hard for a designer to collaborate with a PM inside Claude Code while the prototype is being built. The PM is in flow, prompting and iterating. The designer is standing next to a moving train.
Second, it is hard to change one small thing in a large prototype through prompting. Change the radius of a button. Tighten the spacing on a card. These are one-second edits in a design tool. Through vibe coding, they are slow and imprecise.
Those two problems are actually one problem. PMs work in intent-space. Designers work in property-space. They think in exact values: this weight, this radius, this gap. Prompting is a great interface for intent. It is a terrible interface for precision.
So the designers felt less control and less engagement. Not because the idea was wrong. Because we forced two roles with different native tools into one tool that only serves one of them.
The fix: a hybrid, with one hard rule
I'm bringing Figma back, in a different way. The sequence now looks like this.
The PM and designer use the prototype to nail the core definition. What the feature does. How the flow behaves. The macro shape of the thing. The AI-native prototype is fast and good at exactly this — getting to a shared, running understanding of the product, early.
Once that core is validated, design moves into Figma. This is where designers get their craft back. Precise control, the design system, component discipline, the micro layer. They fine-tune against the design lab the way only a design tool lets you.
Figma gives us version control and a place to lock the design down. PMs get speed at the front. Designers get precision in the middle. Engineering still gets a fully specified artifact at the end.
That's the practical intermediate solution, and it's working.
The honest caveat
I'll be direct about the trade-off, because leaders adopting this should see it clearly.
The original goal was code as the single source of truth. When you move design into Figma and lock it there, Figma quietly becomes the source of truth again. Engineering can inherit a picture instead of running code. That is the exact gap we set out to close.
So I treat this hybrid as training wheels, not the destination. The rule that keeps it honest: the prototype defines the product, and code stays canonical wherever you can hold that line. Figma is for fine-tuning the design system layer, not for becoming the build artifact.
The real end state is a designer who collaborates with the PM directly on the live prototype — visual control over the property layer, on the same code the PM and Engineering use. One source of truth, two ways to touch it. The tools to do that are arriving. Until they're good enough for daily design work, the Figma hybrid is the pragmatic bridge.