Figma Make adds two-way GitHub sync for production code

Figma Make now ships a two-way GitHub integration that converts designs into live, production code while keeping governance controls inside the pipeline. The release changes a workflow that design and engineering teams have traditionally split across two tools with a manual handoff between them.

Until now, the common pattern ran one way: a designer produced a file in Figma, an engineer rebuilt it as code, and any later design revision triggered a second, third, or fourth rebuild. Each cycle cost time and introduced drift between what the designer approved and what shipped. A two-way sync removes the rebuild step in both directions.

What changes for practitioners?

The integration connects Figma Make — Figma's AI-driven design-to-code product — to GitHub repositories. Changes flow in both directions: design updates propagate into the codebase, and code changes reflect back into the design. The file stops being a static mockup and becomes a live artifact tied to the repository.

For interface teams, this shifts where review happens. Designers can review the shipped state of an interface without reading code, because the design surface tracks the repository. Engineers can treat design revisions as versioned changes rather than re-implementation requests.

Where does governance fit?

The phrase "built-in governance" in the announcement signals the second half of the story. Automated design-to-code pipelines risk bypassing review: a generated component can reach production without a human approving its structure, accessibility, or performance. Governance controls inside the integration give teams a checkpoint between generated output and the live codebase.

This matters because uncontrolled sync would create a second path to production — one that skips pull request review. A governed integration instead routes generated changes through the same approval flow engineers already use.

Why this lands now

Design-to-code tools have converged on the same problem: the generated code is only useful if it survives contact with a real codebase, real review processes, and real maintenance. A one-shot export to a starter component addresses the first day of a project. A two-way repository connection addresses every day after it.

The comparison is instructive: an export button produces a snapshot, while a sync produces a relationship. Teams that maintain a product for years live in the second category.

What to watch next

The open questions are the ones the announcement does not answer in detail: which frameworks the generated code targets, how conflicts between simultaneous design and code edits resolve, and how the governance rules are configured per team. Practitioners evaluating the integration will want to test it against a repository with active branches before relying on it for production work.

Figma has positioned Make as the bridge between its design platform and engineering toolchains; this integration moves that bridge from prototype territory into the production pipeline, and the response of engineering teams will show whether governed design-to-code sync becomes a standard part of the interface delivery stack.

By Sophie Lindqvist