The prototype now lives in the codebase

I keep wondering what the future of collaborative prototyping looks like — specifically, how a designer does iterations. For years my work had a very predictable rhythm. Me, a PM, and a couple of devs, all gathered around a Figma artboard. We'd stare at the prototype, click through the flows, and read each other's feedback pinned to the screen as little comment bubbles. “Can this button be higher? ” “What happens on error here?” “Love this, ship it.” That artboard was the meeting point — the one place where design, product, and engineering all looked at the same thing.

It worked. But there was always something quietly off about it, and it took me a while to name what.

The artboard was a picture of the product, not the product

A Figma prototype is a beautiful illusion. It looks and clicks like the real thing, but it isn't. It doesn't handle a slow network. It doesn't reflow when the copy gets long. It doesn't have the empty state, the loading state, or the “you have no permission” state unless I sat down and drew each one by hand. Every comment my colleagues left was a comment about a representation of the product — and the moment we agreed on it, the real work of translating that representation into code was still ahead of us.

So the feedback loop had a wall in the middle of it. We'd iterate on the artboard until everyone was happy, and then the design would cross over into engineering, where new questions surfaced that the static screen never could have answered. The artboard was always slightly ahead of reality and slightly behind it at the same time.

Now the iteration happens in the codebase

What's incredible is that the designer can now iterate directly from the codebase. Not a mockup of the screen — the screen. I make the change where the product actually lives, push it, and a few minutes later there's a Vercel deploy with a real URL. Not a prototype link that fakes the interaction. The actual thing, running, that anyone can open on their phone, resize, break, and poke at.

And then Vercel itself becomes the collaborative review surface. My teammates open the deploy, and instead of dropping comments on a frozen image, they leave feedback on the live product — on the real hover, the real transition, the real behavior when the text overflows. The comment and the thing it's about are finally the same object. When someone says “this feels slow,” they mean it actually felt slow, not that a prototype timing was set wrong.

Why this is more than a faster Figma

It would be easy to read this as “same process, better tools.” It isn't. A few things genuinely flipped:

The prototype and the product stopped being two things. There's no handoff, because there's nothing to hand off. The artifact I iterate on is the artifact that ships. The gap between “what we approved” and “what got built” — the gap that ate so much of every project — mostly disappears.
Feedback lands on reality. Every edge case that a static artboard let me quietly ignore is right there in the deploy. The long name, the failed request, the tiny screen. Reviewers react to the product as it truly behaves, so the conversation is honest in a way a canvas never forced it to be.
The loop is measured in minutes. See something, change the code, deploy, share the link, get feedback, repeat. The distance between an idea and a shareable, real version of that idea collapsed from “let me spec this for the devs” to “give me a few minutes.”

The prototype became alive

The prototype used to live on an artboard — static, admired, annotated, and ultimately separate from the product. Now it lives in the codebase. It's not a picture of the thing; it's the thing, one deploy away from everyone's hands. Collaborative review didn't go away — it moved onto the real surface, where a comment finally points at something true.

I don't think this erases the value of gathering around a screen and arguing about it. That's still the best part of the job. But the screen we argue about is no longer a drawing waiting to be built. It runs. And the designer, for maybe the first time, gets to iterate on the actual product instead of a careful promise of it.

Same instinct to shape and refine. The canvas just became the codebase.