Designing in code is the new Figma file
Why working prototypes are replacing static frames as the source of truth.

Zander Whitehurst
10 min read
For most of the last decade the Figma file was the artefact. It was where decisions lived, where feedback happened and where engineers went to find out what to build. That is changing fast.
I'll be honest, I was a Figma file purist for years. I had a component library I was genuinely proud of, naming conventions that would make a librarian weep with joy and a slightly unhealthy relationship with auto layout. Then one evening I built a settings page in code with Claude in about forty minutes, sent the link to my team and watched the Slack thread explode with people clicking things. Nobody had ever clicked my Figma files like that.
With Claude Code and Figma MCP, a designer can go from a rough idea to a working prototype in an afternoon. Not a clickable mock, a real interface running on real components. When that prototype exists, it quickly becomes the thing everyone points at.
This is not a small workflow tweak. It changes who holds the source of truth, how teams make decisions and what it means to be a strong product designer. Below is how we see the shift, why it is happening now and how to start working this way without feeling like you have to retrain as an engineer.
Why this is happening now
Designers have been told to "learn to code" for years, and most sensibly ignored it. The gap between a design and a working interface was too wide, and the time it took to cross it was time taken away from design itself.
Two things have changed. First, AI coding agents like Claude Code can now turn a clear description into working UI in minutes. Second, Figma MCP lets those agents read your design files directly, so they can use your real layout, tokens and components instead of guessing.
Together they collapse the distance between an idea and something that runs. The cost of building a prototype has dropped so far that it is often faster than making a polished static mockup. When something gets that cheap, workflows reorganise around it.
The prototype wins the room
Put a static frame next to a working prototype in a review and watch where the conversation goes. People click, resize the window, try the empty state, type into the form. The prototype answers questions the frame never could.
Static frames invite opinions about how things look. Prototypes invite feedback about how things work. That is a far more useful conversation, because most of the problems that sink a feature are behavioural: a confusing flow, a missing state, an interaction that feels slow or surprising.
That shift matters because it changes what "done" means for a designer. Handing over a file is no longer the finish line. Handing over something that behaves correctly is.
What changes for the team
When designers bring working prototypes, the relationship with engineering changes too. Instead of translating a picture into code, engineers start from something that already runs. They can focus on architecture, data and performance rather than rebuilding layouts from scratch.
PMs benefit just as much. A prototype can go in front of users the same day it is made, which means decisions get validated with evidence instead of argued about in meetings. The whole team moves from debating what something might be like to observing what it is actually like.
This does not remove the need for collaboration. It raises the quality of it. Conversations start further along and end with clearer decisions.
You do not need to become an engineer
The fear we hear most from designers is that this means learning to code from scratch. It does not. What it means is learning to direct an AI agent well:
- Be specific about intent. Describe the outcome, the constraints and the edge cases, not just the layout.
- Work in small loops. Ask for one change, review it, then ask for the next. Big prompts produce big messes.
- Keep your taste in charge. The agent is fast, not opinionated. Spacing, hierarchy and motion still come from you.
It helps to understand the basics of how a page is structured, what a component is and how props change behaviour. You can pick that up through doing the work. Every prototype you build teaches you a little more about the medium you are designing for. Our AI Product Design Bootcamp is built around exactly this way of working.
A simple prompting pattern
When you sit down to prototype, try structuring your first prompt in three parts:
- Context. What the product is, who the screen is for and what job it does.
- Constraints. The components, tokens and patterns the agent must use, and anything it must not do.
- The first step. One small, concrete thing to build, such as the layout of a settings page without any interactivity yet.
Once that first step looks right, keep layering. Add the interactions, then the states, then the polish. Each step is small enough to review properly, and each review is a chance to steer the work back towards your intent.
Where Figma still fits
Figma is not going anywhere. It is still the best place to explore quickly, align on direction and build a shared visual language. The difference is that it becomes the sketchbook rather than the spec.
A healthy workflow looks like this: explore in Figma, pull the direction into code through MCP, refine in the browser, then push the polished components back into your design system.
Some work will always start and stay in Figma. Brand exploration, early concept work and big visual direction changes are faster on a canvas. The skill is knowing when to stay on the canvas and when to move into code, rather than treating either as the only place design happens.
Common mistakes to avoid
Designers new to this way of working tend to fall into the same traps:
- Prototyping too much at once. Building a whole product in one go leads to messy, hard to change code. Start with one screen.
- Ignoring the design system. If you let the agent invent styles, your prototype will look nothing like your product. Point it at real components.
- Skipping the states. Empty, loading and error states are where prototypes prove their value. Build them early.
- Treating the first output as final. The agent gives you a draft. Your job is to edit it until it meets your bar.
A quick confession: the first prototype I built this way was terrible. Spacing all over the place, a modal that refused to close and a button that turned purple for reasons I still do not understand. But it worked, people used it and the feedback was better than anything I had got from a polished frame. Ugly and real beats beautiful and static almost every time.
How to start this week
Pick one small, real piece of your product. A settings page, an onboarding step, a single card. Prototype it in code with Claude, using your existing components where you can. Share the link instead of the file in your next review and notice how the feedback changes. If you want a guided first go, our AI Prototyping in Claude Code workshop takes you through it.
Then do it again with something slightly bigger. After three or four of these, you will have a feel for where code makes you faster and where Figma still wins. That judgement is the real skill.
That single experiment will teach you more about where design is heading than any article, including this one.
Memorisely