Overview
Exploring ideas for a feature means moving between different kinds of workflows. You compare directions, try interactions, refine the design, and document what the team should build. Keeping those activities connected helps collaborators understand both the experience and the decisions behind it.
In this workflow lab, we’ll bring that process onto the Figma canvas. You’ll explore three feature variations, turn a design into a code layer, refine it through a loop between code and editable design frames, and create a Spec to capture the context for handoff.
When to use this: Use this workflow when you’re exploring a new feature idea or improving an existing experience and want to share the visual design, interactive prototype, and written requirements together.
Key concepts
Code layers
A code layer is an interactive prototype backed by running code on the Figma Design canvas. In this workflow, you’ll use code layers to try out your feature’s interactions and refine how the experience behaves.
Extract designs
Extract designs brings an interface from a code layer onto the canvas as editable design layers. In this workflow, you’ll extract designs to refine visual details, then push those changes back to the code layer.
Specs
Figma Specs is a container for your context, such as technical specifications or component usage guidelines, that lives on the canvas and gives your team and agents a place to work with written context alongside designs and diagrams. In this workflow, you’ll use a Spec to document the feature’s intended behavior, explain decisions, and capture questions that still need answers.
Before you begin
Who can use this feature
Figma agent is available for Professional, Education (not K-12), Organization, and Enterprise plans
Using the Figma agent requires a Full seat
Start with a feature idea or an existing design and a clear description of the problem you’re solving. Have relevant requirements, design system components, and constraints available to reference as you work.
Explore a feature and prepare it for handoff
Step 1: Explore three variations
Before committing to a direction, give your team or the agent a few approaches to compare. Start by describing the user’s goal, the problem with the current experience, and any constraints.
For example:
Explore three approaches to [feature] that help users [goal]. Use our existing design system. Make each approach meaningfully different and explain its main tradeoff.
Look for differences in how the feature works: where someone encounters it, how much information they see, or how many steps they need to complete a task.
Review the variations together. Identify what each approach helps you learn, then choose a direction to develop further.
Step 2: Turn the design into a code layer
Once you have a direction, turn it into something you can interact with.
Select your design frame, choose Code in the toolbar, and click Build selection in the right sidebar. You can also select multiple frames and ask the agent to turn them into code layers.
Include context about the behavior you want to test. For example:
Turn these designs into an interactive code layer. Include [primary interaction], [success state], and [error state]. Use our design system components where available.
Try the main task in the code layer. Pay attention to questions that were difficult to answer in static frames. Does the sequence make sense? Is the next action clear? What happens when someone changes their mind and wants to reverse or undo an action?
Use those observations to guide the next round of refinement.
Starting from a live page? You can also use the Figma Chrome extension to capture code from your webpage and paste it onto the canvas as a code layer. This gives you another entry point when you’re improving an existing experience.
Step 3: Refine the experience in the code editor
Continue working through the interaction before returning to the visual details. Open the code editor to work with the code layer in a larger editing workspace.
Keep requests specific. For example:
When someone completes [action], show [result]. Preserve their previous selections when they return to the earlier step.
After each change, try the affected part of the flow again. Check whether the update solves the problem and whether the surrounding behavior still works as expected.
Step 4: Extract designs and refine on the canvas
When you’re ready to work through visual details, extract the relevant interface as editable designs. You can capture the current state, select an element, or record a flow across multiple frames.
Review the extracted designs with your team. Look at hierarchy, spacing, content, and component choices. Check the frames against your design system and replace mismatched elements with the appropriate components.
Where your team uses Code Connect, check the relevant component mappings before asking the agent to update the code.
Once the frames are refined, use them as the reference for the next update:
Update this code layer to match the refined frames. Apply the changes to [specific elements] and preserve [existing interactions]. Flag anything that needs clarification.
Play through the updated code layer to check the result. Repeat this step as needed, using the canvas to refine the design and the running prototype to evaluate the behavior.
Step 5: Create a Spec from the code layer
Once the direction is ready to share, capture what the team needs to know to build it.
Ask the agent to create a Spec using the code layer and refined frames as context. Figma Specs supports using designs and code to draft technical specifications.
For example:
Create a Spec for this feature using the code layer and these design frames. Include the user problem, primary flow, key states, and expected behavior. Separate what the prototype demonstrates from requirements that still need confirmation. List open questions.
Review the draft carefully. Add the reasoning behind decisions, requirements that aren’t visible in the interface, and any constraints the prototype doesn’t capture.
Check that the Spec describes the version you intend to hand off.
Step 6: Bring the handoff materials together
Organize the final design frames, code layer, and Spec together. Label the selected direction so collaborators know which version to use.
Each artifact answers a different question:
| Artifact | What it communicates |
|---|---|
| Design frames | What the interface should look like across key states |
| Code layer | How the proposed experience behaves |
| Spec | What to build, why, and what still needs clarification |
Before sharing, check that all three agree. If an interaction is exploratory or a requirement remains unresolved, make that clear in the Spec.
Recap
In this workflow, you:
- Explored three feature variations before choosing a direction.
- Turned a design into a code layer to evaluate the interaction.
- Refined the behavior in the code editor.
- Extracted designs, edited them on the canvas, and pushed updates back.
- Created a Spec using the code layer and designs as context.
- Brought the design frames, code layer, and Spec together for handoff.