The opening keynote of Config 2026 didn’t disappoint. The biggest announcement was code layers: a feature that brings executable code directly onto the collaborative design canvas, where until yesterday only pixels and vectors lived. It’s not a plug-in or a third-party integration, but a native layer that promises to drastically shorten the gap between design and development.

What code layers are and how they change the workflow

The idea is simple in its radicality: designers can now clone entire repositories and see actual application flows inside Figma layers, testing their behavior without leaving the design environment. This means that the handoff phase – often a cumbersome step in which static mockups are reinterpreted by developers – is largely eliminated. Code is no longer an artifact to be described with words or annotations; it’s an integral part of the canvas, executable and manipulable in real time.

The mechanism uses an architecture that automatically extracts flows from code and transforms them into interactive visual components. Designers can simulate transitions, error states, and dynamic behaviors by drawing directly from production code. It’s a convergence that sounds familiar to anyone following the low-code evolution, but here the context is the most widely used design tool among product teams.

An open platform for AI: custom plugins

Also at Config 2026, Figma unveiled the ability for users to build custom AI plugins. It’s not yet clear whether execution of these plugins will happen exclusively on Figma’s cloud or whether local operation will be possible, but the opening of the platform signals a shift. Until now, artificial intelligence in Figma appeared in the form of built-in features like layout generation or background removal; now it becomes a programmable ecosystem.

For those who develop their own models or have strict privacy requirements, this could foreshadow a scenario where design tools can be extended with local inference components. The boundary between cloud tool and self-hosted component becomes thinner, but for now we are in the realm of possibilities, not official roadmaps.

The sovereignty and control knot

The convergence of code and design on a collaborative platform also raises weighty questions. The executable code flowing on the canvas is processed by a runtime engine whose location – cloud, edge, or on-premise – is not always under the control of the adopting company. In regulated sectors, where data residency and process auditing are binding requirements, the ability to bring one’s own code into an external environment, however protected, deserves attention.

This isn’t a theoretical matter: on-premise or air-gapped deployment scenarios are already a consolidated reality for software development pipelines, and design tools like Figma have so far remained in an exclusively cloud paradigm. The novelty of code layers, together with the ability to extend the platform with AI plugins, could push large organizations to question hybrid models: design canvas in the cloud, but code execution and AI inference on local servers, within their own security perimeter. For those exploring trade-offs between cloud and on-premise, AI-RADAR offers analytical frameworks (see /llm-onpremise) to evaluate benefits and constraints, without imposing recipes.

Beyond handoff: what signal the industry sends

Figma’s move comes at a time when software is reshaping around the idea of continuous toolchains, where the separation between design and development skills becomes increasingly porous. Other players in the field – from Canva to Penpot – are experimenting with different forms of code-design integration, often with an emphasis on open source or self-hosting. In this landscape, Figma’s code layers are not just a feature but a signal: real-time collaboration on code is becoming a competitive battleground.

It remains to be seen if and how the developer community will embrace this hybridization. Because on the one hand, direct code execution on the canvas reduces friction; on the other, it forces a rethinking of responsibilities: who guarantees that the code executed in the design tool faithfully mirrors what will end up in production? The answer, for now, lies in the maturity of the tools and the transparency of runtimes.