Black flowchart of question boxes and yes or no arrows running across white gallery walls and floor
Black flowchart of question boxes and yes or no arrows running across white gallery walls and floor

•

8 mins read time

Figma Prototype to Code: Code Layers Now Read Your Prototype Connections

Since 3 November 2026 the Figma agent reads the prototype connections between your frames when it builds a code layer. Here is a practical workflow for turning a wired flow into a working prototype, where it falls short, and what it means for designers.

Ayoub Kada

•

8 mins read time

Figma Prototype to Code: Code Layers Now Read Your Prototype Connections

Since 3 November 2026 the Figma agent reads the prototype connections between your frames when it builds a code layer. Here is a practical workflow for turning a wired flow into a working prototype, where it falls short, and what it means for designers.

Ayoub Kada

The agent can only build the paths you drew. Wire the error state, or it does not exist.

Figma prototype to code: the short answer

Going from a Figma prototype to code got shorter on 3 November 2026. When you turn design frames into a code layer, the Figma agent now reads the prototype connections and interactions between those frames, according to the Figma release notes. Your noodles, triggers and transitions become part of the brief. You no longer have to describe the whole flow again in a prompt.

So how do you use it as a designer? Wire the flow properly first, select the connected frames, click Build selection, then spend your prompts on the hard parts: edge cases, empty states, error paths and real data. Figma's own framing is that you spend less time prompting the complex parts of your flow and more time refining it. That is the right expectation. The agent gets a better map. It still needs a designer to judge what it builds.

What Figma actually shipped

This section only repeats what Figma's own pages state.

Prototype connections as context. Since 3 November 2026, creating a code layer from design frames passes the prototype connections and interactions between them to the agent. Code layers themselves are still in open beta.

How you build one. The Figma help center article on code layers gives three steps: select a frame, choose Code in the toolbar (or press B), then click Build selection in the right sidebar. You can also select several frames at once and prompt the agent to turn them into code layers together. That multi-frame route is where the new connection context matters most.

Who can use it. The help center lists Starter, Professional, Education (not K-12), Organization and Enterprise plans, and you need edit access to the file. Code layers use AI credits during the open beta, and usage varies with task complexity. Only Enterprise plans can opt out, by turning off AI features.

Shaders came along a day earlier. On 2 November 2026 Figma said shaders can be included when you build with code, and they render in Play mode in Chrome only. The help center adds that this does not work in the Figma desktop app or other Chromium browsers, and it needs the chrome://flags/#canvas-draw-element flag turned on.

GitHub cloning by default. Also on 3 November, new GitHub repository connections clone into Figma by default, with admins able to switch it off per repository. That matters once your code layer needs to grow into something a developer will pick up.

If you are new to code layers in general, start with the earlier guide to Figma code layers for designers, which covers the basics. This article is about one thing: getting a prototype flow into code without losing the logic you already designed.

Hype vs reality

The hype says your Figma prototype is now an app. It is not. A code layer is described by Figma as an interactive prototype backed by running code. It is a faster, more honest prototype, not a production build.

What does hold up is this: the connections you draw in prototype mode carry intent that used to get lost. "Tap this card, slide in the detail sheet, back returns to the list" is exactly the kind of instruction that took several prompts to get right. Now the agent has it before you type anything.

What does not hold up is the idea that wiring is enough. Figma prototypes are usually happy paths. They rarely show a failed payment, a slow network or a list with one item. The agent can only read the connections you drew. If you never drew the error path, it does not exist in the brief.

Verdict: worth using on every flow you plan to test with people, as long as you treat the result as a prototype and keep reviewing it.

Prompt-only vs connected frames vs a hand-built coded prototype

Criteria

Prompt-only code layer

Connected frames to code layer

Hand-built coded prototype

Where the flow logic comes from

Your written prompt

Prototype connections and interactions in Figma

A developer's interpretation of the spec

Effort to describe navigation

High, every step in words

Low, wiring you already did

Medium, handoff notes and meetings

Risk of the flow drifting from the design

High

Lower, the map is the prototype

Medium

Covers edge cases by default

No

No, only what you wired

Only if specified

Who can iterate

Designer with the agent

Designer with the agent

Developer

Best for

Quick single-screen experiments

Multi-screen flows you want to test

Production-bound work and complex state

Pick connected frames when the flow already exists as a Figma prototype and you want people to use it with real behaviour. Pick prompt-only when you are exploring a single screen or interaction from scratch. Pick a hand-built prototype when data, performance or security actually matter, which is where web app development services take over from the canvas.

The Map, Build, Stress framework

This is a practical way to run the new feature. It has three passes.

1. Map: wire the flow like the agent will read it

Clean up before you build. Name frames by what they are ("Checkout, shipping step", not "Frame 214"). Make sure every connection has the right trigger and the right destination. Use overlays for sheets and modals instead of whole-screen jumps, so the intent is clear. Delete dead connections from old explorations.

Then add the paths you usually skip. Draw one error frame and one empty state and wire them in, even if they are rough. The agent cannot infer branches you never connected.

2. Build: select the connected frames and build

Select the frames that make up the flow, choose Code, and build. Then press Play and walk the flow yourself before writing a single prompt. Check three things: does every tap go where your prototype said it should, do transitions feel like the ones you set, and is anything missing.

Only now start prompting, and spend those prompts on what wiring cannot describe: "the list should load from a short delay with a skeleton", "the form should block submit until the email is valid", "remember the selected tab when I come back". Use point and edit for visual fixes instead of describing padding in words. Duplicate the code layer before big changes so you can compare directions side by side.

3. Stress: break it before someone else does

Play the code layer on a phone through the Figma mobile app. Try long names, slow taps, the back gesture, the keyboard covering the button. Ask the agent to add realistic data in the shapes you expect in production. When something important looks better in the code layer than in your frames, use Extract designs and Record a flow to pull the screens back to the canvas, so the design file stays the source of truth.

If your flow uses a shader for a hero or loading state, test it in Chrome with the flag on, and decide early whether that effect is worth the extra constraint for the team that will build it.

Where this takes design work

Prototype wiring used to be a presentation tool. It now behaves more like a specification that software reads. Over the next one to three years, expect the gap between "prototype" and "spec" to keep shrinking: the clearer your flows, states and naming, the better any agent builds from them, whether in Figma, in a coding tool, or in a developer's editor through MCP.

That shifts the craft. Less of the job is drawing every state by hand. More of it is structuring flows so they are unambiguous, deciding which edge cases matter, and reviewing what a machine produced. It is the same direction covered in AI prototyping and in the rise of the design engineer role: designers who can test behaviour, not just pictures, carry more weight in product decisions.

The fear: do I need to code now?

No. The new feature asks for better prototyping, not programming. The skills it rewards are ones good product designers already have: clear flows, honest edge cases, careful naming, and the judgment to see when something feels wrong.

The real risk is different. Designers who keep handing over static screens with one happy path will find their work looks thin next to a teammate who hands over a working flow. Your next moves: wire one real flow end to end this week, include one error and one empty state, build it into a code layer, and test it on a phone. Reading the code editor's output now and then helps too, not to write code, but to understand what you are asking for.

FAQ

How do I turn a Figma prototype into code?

Select the connected frames of your prototype, choose Code in the toolbar (or press B), and click Build selection, or select several frames and prompt the Figma agent. Since 3 November 2026 the agent reads the prototype connections and interactions between those frames, so the navigation you wired becomes part of the build.

Does a Figma code layer replace a developer's build?

No. Figma describes a code layer as an interactive prototype backed by running code. It is good for testing behaviour and communicating intent. Production work still needs accessibility, testing, security and maintainable code from an engineering team.

Are Figma code layers free?

Code layers are in open beta and use AI credits, according to the Figma help center, with usage depending on the complexity of the task. They are available on Starter, Professional, Education, Organization and Enterprise plans for people with edit access.

Will AI prototyping replace UI designers?

Not the ones who design the flow. The agent builds from the connections, states and names a designer provides, and it cannot invent the edge cases nobody drew. What changes is the deliverable: a tested, working flow is becoming the expected standard, not a nice extra.

Is Figma's prototype-to-code feature overhyped?

Partly. It removes a real chore, re-describing navigation in prompts, but it does not make a prototype production-ready. Its value depends entirely on how well the prototype is wired and how carefully you test the result.

Getting help with flows that need to ship

A code layer is the fastest way to find out whether a flow works. Turning that flow into a product people trust is a different job. If you need help with product design services, web app design or the build that follows, DIGCY is a UI/UX agency in Casablanca working with clients globally, a Dribbble Selected Agency with 50+ projects delivered. Start from your prototype and book a product design consultation.

Let’s keep in touch.

Discover more about high-performance web design. Follow us on Twitter and Instagram.

Building an AI product?

By submitting, you agree to our Terms and Privacy Policy.

Let's Talk

Tell us about your AI product. After you send this, you can pick a 20-minute slot on our calendar. Prefer email? hello@digcy.com We reply within one business day.

Building an AI product?

By submitting, you agree to our Terms and Privacy Policy.

Let's Talk

Tell us about your AI product. After you send this, you can pick a 20-minute slot on our calendar. Prefer email? hello@digcy.com We reply within one business day.

Building an AI product?

By submitting, you agree to our Terms and Privacy Policy.

Let's Talk

Tell us about your AI product. After you send this, you can pick a 20-minute slot on our calendar. Prefer email? hello@digcy.com We reply within one business day.