Astra is a fictional AI video creation and editing platform whose team ships weekly with agentic coding tools. Speed is an asset, but decisions accumulate in code that never reaches the canvas, leaving design blind to what actually shipped. At best this widens the gap between intent and implementation; at worst incomplete solutions ship because the team can't apply its expertise to the full experience. A simple export video flow sets the initial direction and grows more complex as it evolves in code. A designer and developer at Astra use the Figma MCP server to bring that evolving reality back onto the canvas.
Workflow fact sheet: Figma products: Figma Design, Dev Mode. Tools: Figma MCP server, use_figma, generate_figma_design. Skills: /sync-figma-token. Team: designer and developer.
Where the canvas falls short
The designer lays out an export flow: the user selects a sequence, chooses a format, confirms settings, and exports. That is enough to set direction and start building. At Astra's pace, new states surface as the build progresses—encoding errors, render status, empty selections, unsupported format edge cases. The designer didn't miss them; they became clear once the feature met real code and data, and each is a design decision waiting to be made. When the canvas captures only part of the picture, designers can work on only part of the product. With Figma MCP, an agent can read code and write to the canvas, expanding the workspace to decisions that were previously invisible.
Every coded state on the canvas
The agent reads the coded export flow and identifies every state the developer handled. For each, it generates an editable frame on the canvas using Astra's design system components via use_figma. The designer's canvas grows from four frames to fourteen.
From there the designer works each state. The encoding error has no recovery path, just a red message, so she adds guidance: what went wrong, what to try next, and how to get back. The render loading state is a context-free spinner, so she adds a progress indicator and time estimate. The empty selection is blank, so she gives it copy and personality to drive adoption. Visibility into emerging states shortens the feedback loop, shifting time away from requirements discussions and toward designing and building actual features.
Token drift and a shared reference
Reviewing the states, the designer notices the export confirmation screen looks different in code than in Figma: color values slightly off, spacing tighter. Using the /sync-figma-token skill with the use_figma tool, the agent compares tokens used in code against variables in the Figma library to detect drift and sync values.
Token parity is restored, but a structural problem remains: the button hierarchy has shifted, font styles are wrong, and a secondary button was added. Instead of comparing a deployed build with a Figma frame side by side or filing a dev ticket, the designer asks the agent to document it. With generate_figma_design the agent replicates the coded version as a Figma frame, places it next to the original, and annotates the differences—the hierarchy shift, the type styles, the new action.
The artifact isn't a bug report; it's a shared reference for a design conversation. Some changes, like the secondary action, may be improvements the developer made in context; others may be oversights. Designer and developer can now ask specifically whether the design should update, the code revert, or the two meet in the middle. "Why doesn't it match the design?" becomes collaborative refinement rather than an alignment exercise.
Making ideas cheap again
The export flow works and the build is solid, but the success screen is purely functional: "Export complete. View file." Astra is building a dedicated community around a product that is not only easy but fun to use, and the designer believes exporting a final sequence is a moment to celebrate. In code, every direction is an engineering investment—hard to throw away, easy to settle for "good enough." On the canvas, ideas stay cheap: explore without commitment, discard freely, carry forward only what earns it.
The developer adds a playful transition when the render finishes that previews the exported clip. The motion works but the brand tone doesn't land, so the developer sends the key animation states to the canvas. The designer produces three directions in less than an hour—bold and expressive, minimal and elegant, unexpected and delightful—none bound to tokens or committed to code. She picks the bold, expressive one, and it's ready for the design system: tokens, components, and specs.
What the sprint produced
- Fourteen states landed on the canvas, and the designer pushed each one further.
- Design and code drift was documented and resolved through a shared visual artifact.
- The functional success screen became an expressive brand moment, explored on the canvas before any code commitment.
None of this required the designer to learn the codebase or the developer to learn Figma. The agent translated between the two, and the designer's judgment was applied at every step.
Back to production, and what "source of truth" means
The refined states move back into Dev Mode as updated specs—a direct handoff with no separate review cycle. The visual-diff artifact from the confirmation screen becomes the checklist for the next design-dev sync, turning a potential back-and-forth into one focused conversation. The chosen success screen direction enters the design system as tokens, components, and specs, and the loop between design and code stays continuous.
The source of truth used to be a single artifact—canvas, codebase, or PRD—but that framing breaks down once a team moves fast enough for all three to diverge. What the Figma MCP server enables is a system of artifacts that stay connected: the canvas talks to the code, the code writes back to the canvas, and the designer's judgment moves through both. That is a source of truth that isn't a file but a living connection between the canvas, the codebase, and the team building with both.



