For a decade, the boundary between design and development has been a physical one as much as a conceptual one: a Figma file on one side, a code repository on the other, and a handoff ritual in between that translated intent into implementation, one file, one comment thread, one Jira ticket at a time. At Config 2026, Figma proposed erasing that boundary outright. The company’s new “code layers” treat live, running code as a material on the canvas, equal in status to vectors, images, and any other design layer, freely convertible back and forth between the two worlds. It’s a genuinely new kind of object for a design tool to hold, and it’s rolling out from July 2026, currently reachable through a waitlist at figma.com/config-betas. The more interesting question isn’t whether it works, but what it quietly asks of the people who will use it.
Code as just another material
Figma CEO Dylan Field framed the shift in explicitly material terms: “Design is a process. Code is material, just like images, vectors and design layers. For a long time, code has lived in single-player environments built for linear thinking,” he said, according to Figma’s Config 2026 recap. Practically, that means teams can clone a GitHub repo or upload a local codebase directly onto the canvas, extract existing components into inspectable design layers, and convert those layers back into code — a round trip Figma calls “extract designs,” described in detail in Figma’s own writeup of the feature. The pitch is collaboration: designers, PMs, and engineers looking at the same spatial object instead of passing files across a wall. That collapses a lot of friction that used to live in specs, redlines, and Slack threads asking what a hover state was supposed to do, and it does so by making the canvas itself the shared source of truth rather than a picture of one.
Dissolving the handoff doesn't eliminate the engineering judgment that used to live on the other side of it.
An environment built not to care
The friction doesn’t disappear so much as it gets redistributed, and Figma’s own leadership is candid about where it lands. Chief Product Officer Yuhki Yamashita told TechCrunch that the multiplayer canvas is powerful precisely because “this is an environment where you don’t really care about the quality of the code.” That’s a defensible position for a sketch that exists to test an idea in five minutes, and it’s honest in a way most product launches aren’t: it names the tradeoff instead of hiding it. But it becomes a much more precarious stance the moment that same code layer sits a single click away from a live repository, with no structural marker distinguishing throwaway exploration from something a colleague might merge under deadline pressure. Figma is building the fastest possible bridge between prototype and production; it hasn’t yet built the checkpoint that tells you when you’ve crossed it.
The handoff didn’t vanish, it moved earlier
This is where the more useful reading of code layers departs from the launch narrative. Qubika’s analysis of Config 2026 argues that “the design-to-development handoff, as it has existed for the past decade, begins to dissolve,” and that the designers who benefit most are the ones who already think in systems — who understand how a component library behaves, what its interaction states and edge cases look like, rather than treating each screen as a one-off composition. That’s the real substance of the shift: dissolving the handoff doesn’t eliminate the engineering judgment that used to live on the other side of it. It just relocates that judgment earlier, into the design phase itself, and makes it an implicit part of the designer’s job description whether or not the job title changes. A tool that lets anyone drag a running component onto a canvas raises the skill bar for using it well, even as it lowers the bar for producing something that merely runs, and the gap between those two outcomes is exactly where the next generation of design hires will be measured.
What’s left conspicuously unresolved is accountability. If code layers are explicitly sanctioned as a space where quality doesn’t matter, and that same code can be extracted, converted, and shipped with a few gestures, who is responsible when a “don’t worry about it” prototype becomes the thing actually running in production — the designer who assembled it, the engineer who let it through review, or the tool that made the distance between the two disappear in the first place. None of Figma’s launch materials answer that question, and it’s not obvious it’s a question a design tool can answer on its own; it belongs to whatever process a team builds around the tool, not to the tool itself. Figma has built the canvas. The governance for what happens on it is still, by the company’s own account, someone else’s problem to solve later.
