Summary: On May 28, 2026, Figma Make gained the ability through the desktop app to connect to production or sandbox repositories and edit real software from a visual surface. Make kits and attachments can carry real components, styles, and project context into prompts. The article still routes every production change through diffs, CI, and pull-request review because the result is ultimately a commit.
Figma picked May 28, 2026 to hand Figma Make a power most observers assumed was still years out: over the Figma desktop app, Make can now latch onto a production or sandbox repository and serve as what the company describes as “a visual surface for building and editing real software.” Arriving with it is a panel built for “precise design adjustments like layouts, colors, font sizes, and effects.” Said plainly, a design-tool company has just put out a code editor pointed at production codebases — and the last wall between design and code is coming down one panel at a time.
How the Hookup Works
By The Verge’s account, the whole connection runs inside the desktop app, and whether a team binds a production repository or a sandbox one is its own decision — the sandbox route plainly exists so people can rehearse first in an isolated setting. Once bound, Figma Make behaves like a visual editing layer laid over the codebase: sweeping changes come in as prompts, small corrections come in through the new panel, and the two routes share a single workspace. CMSWire’s reading was equally direct: the additions carry designers “deeper into engineering territory,” able to touch production code without ever leaving the canvas. The Verge treats the launch as the sequel to Make’s earlier general availability — a fast move from text-to-app showcase toward a tool that means to live inside your engineering workflow rather than beside it.
From Prototype Generator to Production Floor
The update also redraws what Figma Make is. It started out as a prompt-driven prototype generator; the label it wears now is an interface for editing real software. Figma’s companion piece published the same day, “4 new ways to go from idea to product with AI tools,” offers numbers worth lining up side by side. Marketing agency Merkle had Figma’s AI agent produce about 50 layout variations for a telecom client, folding “the production work that would have taken days… into hours.” Affirm moved checkout payment-plan badges “from idea to working prototype in two days instead of the usual six weeks,” with MCP carrying components, tokens, and layout structure straight into the coding environment. Hotel group Accor prototyped a webpage that rebuilds itself around whatever a user types — enter “golf” and the page reshapes — while the Figma MCP server “kept everything connected to the brand’s design system.”
That same article put Make kits on the table — Figma’s own comparison is that they “do for Figma Make what MCP does for AI-generated code” — so a prototype draws on your real components and styles from the first prompt onward, and Make attachments carry project context such as data and brand guidelines in along with it. These mechanisms are what keep production editing from straying: a visual edit only holds up when it lands on a genuine design system, not on a believable stand-in improvised on the spot.
Where Design Ends and Engineering Begins Is Moving
Plugging a visual editor into a live repo rearranges who answers for what, not merely which tools sit in the chain. Designers get their hands on software that actually runs sooner — FloQast’s story in the same Figma piece shows why: a prototype with a simulated backend, exercised against realistic data from an actual customer, surfaced “flows that looked right on the surface but fell apart in practice.” That is precisely the case for closing the design-to-code distance early. Even so, a visual edit made on a production repository always comes out the other end as a commit. Every extra editing door loads more work onto code review and CI, and engineering review capacity becomes the next spot where queues form. Figma’s own telling of the design-to-code loop — draft a prototype in an AI coding tool, bring it back to the canvas to polish, then take MCP back into code “with the design context intact” — makes clear the corridor now carries traffic both ways.
Three Decisions to Settle Before Switching It On
Start on the sandbox repository and reach for production only after review discipline has genuinely taken hold. Route every change Make makes through the pull-request routine — read the diff first, then clear CI; however precise the panel becomes, what finally lands is still a single commit. Connect Make kits or an MCP design-system integration on day one so visual edits touch real components and real tokens; leave that out, and design debt simply moves house from the mockup into the repository. The tool opened the door; building the governance is left to you.