Memorisely
AI Product Design

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.

A working prototype moves the conversation from taste to behaviour.

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:

  1. Context. What the product is, who the screen is for and what job it does.
  2. Constraints. The components, tokens and patterns the agent must use, and anything it must not do.
  3. The first step. One small, concrete thing to build, such as the layout of a settings page without any interactivity yet.
Context, constraints and one small first step keep the agent pointed at your intent.

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.

Figma becomes the sketchbook and the browser becomes the place decisions get made.

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.

Sharing a link instead of a file invites people to use the thing, not just look at 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.

Keep reading

View all
View all

Optimize your AI for better experiences, not AI slop.

View all

AI Prototyping Skills

Prototype with AI using clean UI patterns and guardrails so flows feel product-grade, not generic template slop.

$99

AI UI Motion Skills

Motion and micro-interaction patterns that make AI-built UI feel designed, polished, and trustworthy in real products.

$99

Fix AI Slop Skills

Spot AI slop early and fix type, spacing, and components so your product looks intentional, not like a template.

$99

AI Responsive Design Skills

Responsive layout patterns for rails, sidebars, and breakpoints so AI-generated UI adapts cleanly from narrow to wide.

$99

AI Dark Mode Skills

Dark theme tokens, contrast, and surfaces that keep AI-generated UI readable and product-grade, not flat gray on black.

$99

AI Color Token Skills

Neutral and primary ramps with clear steps so AI palettes stay systematic, not a random set of accent hex codes.

$99
View all