November 20, 2026Workflow lab: Turning context into a plan with Specs and the Figma agentJohnny DallasSoftware Engineer, Figma

Bringing scattered context onto the canvas helps teams connect the diagrams, designs, and technical decisions they need to build, all in one place. This workflow shows how Specs and the Figma agent provide a container for that context so implementation is easy.

Share Workflow lab: Turning context into a plan with Specs and the Figma agent

    Hero illustration by Marine Buffard

    Welcome to Workflow lab, where we present a sample workflow

    Workflow lab: Test ideas with code layers and the Figma agent

    Bringing code onto the canvas gives teams a shared space to compare working prototypes side by side, refine a direction, and collaborate on ideas with teammates. This workflow shows how a designer uses code layers and the Figma agent to explore a new feature.

    using Figma products and tools.

    When teams are going from prototype to production faster than ever, it’s easy for important context to get lost along the way. Written requirements, design details, and engineering guidance are critical to making sure teams are sprinting toward the right outcomes, but these inputs often end up scattered across separate documents and links.

    Now, Specs

    Introducing Specs: Markdown as a medium

    We’re launching Specs, a container for your context that lives on the Figma canvas.

    provides a shared container for context right on the canvas, alongside the work it describes, where teammates and agents can contribute together. In this workflow example, an engineer uses Specs and the Figma agentWorld Peas website design in Figma beside an agent conversation showing a request to replace the main image with a close-up mushroom photograph.

    6 easy ways to use the Figma agent right now

    From making designs more expressive and automating busywork, to exploring more possibilities on the canvas, here are six ways to push designers further with the Figma agent.

    to turn sprawling context into a plan their coding agent can build from.

    Agent prompt referencing Pickup UI Guidelines to create UI components, alongside button variants, labels, icons, and a Pickup logo.

    Read all about using Markdown as a medium with Specs.

    The problem

    The team at Pickup, a fictional marketplace shopping app, is scoping a new delivery feature. The lead engineer is taking stock of the designs and technical decisions they’ll need to build it: There’s a PRD, a diagram in FigJam, and a Figma file containing designs, code layers

    Design together with code layers on the canvas

    Today, code layers moves into open beta. Now teams can explore and build prototypes backed by code on the canvas.

    , and components on the canvas. Across all of these sources, it’s not clear which details are missing or who still needs to give input. The engineer needs to connect the dots.

    A code layer is an interactive prototype on the canvas backed by running code.

    Starting with the data

    The engineer combs through the PRD and notices that the team plans to pilot the new delivery feature in a single city, but haven’t identified which one yet. The engineer doesn’t want to start implementing code until they know which city’s map they’re building for, so they decide to look into where Pickup’s demand is highest based on the app’s usage data. That data lives in Hex, the team’s data analytics platform, but the engineer wants designers and other teammates to be able to view and react to the data in a shared space.

    Connectors let the agent access information from a tool outside Figma.

    The engineer turns to the Figma agent to help add the data to the canvas in the form of a spec. They open the agent, add the Hex connector to the conversation, and prompt: Go find where we have the most usage of Pickup and create a spec breaking that down. Also, update this map code layer to show usage data for the top cities.

    A Pickup delivery PRD and a mobile map prototype displayed side by side on the Figma canvas.
    The product team’s PRD sits in a spec beside a map code layer, keeping the delivery requirements alongside the working prototype.

    The agent produces a spec that contains a table with app usage and order volume by city, along with code layers showing maps for each of the top four cities. The engineer and their collaborators review the Hex data and the screens on the canvas. The team decides to launch in Bengaluru, India, the city that clearly has the highest density of customers and demand.

    A Pickup usage report with a city comparison table and chart sits beside four mobile map code layers on the Figma canvas.
    The Figma agent creates a usage report and four map code layers to help the team compare potential launch cities.

    Gathering context on the canvas

    The engineer opens the team’s technical spec. It explains how the app will store information about deliveries, how the team will make the feature available to customers, and how they’ll monitor it for problems after launch. They then drag in an existing FigJam diagram showing the delivery process and what the seller, buyer, and driver each do.

    A spec titled “Delivery Data & System Architecture” contains a flow diagram above sections covering scope, checkout, and pricing.
    The engineer embeds the delivery lifecycle diagram in the technical spec, bringing the visual explanation together with the written requirements.

    Elsewhere on the canvas, designers are reviewing the final screens. The team has added annotations on the frames to call out key details, and both design and engineering approved the designs.

    Three Pickup design frames show the marketplace home screen, map, and product details, with colored annotations attached to specific elements.
    The team specifies when to show the delivery icon and reminds developers to display prices in the local currency.

    The engineer also includes an interactive version of the Bengaluru map as a code layer so the agent can see how it should work—for example, how nearby items group together and how they animate as someone moves around the map.

    Lastly, the engineer reviews a new component from the design systems team. A code layer shows how the component works, and a written spec beside it explains when to use it instead of the existing component.

    The engineer selects the technical spec, annotated design frames, interactive map code layer, new component, and design system guidance on the canvas, then opens the Figma agent. They prompt the team’s previously configured build-implementation-plan skill—a reusable set of instructions for the agent. The agent creates a new spec that brings those inputs together into a plan for a coding agent to build the feature, including how it should look and behave.

    The Figma canvas shows a technical spec with an embedded diagram, annotated design frames, a map code layer, and address component guidance. The agent panel is open on the left.
    The engineer brings together the technical spec, annotated designs, map interactions, and design system guidance before asking the Figma agent to create an implementation plan.

    Reviewing the plan and handing it off

    Before handing the plan off to a coding agent, the engineer reviews it to make sure the details are right, expanding the spec to its full width. They check that the spec includes the team’s design system, testing and observability requirements, rollout details, and a table outlining what needs to be done to build and ship the feature, along with references back to the specs, designs, and code layers it draws from.

    A spec titled “Pickup Delivery: Implementation Plan” includes sections for context, key details, design system adherence, and testing, with a code example.
    The agent creates a spec with an implementation plan for the engineer to review before handing it to a coding agent.

    The engineer spots a detail in the spec that isn’t quite right, leaves a comment on the spec with the problem, then prompts the Figma agent: Read my comment and reply to it with a solution. The agent comments back with an edit for the engineer to review. Reading on, the engineer notices another detail that needs adjustment, but this one requires input from a designer on the team, who the engineer tags in a comment. The designer receives a notification, jumps into the spec, and makes the change in real time.

    Highlighted text in the Pickup implementation plan has an open comment thread asking someone to take a look, with a reply beneath it.
    The engineer mentions a teammate in a comment to check a detail in the generated plan.

    The path to production

    Clicking on the spec, the engineer copies a link to share it and opens Codex. They paste the link and prompt: Implement this feature. Through Figma’s MCPAbstract illustration of interlocking organic shapes in purple and orange on a dark green background.

    The TL;DR on MCP: Why context matters and how to put it to work

    Figma’s MCP server brings your design decisions into the tools where code gets written—so what gets built actually matches what was designed. Here’s what that unlocks for everyone who builds products.

    , Codex can read not just the spec, but also the annotated design frames, code layers, design system components, and other context that went into the plan—all with just one link. All of that context helps Codex build the delivery feature, and once implemented, the team can review and test the feature before rolling it out to users.

    Specs is in open beta on all plans and available on web, desktop, and mobile. Get started here, and learn more in the help center.

    Johnny Dallas is the tech lead for Specs, and is based in NYC. He joined Figma in early 2026 as part of the Gather.town team.

    Create and collaborate with Figma

    Get started for free