Figma Merges Live Production Code Directly Into Design Canvas
Figma
Integrating live codebases directly into the design canvas eliminates the redundant labor of manually rebuilding interactive prototypes as static vector layers for developer handoff.
Figma introduced Code layers to embed interactive, executable code directly onto the infinite design canvas, allowing teams to explore and branch functional code prototypes side by side. (4:45)
Make functions as a visual production code editor that runs against local Git repositories, enabling non-engineers to visually annotate UI changes, auto-commit updates, and file pull requests directly to production. (21:40)
An embedded Figma Model Context Protocol (MCP) server powers bidirectional synchronization, allowing visual modifications in code to update Figma libraries and code-only screens to convert into native design frames. (32:23)
Figma introduced deterministic screen extraction to instantly unpack running prototype flows into static spec frames on canvas without using AI models or consuming API tokens. (16:11)
Detailed notes
## Background
Published on YouTube by Figma on June 26, 2026, this Config deep-dive session presents two major platform additions: Code layers and Make. According to the page description, the presentation demonstrates how these launches bring code natively into Figma—allowing creators to explore code on the canvas, design within local codebases, and collaborate seamlessly through to production.
## TL;DR
Figma team members Iris, Nico, Ben, and Al explore how Code layers and Make bridge the gap between divergent visual ideation and production-ready software development. Nico and Ben demonstrate cloning GitHub repositories directly onto the canvas to branch interactive code layers with AI agents, test edge cases, and deterministically extract static spec screens without terminal overhead. Al and Iris then reveal how Make connects to local production repositories, enabling safe Git branching, targeted visual annotations, and direct manipulation of live UI components grounded in real design tokens. The talk culminates in showing bidirectional synchronization between codebases and Figma libraries, allowing teams to ship verified updates directly via pull requests.
## Atmosphere & style
The presentation carries an energetic, playful tech conference vibe, punctuated by easy banter, audience laughter, and lighthearted jokes about San Francisco weather and undersized UI badges. Fluid transitions between presenters give the deep dive a conversational workshop feel, contrasting high-level design philosophies with pragmatic, live canvas demonstrations. Watching the team navigate real-time AI code branching and visual Git workflows evokes a palpable sense of relief and enthusiasm for liberating product teams from disjointed developer terminals.
## Bulletin
- [04:45](https://www.youtube.com/watch?v=Q3BkuQRBg-w&t=285s) Figma introduced Code layers to embed interactive, executable code directly onto the infinite design canvas, allowing teams to explore and branch functional code prototypes side by side.
- [21:40](https://www.youtube.com/watch?v=Q3BkuQRBg-w&t=1300s) Make functions as a visual production code editor that runs against local Git repositories, enabling non-engineers to visually annotate UI changes, auto-commit updates, and file pull requests directly to production.
- [32:23](https://www.youtube.com/watch?v=Q3BkuQRBg-w&t=1943s) An embedded Figma Model Context Protocol (MCP) server powers bidirectional synchronization, allowing visual modifications in code to update Figma libraries and code-only screens to convert into native design frames.
- [16:11](https://www.youtube.com/watch?v=Q3BkuQRBg-w&t=971s) Figma introduced deterministic screen extraction to instantly unpack running prototype flows into static spec frames on canvas without using AI models or consuming API tokens.
## Key takeaways
- [01:33](https://www.youtube.com/watch?v=Q3BkuQRBg-w&t=93s) Unchecked AI prototyping velocity can mask architectural flaws and undermine product thinking if teams skip divergent exploration.
- [02:40](https://www.youtube.com/watch?v=Q3BkuQRBg-w&t=160s) Prototyping in isolated IDEs and terminals disconnects designers from shared design systems and forces manual rework during developer handoff.
- [04:45](https://www.youtube.com/watch?v=Q3BkuQRBg-w&t=285s) Code layers bring executable code natively into the Figma canvas, bridging visual ideation and working software without leaving the design environment.
- [09:38](https://www.youtube.com/watch?v=Q3BkuQRBg-w&t=578s) Designers can clone authenticated GitHub repositories directly onto the canvas, treating code layers as dynamic viewports into an underlying codebase.
- [10:51](https://www.youtube.com/watch?v=Q3BkuQRBg-w&t=651s) AI agents can convert static vector designs into code layers and orchestrate parallel branching to test multiple interaction states simultaneously.
- [12:25](https://www.youtube.com/watch?v=Q3BkuQRBg-w&t=745s) A single prompt across multiple code layers allows creators to apply unified layout constraints and visual fixes across all branches at once.
- [14:46](https://www.youtube.com/watch?v=Q3BkuQRBg-w&t=886s) Discarded prototypes and edge-case explorations are critical assets that reveal structural issues often hidden beneath polished happy-path mockups.
- [16:11](https://www.youtube.com/watch?v=Q3BkuQRBg-w&t=971s) Deterministic screen extraction unrolls runtime states into static, inspectable specification frames with zero AI token overhead.
- [19:28](https://www.youtube.com/watch?v=Q3BkuQRBg-w&t=1168s) Stripping backend infrastructure from prototyping playgrounds accelerates AI inference speed and lowers token consumption while preserving front-end design components.
- [24:27](https://www.youtube.com/watch?v=Q3BkuQRBg-w&t=1467s) Make connects directly to local codebases, enabling safe experimentation on Git branches without endangering production stability.
- [26:47](https://www.youtube.com/watch?v=Q3BkuQRBg-w&t=1607s) Targeted visual annotations allow users to scope AI coding prompts to specific bounding boxes rather than rewriting entire templates.
- [32:23](https://www.youtube.com/watch?v=Q3BkuQRBg-w&t=1943s) Native Figma MCP integration connects design tokens and components to the coding agent without requiring manual server configuration.
- [33:44](https://www.youtube.com/watch?v=Q3BkuQRBg-w&t=2024s) The Make design panel provides direct visual manipulation over code variables, typography scales, and component properties without requiring conversational prompting.
- [36:54](https://www.youtube.com/watch?v=Q3BkuQRBg-w&t=2214s) Bidirectional synchronization lets developers and designers push live code adjustments back into the canonical Figma design system.
- [38:00](https://www.youtube.com/watch?v=Q3BkuQRBg-w&t=2280s) Using the 'Copy designs' tool, code-rendered interfaces can be pasted back onto the Figma canvas as fully editable vector layers.
- [40:05](https://www.youtube.com/watch?v=Q3BkuQRBg-w&t=2405s) Completed iterations in Make can be packaged into standardized Git commits and submitted as production pull requests directly from the design tool.
## Detailed walkthrough
### [00:11](https://www.youtube.com/watch?v=Q3BkuQRBg-w&t=11s) Introductions and Welcome to Day Two Deep Dives
Jorja Hess from Figma's product team and Angel Annunziata from the research team open the second day of deep dives at Config, welcoming attendees and asking the audience to put their phones on silent so everyone can be fully present. Setting the stage for the morning's first technical deep dive, they introduce the team presenting on the topic of designing with code: Iris, Al, Ben, and Nico, playfully introduced as the “infamous red hat guy.”
Nico kicks off the session with high energy, cracking a joke about San Francisco's foggy weather and hoping people brought their layers, noting that jokes always get better after being repeated two or three times, before passing the microphone over to Iris to establish the core challenges facing designers today.
---
[01:33](https://www.youtube.com/watch?v=Q3BkuQRBg-w&t=93s) The Promises and Pitfalls of AI-Driven Workflows
Iris begins with an honest reflection on the current state of product development, observing how rapidly AI coding tools—such as Figma Make—allow designers and non-designers alike to prompt concepts into existence. Although having direct access to code opens up novel avenues to express ideas and spin up prototypes faster than ever, Iris warns that raw velocity does not equal design quality: “We get unprecedented speed with our new AI workflows. We can spin up prototypes quicker than ever, but speed itself isn't a solution.”
```mermaid
flowchart TD
accTitle: The Pitfalls of Isolated AI Prototyping
accDescr: Diagram illustrating how rapid AI vibe-coding leads to lack of design exploration, divergence from systems, and isolation.
subgraph SpeedVsDesign ["Velocity vs. Intent"]
A["Rapid AI Prompting / Vibe Coding"] --> B["Polished, Convincing Surface"]
B --> C["Skips Broad Ideation & Exploration"]
end
subgraph SystemBreakdown ["System & Team Breakdown"]
C --> D["Divergence from Design System"]
D --> E["Double Work Rebuilding in Design Layers"]
E --> F["Isolated Workflows in Terminals/IDEs"]
end
```
The friction arises when teams mistake convincing, polished "vibe code" for sound product thinking. Because teams lack the time to interrogate solutions over multiple weeks, they frequently skip the messy, foundational phase of divergent exploration. Furthermore, when designers work on individual code prototypes in isolation, their work easily drifts away from company design systems. This divergence creates redundant labor down the road, forcing designers to manually recreate code prototypes back into static design layers just to facilitate developer handoff. Compounding this is the isolation of working inside terminals and IDEs, which cuts off the open, collaborative canvas environment where multidisciplinary teammates can freely iterate together.
- AI tools make concept generation rapid, but polished prototypes often mask misaligned initial intent.
- Isolated development creates divergence from core design systems and design guardrails.
- Teams waste cycles manually rebuilding code prototypes as vector design layers for handoff.
- Engineering environments like IDEs and command-line terminals hinder spontaneous cross-functional collaboration.
---
[04:45](https://www.youtube.com/watch?v=Q3BkuQRBg-w&t=285s) Introducing Code Layers and Make for Production Code
To eliminate the forced trade-off between living in a design canvas and working in code, Iris announces two major solutions: Code layers and an expanded role for Make. Rather than forcing designers into external developer environments or requiring engineers to interpret static vector files, code is brought natively into the Figma canvas through Code layers. This setup allows teams to seamlessly shift between modalities, testing and contrasting divergent ideas side by side on a shared infinite board.
Simultaneously, production code becomes an active participant in design via Make, which now functions as a production code editor. When natural-language prompting reaches its limits, Make gives designers fine-grained, visual controls to refine their implementations while keeping their original product intent intact. With this foundation laid, Iris passes the stage to Ben and Nico to explore real-world workflows using Code layers.
---
[05:43](https://www.youtube.com/watch?v=Q3BkuQRBg-w&t=343s) Prototyping as an Explorable, Tactile Material
Taking over, Nico and Ben dive into the tactile reality of designing with code, emphasizing that real-time canvas collaboration far outshines asynchronous screen recordings. Nico addresses the audience by calling out the famously chaotic, sprawling Figma files familiar to every practicing designer. Far from viewing this disarray as a defect, Nico celebrates it as the hallmark of creative problem-solving: “The design process is can be so messily beautiful. And because you need to go broad and deep at the same time.”
```mermaid
flowchart LR
accTitle: Prototyping Approaches Comparison
accDescr: Contrasting traditional cardboard prototyping with modifying real materials in Code Layers.
subgraph CardboardApproach ["Traditional Static Prototyping"]
direction TB
A1["Rebuild Entire UI from Scratch"] --> B1["'Cardboard Backpack' Mockup"]
B1 --> C1["Dense Spaghetti Wireframes"]
end
subgraph CodeLayerApproach ["Code Layers Prototyping"]
direction TB
A2["Import Existing Production Code"] --> B2["Cut In with AI / Hot Glue Additions"]
B2 --> C2["Infinite Duplication & Divergence"]
end
```
Contrasting the linear nature of coding with AI agents—where a user writes a prompt or loop and moves linearly in a single direction—Nico explains that design requires a flexible workbench that supports simultaneous breadth and depth. Referencing Antoni Gaudí, who famously designed the organic catenary arches of the Sagrada Família by hanging models upside down with weighted strings, Nico illustrates that physical and digital crafts both require unconventional exploration to find natural forms.
Reflecting on his seven-plus years working on Figma's prototyping features, Nico sympathizes with users who build massive, incomprehensible webs of interaction noodles. Traditional prototypes feel like building a backpack out of cardboard from scratch just to test a strap. In contrast, Code layers let designers take an existing production backpack, take a knife to it, attach a custom piece with hot glue, and evaluate how it feels. Crucially, the digital medium allows teams to duplicate that hacked-together prototype infinitely to test ten alternatives side by side without ruining the original.
---
[09:38](https://www.youtube.com/watch?v=Q3BkuQRBg-w&t=578s) Demonstrating Live GitHub Repository Cloning on the Canvas
Moving to a live demonstration, Nico walks through how Code layers connect directly to existing software projects using the new GitHub repository import. Opening a Figma canvas, he navigates to the "build with code" menu, selects "clone repository," and views an authenticated list of codebases linked to his account. With a single click on a repository, an agent begins cloning the project directly onto the canvas.
Nico clarifies the underlying mental model of this architecture: Code layers are not just static code blocks pasted onto artboards; they function as interactive viewports into the underlying repository. Multiple team members can open distinct windows into the same repository from different coordinates on the canvas, visualizing and manipulating live code without breaking the centralized codebase. Nico then prepares to demonstrate an alternative entry point by selecting two static UI designs to feed directly into the agent.
- Users can import live code directly from authenticated GitHub repositories via the "build with code" interface.
- An AI background agent manages the cloning and setup process on the canvas.
- Code layers act as dynamic "windows" into the repository rather than isolated snippets, allowing multiple divergent views into the same codebase.
[10:51](https://www.youtube.com/watch?v=Q3BkuQRBg-w&t=651s) Generating and Branching Code Layers with AI Agents
Nico demonstrates how an AI agent can bridge raw visual designs and working code directly on the Figma canvas. Selecting an element on the screen, Nico triggers the prompt, “Build interactive code layer from this design.” Under the hood, the agent evaluates the selected Figma design layers and context, generates a corresponding code layer, and applies the designated behavior. To explore alternative interactions without typing in front of the audience, Nico pastes in a follow-up request asking the agent to create three distinct variations of the post-drag slider state: an expressive version, an animated one, and a basic, instant transition.
The agent inspects the code, duplicates the code layer into separate parallel branches, lays them out side by side on the canvas, and dispatches tailored prompts to each instance. Nico walks through the rendered results to inspect the animations, hiding and showing the Figma interface along the way. One variation erupts with a celebratory burst of confetti and a swoosh, another provides a slower, subtler drag transition, and the third snaps into place instantly. Delighted by the confetti effect, Nico replays it for the laughing audience before demonstrating multi-layer prompting. Navigating between instances reveals a slight alignment jump, so Nico issues a single collective instruction across all code layers: ensure the bottom dragging handle remains fixed in the same relative position between the initial state and the unlocked state. The agent evaluates the request and modifies each code layer independently to enforce the constraint. Nico wraps up the sequence by highlighting that the underlying codebase was imported directly from GitHub, teasing deeper code-layer capabilities to be shown later by Iris and Alice before handing the stage over to Ben.
```mermaid
flowchart TD
accTitle: AI Agent Code Layer Branching and Multi-Layer Prompting
accDescr: Diagram showing how Figma design layers are converted into parallel code branches and simultaneously modified by an AI agent.
subgraph Input ["Design to Code"]
D["Figma Design Layers"] -->|"Prompt: Build interactive code layer"| A["AI Agent"]
A --> CL["Base Code Layer"]
end
subgraph Branching ["Branching Solution Space"]
CL -->|"Prompt: 3 Variations"| A
A --> V1["Expressive Branch (Confetti & Swoosh)"]
A --> V2["Subtle Branch (Smooth Animation)"]
A --> V3["Basic Branch (Instant Snap)"]
end
subgraph Coordination ["Multi-Layer Operation"]
V1 & V2 & V3 -->|"Global Prompt: Fix Handle Position"| A
A -->|"Individual Code Patches"| Sync["Synchronized Code Layers"]
end
```
- Nico emphasizes the speed of parallel exploration: “And it will duplicate this code layer creating separate branches of your code base putting them side by side and sending individual prompts to each making it much faster for you to explore the solution space ahead of you.”
- The agent is capable of transforming Figma vector design layers into executable code, spinning up parallel branches, and modifying multiple code layers at once through a single coordinated prompt.
- The working environment connects directly to external version control by importing a live GitHub repository into the code layer.
[14:46](https://www.youtube.com/watch?v=Q3BkuQRBg-w&t=886s) Edge Cases, Collaboration, and Why Polish Can Be Deceptive
Taking the stage to applause, engineering manager Ben praises the creativity of Figma designers and reflects on the nature of product development. While polished prototypes are exciting, Ben argues that the discarded concepts and early exploratory branches are often the most valuable artifacts of the design process. In cross-functional teams, engineers frequently push back on initial concepts by probing for edge cases, performance limitations, and technical complexity that happy-path mockups overlook.
Ben warns that modern AI tools exacerbate this friction because they can effortlessly churn out interfaces that appear complete on the surface while masking deep structural omissions. Discovering these architectural cracks early is essential. Traditional handoff channels—such as dropping prototype links into Slack threads only to receive scattered emoji reactions—make it nearly impossible to organize feedback or arrive at clear product decisions. By contrast, an open canvas preserves the messy evolution of ideas in one shared view, allowing team members to directly inspect trade-offs and prompt their own changes on top of existing work.
- Explaining the reality of product engineering, Ben remarks: “Because design is not just about the happy path.”
- Ben highlights the hidden risk of automated code and design generation: “AI is really great at building stuff that looks polished, but it's full of holes. And that kind of feedback is so important to get early on.”
- Rather than isolating prototypes behind external links and fragmented chat threads, keeping live code variations on a single canvas empowers team members to pick up an artifact and prompt adjustments immediately.
[16:11](https://www.youtube.com/watch?v=Q3BkuQRBg-w&t=971s) Deterministic Screen Extraction and Live Spec Reviews
Switching to a live demonstration, Ben reviews three interactive onboarding prototypes sent over by a designer. Because comparing interactive prototypes through manual clicking alone makes it hard to pinpoint what changed, Ben demonstrates a fast extraction workflow: stepping through the prototype flow and hitting stop immediately unpacks every state and transition into separate, static canvas screens. Ben highlights that this extraction mechanism does not rely on an AI model; it is completely deterministic, instant, and free of token costs.
Extracting the screens from all three prototypes reveals their key structural differences side by side. In one flow, the email verification step was placed in the middle of onboarding, whereas a subsequent iteration shifted it to the very end to remove friction. Another iteration introduced single sign-on (SSO) alternatives and swapped a card-based layout for a grid comparison. Having all generated screens laid out statically transforms abstract user flows into an actionable design specification where engineers can immediately identify missing requirements—such as whether a password field is necessary or what error state renders when an incorrect verification code is submitted.
Transitioning into the persona of an incentive-driven growth product manager whose bonus hinges on conversion rates, Ben demonstrates how non-engineers can iterate on code layers. Taking a shared component, Ben duplicates the layer and submits a prompt to make the button shimmer. Reviewing side variations, one branch applies a shimmering highlight strictly across the call-to-action button, while another animates the entire slider container. Ben shows how easily a teammate can fork an existing prototype to test alternative micro-interactions, like adding bounce animations or adjusting completion states, without filing engineering tickets.
- Emphasizing the utility of static artifacts for team reviews, Ben observes: “These sort of discussions are much easier to have in a static spec-like format because the canvas is not just for doing your own work, it's for presenting it and bringing your team in.”
- The screen extraction feature runs deterministically in real time, converting live runtime states into static inspectable frames without consuming AI tokens.
- Team members can fork an active code layer and iterate on visual micro-interactions—such as button shimmers, element bounces, and completion effects—via natural-language prompts.
[19:28](https://www.youtube.com/watch?v=Q3BkuQRBg-w&t=1168s) High-Fidelity Code Layers and Prototyping vs. Production Realities
To demonstrate that code layers are not limited to trivial buttons or basic sliders, Ben unveils a full clone of the Figma design interface running directly within a canvas code layer. Ben interacts with the embedded application in real time: selecting objects, adjusting items within the elements panel, and modifying layer colors on the fly. Joking that modifying such an advanced prototype would typically require opening a terminal and starting up a local development server, Ben points out that this complex application is simply another interactive code layer. It runs side by side with other instances on the canvas, requiring no local development environment, no Git branch management, and no terminal commands.
Returning to the presentation slides, Ben articulates the architectural philosophy behind separating prototyping code from production codebases. Production software carries substantial overhead that actively hinders rapid design exploration—including complex backends, databases, authentication, routing, and deployment infrastructure. Prototyping playgrounds incorporate production-grade front-end design system components while shedding unnecessary infrastructure. This streamlined environment provides a significant performance boost for large language models, accelerating generation speed while reducing token consumption.
| Approach | Primary Goal | Environment & Dependencies | Key Advantages |
|:--- |:--- |:--- |:--- |
| **Prototyping Code** | Rapid ideation & team feedback | Isolated playgrounds, real UI components, zero backend/deployment baggage | High iteration speed, low token usage, accessible without developer tooling |
| **Production Code** | Shipping & final implementation | Full production repository, live backends, build systems, deployment pipelines | Pixel-perfect UI fidelity, direct code deployment, edge-case coverage |
- Emphasizing the division between workflow phases, Ben explains: “When you're doing exploration, prototyping code lets you test ideas quickly and get feedback from your team.”
- When teams move from exploration into implementation, shifting directly into production code allows developers and designers to nail down precise UI details and ship verified changes directly to users.
- Stripping away production infrastructure in prototyping playgrounds allows AI models to process front-end codebases significantly faster, saving both engineering time and API token budgets.
[21:39](https://www.youtube.com/watch?v=Q3BkuQRBg-w&t=1299s) Designing on Production Code with Make
Following Ben’s introduction highlighting how AI enables designers to ship high-craft changes straight to production, Al and Iris take over to showcase how Figma’s new capabilities in Make interact with live production code. When a team already has clear product direction and enters the final refinement stage of a project, small details often get overlooked or compromised. Working directly on the production codebase grounds design exploration in technical reality. Al emphasizes that this shift ensures teams build against real constraints rather than rough approximations, stating: “This is a time when we want to start from reality, work within realistic constraints, so that we can test actual behavior, and ultimately get the power to ship with confidence.”
To demonstrate this workflow, Al introduces a real-world scenario centered on a fictional outdoor meetup platform named Offtrail. The platform connects community members to discover and participate in local outdoor activities. To monetize the platform, Offtrail is running a pilot with corporate event sponsors, starting with two sports brands: Drift and Cadence. Al plays an audio recording of a customer call with Chad, the CEO of Cadence, who expressed concern after reviewing Offtrail’s website. Chad noted that while Cadence was thrilled to sponsor gatherings like the "Canyon Crew Meetup," attendees could hardly tell the events were Cadence-sponsored. To retain sponsor investment, Offtrail needs to make brand sponsorships prominent across the user experience.
```mermaid
flowchart TD
accTitle: Production Code Workflow in Make
accDescr: Diagram illustrating how cloned production code in Make maps to FigJam and branch-based design iterations.
subgraph RepoSetup["Local Environment"]
A["GitHub Repository"] -->|"Cloned locally"| B["Make Local Codebase"]
end
subgraph Exploration["Discovery & Architecture"]
B -->|"AI / MCP Agent analysis"| C["Interactive Website Preview"]
C -->|"Generate surface map"| D["FigJam Canvas<br>(Event, Map, Profile, Home)"]
end
subgraph Iteration["Branch & Annotation"]
B -->|"git checkout -b"| E["Feature Branch: 'L's sponsor'"]
E -->|"Visual Annotation Tool"| F["Targeted Element Prompting"]
F -->|"Auto-commit on complete"| G["Push & Share with Design"]
end
```
[24:27](https://www.youtube.com/watch?v=Q3BkuQRBg-w&t=1467s) Local Codebases, Architecture Mapping, and Safe Branching
Al explains that Make runs directly against the user’s local code by cloning the production repository through a connected GitHub account. Because the codebase lives locally on the designer's or product manager's machine, the AI agent generates code that naturally adheres to the repository’s existing architectural patterns and component libraries, all without risking live production. Before modifying anything, Al uses an AI agent to analyze the entire codebase and map every user interaction touchpoint where event sponsorships might appear. The agent outputs this structural overview directly into a FigJam file, visualizing the event detail page, profile page, map page, and homepage. Recognizing that the featured event card on the homepage gets the highest traffic, Al decides to prioritize placing the Cadence badge there.
Before making any visual edits, Al creates a new Git branch called `L's sponsor` directly inside the interface, checking it out from the latest `main` branch so all recent team commits are included. Al explains that source control concepts have been reimagined to make non-engineers comfortable in a codebase without fear of breaking things: “And the reason why I'm going to do that is so that my work is completely protected and I'm able to ideate without being worried about being that one product manager who brought down prod.”
- **Local Git Repository:** Make connects via GitHub, keeping files locally so tests and edits remain completely isolated from production servers.
- **MCP Architectural Mapping:** The agent traverses the project files to output a FigJam diagram mapping where events surface (Homepage, Event Detail, Map, Profile).
- **Branch Synchronization:** Creating a branch pulls the latest changes from `main`, guaranteeing that all explorations reflect up-to-date dependencies and UI states.
[26:47](https://www.youtube.com/watch?v=Q3BkuQRBg-w&t=1607s) Targeted Visual Annotations and Frictionless Git Workflows
Instead of drafting lengthy, complex prompts describing element positions, Al uses Make’s visual annotation tool. Al clicks directly on top of the featured event hero image and enters a concise prompt: “Add a badge saying 'sponsored'.” A shimmering outline appears over the image, visually signaling that the agent is targeting that exact bounding box rather than rewriting unrelated parts of the page. Al contrasts this tactile workflow with conventional generative interfaces, noting: “Sometimes, I find it pretty tricky to guide an agent to make the exact change that I'm trying to make. But using annotations, I can point exactly at what I want and hand it over to the agent.”
Al explains that adapting Git into Make required stripping away traditional command-line friction while retaining its core safety guarantees:
- **No manual saving needed:** Just as Figma removed manual saves a decade ago, Make auto-commits file changes after every completed prompt.
- **Visual history and rollbacks:** Users can revert prompts or review previous commits similarly to stepping through version history in a design document.
- **Seamless branch switching:** Teammates can view each other’s branches via dropdown menus or direct links.
Once an audio chime signals the agent has completed the request, Al reviews the canvas. The newly generated badge is present but minuscule. Al adds a follow-up annotation: “make this a little bigger and bolder.” Another chime sounds, revealing a slightly updated badge. Still wanting more visual polish, Al uses Make’s built-in share modal to push the local commits to the remote repository and invites product designer Iris directly to the branch.
[30:39](https://www.youtube.com/watch?v=Q3BkuQRBg-w&t=1839s) Iris Bridges the Gap Between Production and Figma Exploration
Iris takes over the project, accessing the branch pushed by Al. Iris observes the tiny badge on the homepage and jokes, “What is this? A badge for ants? I think Chad's going to want more of his branding here.” She explains that getting direct access to Al's branch eliminates miscommunications because both product and design see the exact state of the code.
Iris opens the FigJam architectural diagram generated earlier by Al via the Model Context Protocol (MCP) agent. She highlights how difficult it used to be to verify what was actually live in production, which usually required spinning up local servers, creating artificial test user accounts, and navigating confusing app states just to locate a screen. Iris reflects on the shift in visibility, stating: “A lot of this time I have to do this manual work to find out, but with this diagram, I can quickly understand all the surfaces where this badge needs to show up and it's visibility into production code that I never had before, and I'm going to make sure that the design solution I come up with covers everything.”
Seeing that Al tagged the homepage and detail surfaces as P0 priorities, Iris reviews several alternative badge components she had previously drafted on an open Figma canvas. She explains that while production code is essential for execution, designers still need the freedom of an unconstrained, blank canvas to ideate visual solutions before locking them down into code prompts.
[32:23](https://www.youtube.com/watch?v=Q3BkuQRBg-w&t=1943s) Testing Designs in the App with Make and Built-in MCP
Having explored potential layouts on the canvas, Iris moves to test how the new sponsored badge looks directly inside the live application using Make. She grabs the link to her Figma frame, returns to Make, selects the specific area where the component should live, and prompts the agent: "add this sponsored badge according to my Figma design." With a single click, she applies the generated changes.
```mermaid
flowchart LR
accTitle: Figma to Make Integration Workflow
accDescr: Diagram illustrating how Figma designs link through the built-in MCP server into Make to update the codebase.
subgraph FigmaCanvas["Figma Canvas"]
A["Figma Frame Link"]
end
subgraph MakeEnvironment["Make Environment"]
B["Built-in Figma MCP Server"]
C["AI Coding Agent"]
D["Interactive App Preview"]
end
A --> B
B --> C
C --> D
```
Switching back to the slides while the model processes the request, Iris highlights the underlying architecture powering this bridge: the Model Context Protocol (MCP). She emphasizes that users do not need to configure anything manually because the Figma MCP server is embedded natively inside Make:
> “The beautiful thing about Make is that the Figma MCP server is built directly into Make, which means you don't have to set it up manually.”
- The built-in MCP server provides the exact same suite of tools used across standalone AI coding assistants, enabling bidirectional movement between code and design.
- Integrated tooling automatically keeps the design system connected and synchronized across both code and visual artifacts.
---
[33:44](https://www.youtube.com/watch?v=Q3BkuQRBg-w&t=2024s) Direct Manipulation and Native Variables in the Make Design Panel
Turning back to the preview, Iris notes that while the AI agent got the badge remarkably close to her design, it was not completely pixel-perfect. Rather than repeatedly re-prompting the model, she points out the visual editing panel on the right side of the screen. Users can bypass conversational prompting entirely, dragging and dropping elements directly within the UI to match exact specifications. Iris remarks:
> “This really helps me get fine-grained control over the result and it feels more native to me to be able to do it this way than having to prompt to do it this way.”
The demo takes an interactive turn when Iris jokes with Chad about making his company's sponsor name bigger on the badge ("Yeah, I mean, I'd like more money for sure," Chad quips). When she clicks on the text element to adjust it, the design panel surfaces all the existing design variables straight from the codebase. Iris demonstrates adjusting colors and typography using these detected tokens. Make automatically inspects the local codebase, mapping component properties, color variables, spacing scales, and text styles so that visual adjustments stay strictly within the design system's constraints.
- Make features a dedicated "Generate properties" button in the component section of the edit panel to detect code components and expose their props visually.
- Direct manipulation of interactive components—such as selecting a primary register button, toggling icons, and adjusting sizes—happens in real time without generating text prompts.
---
[36:54](https://www.youtube.com/watch?v=Q3BkuQRBg-w&t=2214s) Bidirectional Design System Syncing and Code-to-Canvas Roundtripping
When deep into AI prompting, implementations in code often diverge from the canonical design files. Iris shows what happens when her local component evolves beyond the official Offtrail design library. Instead of manually redrawing the changes in Figma, she prompts the agent:
> “Can you update the sponsored badge component in the Offtrail design library to reflect the changes I made here?”
The agent pushes the updates back into the Figma library file, ensuring team members immediately benefit from the production refinements in their own design files.
```mermaid
flowchart TD
accTitle: Roundtrip Synchronization Cycle
accDescr: Cycle showing how code changes in Make push to the Figma library and how code-first pages can be extracted back to the canvas.
subgraph LocalCode["Make / Codebase"]
E["Code Updates & Prompting"]
F["Event Detail Page (Code-Only)"]
end
subgraph FigmaLibrary["Figma Design System"]
G["Offtrail Design Library"]
H["Canvas Design Layers"]
end
E -->|"Sync prompt via MCP"| G
F -->|"Copy designs tool"| H
H -->|"Canvas edits detected"| E
```
Iris then demonstrates an advanced edge case: an event detail page created for Chad's brand (Cadence) entirely via code prompting, leaving no Figma source frame behind. Using a dedicated tool called "Copy designs," Iris extracts the rendered code layers and pastes them directly onto the Figma canvas as native vector designs. When she edits the resulting frame on canvas by deleting a section, Make immediately detects the structural canvas modifications and offers to write those changes back into code.
---
[40:05](https://www.youtube.com/watch?v=Q3BkuQRBg-w&t=2405s) Shipping to Production via Pull Request and Core Principles
Once the interface looks complete and thoroughly tested, Iris clicks "Create PR." Make automatically bundles the codebase modifications, generates the commit details, and files a pull request to the repository so engineers can perform standard code reviews. Iris hands the presentation over to Elle to summarize the broader philosophy behind these releases. Elle recaps the four guiding principles that shaped both Make and Code layers:
1. **Exploration**: Bringing code onto the canvas preserves the classic iterative workflow, letting creators compare multiple live code implementations side by side.
2. **Open Collaboration**: Replacing delayed pull-request reviews with shared, real-time files where designers and developers inspect code on canvas together.
3. **Scale**: Maintaining synchronized design systems so rapid prototyping never fragments the shared token architecture.
4. **Direct Shipping**: Empowering teams to push finished work directly from design environments to production pipelines.
Elle closes the session by encouraging the audience to scan on-screen QR codes for early access, joking:
> “And as the owner of this wait list, I will make sure to prioritize you all for attending the talk.”
## Notable quotes
> [01:33](https://www.youtube.com/watch?v=Q3BkuQRBg-w&t=93s) We get unprecedented speed with our new AI workflows. We can spin up prototypes quicker than ever, but speed itself isn't a solution. — Iris
> [14:46](https://www.youtube.com/watch?v=Q3BkuQRBg-w&t=886s) AI is really great at building stuff that looks polished, but it's full of holes. — Ben
## Video description
The gap between designing and working in code is closing. Learn how two new launches bring code natively into Figma. Use Make to design in your local codebase, and Code layers to explore right on the canvas. Iterate, prototype, and collaborate in code all the way to production.
____________________________________________________
Find us on ⬇️
X (formerly Twitter): https://x.com/figma
Instagram: https://www.instagram.com/figma
LinkedIn: https://www.linkedin.com/company/figma
TikTok: https://tiktok.com/@figma
Figma forum: https://forum.figma.com/
Figma introduced Code layers and expanded its Make editor to bridge the gap between rapid AI-assisted development and rigorous design craft, bringing live repositories directly onto the visual canvas. The team argued that surface-level AI prototyping often masks product flaws and fragments design systems unless teams can explore divergent branches side by side and synchronize code with design libraries.
The Divergence Risk in AI Prototyping (1:33)
Presenters Iris and Ben cautioned that while generative AI tools allow teams to prompt interfaces into existence with unprecedented speed, raw velocity does not guarantee design quality. Rapid 'vibe coding' often skips messy, divergent problem exploration and masks deep architectural omissions behind polished surfaces. When prototypes are built in isolated IDEs or terminal environments, work frequently drifts away from standardized design systems, forcing designers into redundant labor where code prototypes must be manually rebuilt as static design layers for engineering handoff.
Code Layers for Parallel Canvas Exploration (9:38)
To preserve breadth during early design, Figma introduced Code layers, which import live GitHub repositories onto the canvas as interactive viewports rather than static snippets. Demonstrating this architecture, Nico showed an AI background agent translating vector designs into working code, generating three divergent interaction branches—expressive, subtle, and instant transitions—and modifying them simultaneously with unified prompts. Ben contrasted lightweight prototyping code, which strips backend dependencies to reduce AI token costs and latency, with heavyweight production codebases.
Deterministic Extraction and Spec Reviews (16:11)
Addressing the tendency for happy-path prototypes to ignore edge cases, Ben demonstrated deterministic screen extraction. Stepping through an interactive flow and stopping it instantly extracts every state, transition, and layout variation into static frames across the canvas. Because this extraction mechanism operates deterministically without relying on language models, it consumes zero AI tokens. Laying out runtime states side by side transforms abstract interactive flows into inspectable specifications where cross-functional team members can debate missing requirements, error handling, and authentication steps before shipping.
Visual Control and Direct Code Manipulation (21:39)
When projects advance from open exploration to production refinement, Make functions as a production code editor running against local Git clones. Al demonstrated visual annotation tools that let users click specific UI bounding boxes to guide agent edits, accompanied by automated commits and safe branch creation that avoid command-line friction. For fine-grained adjustments where natural language prompting falls short, Iris highlighted Make's visual editing panel. The panel inspects the local codebase to surface real variables, typography scales, and component properties, allowing designers to manipulate layout and styling directly within design system guardrails.
Bidirectional Sync and Production Handoff (36:54)
To prevent drift between visual assets and codebases, Make leverages an embedded Figma Model Context Protocol (MCP) server for bidirectional synchronization. Iris demonstrated pushing local code refinements back into canonical Figma design libraries, as well as using a 'Copy designs' tool to extract code-first interfaces into editable vector frames that write structural canvas edits back to code. Once verified, changes are packaged into pull requests directly from the interface, preserving standard code reviews while reducing the traditional disconnect between design intent and production implementation.
Figma's presentation frames canvas-native code as a way to unite exploratory ideation with production engineering. However, the workflow relies heavily on teams maintaining structured design tokens, adopting Git-aligned branching, and balancing isolated prototyping sandboxes against complex production constraints.
Source quotes
[1:33] Iris: We get unprecedented speed with our new AI workflows. We can spin up prototypes quicker than ever, but speed itself isn't a solution.
[14:46] Ben: AI is really great at building stuff that looks polished, but it's full of holes.
Original transcript
[0:11] [music]
[0:17] >> What's up, friends? Welcome back to day
[0:19] two of deep dives. I'm Jorja Hess, and
[0:21] I'm on the product team here at Figma.
[0:23] >> And I'm Angel Annunziata, and I'm on the
[0:25] research team here at Figma. Before we
[0:27] begin, just a gentle reminder to please
[0:28] turn your phones on silent if you
[0:30] haven't done so already.
[0:31] >> Also, let yourself be fully present on
[0:33] this stage. We have some amazing friends
[0:35] who are going to come out here and share
[0:36] their hard work with you. All right,
[0:38] housekeeping notes out of the way, let's
[0:40] get into our first deep dive. We've got
[0:42] a great one for you today. We're going
[0:43] to be bringing out the team to talk more
[0:45] about designing with code. So, please
[0:47] help me in welcoming our wonderful team,
[0:49] Iris, Al, Ben, and our infamous red hat
[0:52] guy, Nico.
[1:07] >> [music]
[1:09] >> What's up, Config?
[1:12] Let's go. Let's go. Let's go.
[1:16] Happy day two. It's another foggy day. I
[1:18] hope you brought your
[1:19] layers. Okay, jokes get better when you
[1:21] do them two or three times. My name is
[1:24] Nico.
[1:25] >> I'm Ben.
[1:26] >> I'm Al.
[1:26] >> And I'm Iris.
[1:29] >> Yeah, let's get into it.
[1:33] >> Let's start this deep dive off with some
[1:35] real talk. This is kind of what
[1:37] everyone's been talking about this whole
[1:39] week, but I'll just say it again.
[1:42] We're building some amazing things now
[1:44] with AI. We're able to generate new
[1:46] concepts so quickly. To explain or show
[1:49] a concept, all you have to do is prompt
[1:51] in an AI coding tool like Figma make,
[1:53] and you'll see it come to life. It's
[1:55] great.
[1:57] It's changed our workflows the tools we
[1:59] use to do our work. We have access to
[2:01] code now, which is
[2:04] opened up entirely new ways to express
[2:06] ideas and solutions. But code is rarely
[2:09] enough by itself.
[2:12] We get unprecedented speed with our new
[2:14] AI workflows. We can spin up prototypes
[2:17] quicker than ever, but speed itself
[2:19] isn't a solution. It optimizes the way
[2:22] we work.
[2:24] So, this new landscape presents some new
[2:26] challenges in the design process.
[2:29] With the power of new tools, it can be
[2:31] easy to overlook the exploratory process
[2:33] of design.
[2:35] The solutions we vibe code look polished
[2:37] and convincing, but they may not always
[2:40] match our initial intent.
[2:42] We often don't have time to spend weeks
[2:44] questioning the solution and exploring
[2:46] other options, which means we can skip
[2:47] the work of exploring the space,
[2:49] ideating on different directions, or
[2:52] looking into other better solutions. We
[2:54] still need that time so we can choose
[2:56] the right ideas to build.
[2:58] We also want what we make to look like
[3:00] it comes from within our own system.
[3:03] This ensures our work is durable and
[3:05] even shippable. If every designer is
[3:08] working on their own prototypes in
[3:09] isolation, you can get into a state of
[3:11] divergence. People can make choices that
[3:14] work well for them, but aren't aligned
[3:16] with the rest of the design system.
[3:19] And in an attempt to be as clear as
[3:22] possible in handoff, we usually end up
[3:24] doing more work, manually rebuilding
[3:27] code prototypes in design layers to
[3:29] handoff.
[3:30] We need tools that help us maintain the
[3:32] design guardrails that keep things
[3:34] cohesive.
[3:36] No one wants to feel alone in the design
[3:38] process. We're working alone in these
[3:39] tools for a lot more of our time. We
[3:42] also have fragmentation out there where
[3:45] explorations and artifacts live in
[3:47] different places.
[3:49] That creates barriers to the
[3:51] collaboration that's become such a
[3:52] critical part of the way we work. We
[3:55] need to maintain those human connections
[3:56] throughout the design process. We need
[3:58] the doors to stay open so that others
[4:00] can come in and continue the
[4:02] conversation.
[4:04] All these new AI tools, they make it
[4:06] easy for non-designers to express their
[4:08] ideas. But as designers, we see
[4:10] ourselves getting pushed more and more
[4:12] into engineering tools. We all want to
[4:15] expand our skills, stay relevant, and
[4:17] push the boundaries.
[4:18] Code editors seem like a natural next
[4:21] step for many of us.
[4:23] But some of you may be thinking the IDE
[4:25] is not for me, and that living in a
[4:27] terminal is no way to live.
[4:30] And as much as I love the speed as at
[4:32] which we can work now, I miss being in a
[4:34] canvas
[4:36] where I can duplicate frames and iterate
[4:38] on an idea infinitely,
[4:40] and then bring in team members to help
[4:43] me build on my ideas.
[4:45] Well, we've been really busy. We've been
[4:47] working on a solution for all of the
[4:49] problems I just described.
[4:51] Here's what we'll walk you through
[4:52] today, and we think this is going to
[4:54] empower you to do your best work.
[4:57] Code is now in the Figma canvas with
[4:59] code layers. You don't have to decide
[5:01] between being a coding tool or design
[5:03] tool. You can get both,
[5:05] and the ability to move between them
[5:07] seamlessly,
[5:08] helping you explore multiple divergent
[5:10] ideas side by side in different
[5:11] modalities.
[5:13] But production code can be part of the
[5:15] design process, too,
[5:17] with Make,
[5:19] because Make now works as a production
[5:21] code editor.
[5:23] When prompting isn't enough,
[5:25] we're giving you more precise and visual
[5:27] control in Make to keep your intention
[5:29] intact.
[5:30] Now, I'll hand it off to Ben and Nico to
[5:34] walk through our code layers workflows.
[5:37] >> Thank you. Thank you. Thank you, Iris.
[5:38] >> Thanks.
[5:39] >> [applause]
[5:43] >> Yeah, welcome, everyone. I, yeah,
[5:45] hope, again, you're having an amazing
[5:47] config, and Ben and I are going to talk
[5:49] about the magical feeling of designing
[5:52] with code. We're going to go a little
[5:54] deeper than yesterday. How
[5:57] collaboration on the canvas is so much
[5:59] better than just sharing videos.
[6:01] And when to use code for prototyping
[6:04] versus when to work directly in
[6:06] production.
[6:09] Whose files here look something like
[6:11] this?
[6:13] Come on. Come on. Come on. Come on. I
[6:14] know. I know. I know they do. I know
[6:15] they do. I know they do.
[6:17] I I think this is awesome. The design
[6:19] process is can be so messily beautiful.
[6:22] And because you need to go broad and
[6:25] deep at the same time.
[6:27] And
[6:28] as a design tool,
[6:30] we don't want to make you choose.
[6:33] We're basically just providing a
[6:35] workbench for you to do whatever you
[6:37] want to do in whatever material you need
[6:40] to express your ideas.
[6:43] And coding with agents is quite a linear
[6:46] experience, right? Like you write a
[6:47] single prompt, maybe you write a loop,
[6:49] and you can go incredibly deep, but same
[6:51] as we said yesterday, the workflows
[6:53] around code are isolating and not built
[6:56] for exploration.
[6:58] We're making code a collaboratively
[7:01] explorable material.
[7:03] So, you can figure out where to go
[7:05] together.
[7:07] And it's critical
[7:09] to prototype to understand what you're
[7:11] trying to do.
[7:14] Like famously Gaudi designed the Sagrada
[7:16] Familia that recently
[7:18] opened. I'm not sure if you've seen
[7:19] this, right? But it he designed it
[7:21] upside down in order to capture organic
[7:24] curves that he wouldn't be able to do as
[7:26] he were built was building them up from
[7:28] the ground.
[7:29] And designers
[7:31] have been sharing prototypes, building
[7:34] and sharing prototypes in Figma for
[7:35] years.
[7:37] Like
[7:39] I know. I know, right?
[7:41] Who here Who here has built a prototype
[7:43] that kind of looks like this?
[7:44] >> Woo!
[7:45] I know. I know. I know. So, I'm like
[7:47] partly sorry.
[7:49] Uh like this is what I've worked on for
[7:51] for over 7 years. And like sure, we kind
[7:53] of like made it better over time. And
[7:55] it's And it's it's great. I I I I think
[7:57] there's a lot of value in seeing all of
[7:59] the states side by side, but there's off
[8:01] also just too much visible on the canvas
[8:04] for you. So, you do want to compress it
[8:06] and get more functionality in a denser
[8:08] space.
[8:10] And
[8:11] these prototypes right now often also
[8:13] only feel kind of like this. They feel
[8:15] like you're designing a backpack and
[8:17] you're rebuilding the entire backpack
[8:19] with cardboard.
[8:21] And I think that actually it would be
[8:22] nicer
[8:24] if if it's more like this. I was like
[8:26] thank you for AI-generated images. That
[8:28] actually was really helpful. Um because
[8:30] think about if you're prototyping like a
[8:31] holder for a backpack, right? The only
[8:34] thing you want to do is to attach
[8:36] something
[8:37] to an existing product.
[8:39] And so, you want to take the existing
[8:40] product and then take a knife to it,
[8:42] right? And put some hot glue on it, put
[8:43] some cardboard on it or do something.
[8:45] And then gives you like the feeling like
[8:46] you could imagine me wearing this. It
[8:48] gives you the feeling of like you
[8:49] playing with something real enough so
[8:52] you can evaluate this.
[8:54] And more importantly,
[8:56] it's not just one idea. And this is the
[8:58] beauty of the digital medium over
[9:00] working in the physical medium.
[9:02] Because if I have built a prototype,
[9:05] I can just duplicate this.
[9:07] If I have cut open a backpack, I cannot
[9:10] duplicate the backpack. I have to cut it
[9:12] open again. So, that's why I actually
[9:13] really love the digital medium for
[9:15] creative open-ended exploration. And
[9:18] you only understand how good one idea is
[9:21] by seeing many of them.
[9:23] And this is what we'll hope to for you
[9:26] to do with Code Layers. So, you can
[9:27] explore to your heart's content
[9:30] and start from existing code. So, let's
[9:33] take a look.
[9:38] Okay.
[9:39] So, the first thing that we want to show
[9:41] here is the GitHub import we were
[9:43] talking about yesterday. I heard from a
[9:45] couple of people that like just
[9:46] mentioning it and not kicking it off was
[9:49] like, "Okay, is this working?" Let Let
[9:50] me show you how this works.
[9:52] So, we're here in a Figma file
[9:54] and I can just click on build with code.
[9:56] And if I click on clone repository, I
[9:58] will see a list of repositories that are
[10:01] connected to this account.
[10:03] And so, let's click here and say clone.
[10:06] And just like that, it's in the canvas.
[10:08] And now, as you can see here, the agent
[10:10] is working on cloning this and making it
[10:12] work.
[10:14] And
[10:15] in those moments, code layers, I'm not
[10:18] sure
[10:19] I think they're more like windows into
[10:21] your repository. You can create many
[10:23] different windows. Different people can
[10:25] also look into your repository from
[10:27] different places. This is
[10:29] the beautiful thing about the code not
[10:32] being directly in the canvas,
[10:34] but the repository being visualized in
[10:37] the canvas.
[10:40] We're going to wait for set this up.
[10:42] And let me show you another way to
[10:43] create it.
[10:45] I can Here I have two designs.
[10:47] I'm going to just select both of them
[10:49] and I'm going to use the agent entry
[10:51] point here on the right.
[10:53] I'm going to say build this with code.
[10:56] And so, we're sending off a prompt.
[10:58] Build an interactive Build interactive
[11:01] code from code layer from this design.
[11:03] And the cool thing about this is that
[11:05] agent will now analyze what is on the
[11:06] design
[11:08] and will actually create a code layer
[11:10] and then send both of those
[11:12] both of those Figma design layers
[11:15] and a specific prompt into it.
[11:18] So, we're going to let this run,
[11:20] but you can see here that this is
[11:21] something that like I've created, of
[11:23] course, before. I will get to the other
[11:24] one when it's when it's done. But you
[11:26] can see, okay, it did some it did some
[11:28] things. Okay, it's not like
[11:30] funny yet.
[11:31] I don't want to be like
[11:34] >> [laughter]
[11:35] >> You know, you you get me? Okay.
[11:37] Let's try out a couple things here. I
[11:39] think one of the thing, let me just copy
[11:41] this prompt cuz no one wants to see me
[11:42] typing. The other thing I can do with
[11:45] agent is that I can just do with them
[11:48] paste this in here and it's saying
[11:49] create three variations of what happens
[11:52] after the slider has been dragged.
[11:54] An expressive one, right? An animated
[11:57] one or a very basic one. So, let's do
[12:00] this.
[12:01] And now
[12:02] that the agent looks into the code
[12:04] essentially and decides what to do.
[12:07] And it will duplicate this code layer
[12:09] creating separate branches of your code
[12:11] base putting them side by side and
[12:13] sending individual prompts to each
[12:15] making it much faster for you to explore
[12:18] the solution space ahead of you.
[12:21] This too
[12:22] we prepared down here.
[12:25] I'll I'll I'll get back to some of them.
[12:27] Let's play them all and like see what's
[12:28] happening. See if it got the like swoosh
[12:30] effect correct.
[12:32] And let me just oh hide the UI.
[12:38] Show and hide UI. I'll get this back
[12:39] later. All right.
[12:41] And now we can see here.
[12:43] Oh, let's see. Hey, that was like the
[12:46] little confetti. That's a little swoosh.
[12:48] I think this one is a little slower.
[12:51] Yeah, okay. Some little more subtle.
[12:53] I think this one was the instant one.
[12:55] Yeah, this is the instant one. I do
[12:57] really like the
[13:00] Should we do it again? Okay, one more
[13:01] time.
[13:03] >> [laughter]
[13:06] >> Okay. Okay. Okay. The the next thing too
[13:08] is like so we've shown that like you can
[13:09] create code from designs through the
[13:12] agent. You can create multiple code
[13:14] layers also through the agent and you
[13:17] can operate on multiple code layers at
[13:19] once through one agent as well. So, for
[13:22] example here you can see that like as
[13:24] I'm navigating between them. Okay, I'm
[13:25] going to do it one more time.
[13:26] As I'm having between them, they're kind
[13:28] of like jumping around a little bit. And
[13:30] so, one thing I want to do is that for
[13:32] all of them, I want to say
[13:36] What what do I want to say? I want to
[13:37] say that the bottom dragging handle
[13:41] thingy
[13:43] I actually don't know what it's called
[13:44] should stay at the same position.
[13:48] Right?
[13:49] Between the first and the unlock state.
[13:53] So, now I'm going to send this off.
[13:56] And so, now the agent again analyzing
[13:59] what's what what I've asked and will
[14:00] send individual prompts to each code
[14:03] layer.
[14:04] I just to show the UI again.
[14:07] Cool.
[14:08] Let's go over here and let's get check
[14:09] out. We see that the
[14:11] GitHub
[14:12] codebase is actually imported. So, the
[14:14] cool thing now is I can just play with
[14:16] this. That's kind of nice. I'm playing
[14:17] with this.
[14:18] Um and there's a lot more that you can
[14:21] do.
[14:26] I will There's a lot more that you can
[14:27] do that we'll see with Iris
[14:29] and Alice well within the code layer.
[14:32] So, definitely stay tuned. There's some
[14:33] cool updates there. But
[14:35] great ideas are never made alone. So,
[14:38] Ben is going to show you how we can take
[14:40] this even further.
[14:46] >> Wow. Thank you so much, Nico.
[14:48] >> [applause]
[14:51] >> As an engineering manager, I'm always so
[14:53] impressed by what designers are able to
[14:55] create in Figma. And I'm so excited to
[14:57] see what all of you create with code
[14:59] layers.
[15:01] But I think I might be even more excited
[15:03] to see all the ideas that didn't end up
[15:05] making it.
[15:08] Because design is not just about the
[15:11] happy path. If you've worked with
[15:13] engineers, you maybe have experienced
[15:15] how annoyingly good we can be at
[15:16] pointing out, well, what about this edge
[15:18] case? Or oh, actually that's going to be
[15:19] kind kind hard, but maybe this other way
[15:21] will be easier.
[15:23] AI is really great at building stuff
[15:24] that looks polished, but it's full of
[15:26] holes. And that kind of feedback is so
[15:28] important to get early on.
[15:29] The canvas makes it really easy to show
[15:32] your thought process and visualize the
[15:34] trade-off between multiple solutions.
[15:37] Consider what it looks like today to
[15:39] share a prototype. You maybe post a
[15:41] message in Slack, you get some links.
[15:44] Uh maybe you get a few emoji reactions,
[15:45] but it's really hard to manage that
[15:47] feedback and make decisions.
[15:50] A canvas lets you see and keep track of
[15:53] all of your ideas in one place.
[15:56] And better yet, anyone on your team can
[15:58] directly prompt a change and pick up
[15:59] where you left off.
[16:02] So, let's jump into a demo to show you
[16:04] how some of the collaborative parts of
[16:07] Code Layers work.
[16:11] So, we switch over to the demo here.
[16:13] Great.
[16:14] Uh I have here three prototypes that my
[16:17] designer sent me.
[16:18] And uh you know, it's kind of hard to
[16:21] tell what the difference is between
[16:23] them.
[16:24] So, what if Let's just restart these.
[16:27] What if I go here and could One second.
[16:33] I'll wait for this little tooltip to go
[16:34] away.
[16:37] There we go.
[16:38] Uh what if I could just click through
[16:39] the application
[16:43] and just walk through it like I normally
[16:44] would? And this is a prototype, so we're
[16:46] just going to go through it.
[16:49] And there we go. I'm going to hit stop.
[16:51] And there, we've extracted all the
[16:53] screens, which make it really, really
[16:55] easy for anyone to look at everything
[16:57] that's going on this application. And
[16:58] the best part is there's no AI here.
[17:01] It's a deterministic, free, and fast.
[17:04] I'm going to do another one here.
[17:08] Well, all right. Let's do the bottom one
[17:10] first. We'll come back to the middle
[17:11] one.
[17:13] And maybe you can spot what some of the
[17:16] differences are.
[17:21] All right. I'm going to stop. There we
[17:23] go. All the screens are extracted. We'll
[17:26] do the middle one.
[17:29] If it will cooperate with me.
[17:31] There we go.
[17:33] All right.
[17:35] >> [snorts]
[17:35] >> I'm going to click through these pretty
[17:36] quick.
[17:40] Great.
[17:41] I'm going to stop.
[17:42] So, did you notice what the differences
[17:44] are?
[17:45] Well, in this version we had the verify
[17:47] email step up in the middle.
[17:49] And later we moved it on to the end cuz
[17:50] why get in the way of your onboarding?
[17:53] And here we've added a couple
[17:55] um single sign-on options.
[17:57] And [snorts] change the card view uh so
[18:00] you can
[18:01] you know, maybe compare if you want to
[18:02] go through cards or more of a grid view.
[18:04] And if I'm an engineer here and I'm
[18:06] looking at this, I can look at things
[18:08] like, well, you know, should we have a
[18:11] password field?
[18:13] Or I can look over here and say, well,
[18:16] what happens if I type the wrong
[18:19] code?
[18:20] These sort of discussions are much
[18:22] easier to have in a static spec-like
[18:25] format because the canvas is not just
[18:27] for doing your own work, it's for
[18:29] presenting it and bringing your team in.
[18:33] Let me for a moment put on my growth PM
[18:36] hat. So,
[18:37] let's say Nico end up sharing this
[18:39] version with me.
[18:40] And yeah, okay, it's a little bit more
[18:42] dialed back, but it feels pretty good.
[18:44] But I really, really want people to
[18:47] click on this button. Uh
[18:50] my
[18:51] bonus is going to depend on the
[18:52] click-through rate here. So, I can just
[18:54] easily say
[18:56] copy that layer and say, make the button
[19:00] shimmer.
[19:01] I'm going to let that go in the
[19:02] background.
[19:03] Uh here's two examples that I created on
[19:05] the side.
[19:06] And here you can see this one is
[19:07] shimmering the little button over here.
[19:09] Whereas this one is shimmering the whole
[19:10] slider.
[19:12] And both of these, you know,
[19:14] share the same commonality as the ones I
[19:16] copied.
[19:18] If I don't think that's enough, I'm
[19:19] going in here, maybe make the the the
[19:21] item bounce, or play with the uh
[19:25] finished effect.
[19:27] So,
[19:28] everything we kind of showed here with
[19:29] code layers,
[19:31] they're kind of simple. Maybe you're
[19:32] wondering like,
[19:34] what's like a real product? What what's
[19:36] something a little bit more complicated?
[19:38] Uh what about Figma design?
[19:41] So, I have here uh a canvas, and I can
[19:43] move elements around, you know, I can
[19:45] interact with the uh elements panel. I
[19:47] could even go in here and uh change the
[19:50] color. I mean, that's not great
[19:51] contrast, but you get the idea.
[19:54] Um but if I, let's say, wanted to work
[19:57] with my agent to build a new feature,
[19:59] like uh something where I can
[20:02] connect my components with my code.
[20:04] Well, all right, I'm going to go ahead
[20:05] and boot up the terminal, and then I'm
[20:07] going to start up my dev server. No, I'm
[20:09] just kidding. This is a code layer. Just
[20:11] like all these other code layers, you
[20:13] can run all of these side by side. These
[20:16] are working interactive code layers that
[20:19] don't require you to spin up a dev box,
[20:22] or understand how to use Git, or open up
[20:24] a terminal. It's just easy to go ahead
[20:27] and copy
[20:28] and prompt.
[20:32] So,
[20:33] um I want to go back to the slides now.
[20:39] And I'll talk a little bit more about
[20:40] why we took this approach.
[20:42] So,
[20:43] production [clears throat] code really
[20:44] requires you
[20:46] to bring in a lot of stuff you don't
[20:48] really need for prototyping.
[20:50] Uh yeah, you want the screens, you want
[20:52] components, you want realistic-looking
[20:54] data,
[20:55] but you don't actually need a back end.
[20:56] You don't want to care about deployment.
[21:00] Many [snorts] companies, including
[21:01] Figma, have been building prototyping
[21:03] playgrounds. And these can be built with
[21:05] your real front-end components,
[21:06] but they're free from all the baggage
[21:08] that you don't need. And a huge
[21:10] advantage of this is that LLMs can work
[21:12] so much faster on these code bases,
[21:14] saving you both time and tokens.
[21:19] The way you design with code will
[21:20] ultimately depend on your use cases.
[21:22] When you're doing exploration,
[21:24] prototyping code lets you test ideas
[21:25] quickly and get feedback from your team.
[21:28] When doing implementation,
[21:31] working directly on production code lets
[21:32] you deploy changes faster and nail all
[21:35] of the UI details yourself.
[21:37] I've been incredibly impressed with all
[21:39] the designers who've been using AI
[21:40] lately
[21:41] to ship major changes directly to
[21:43] production.
[21:45] They're able to add a level of craft
[21:47] that takes a product from good to great.
[21:49] So, I'm going to hand it over to Al and
[21:52] Iris to talk to us about how to use make
[21:54] with your production code.
[21:57] >> [applause]
[22:04] >> Thank you, Ben.
[22:05] So, now we're going to dig into what
[22:07] happens when you have direction and what
[22:09] it means to build on production code.
[22:13] We'll cover how you can ideate within
[22:15] the constraints of production, design on
[22:17] production code directly in a Figma
[22:20] native way, share seamlessly with your
[22:22] colleagues, and leverage design systems
[22:25] to build things correctly, not
[22:27] approximated.
[22:30] But, as Ben mentioned, sometimes a
[22:32] prototype playground meets your design
[22:34] needs. But, there's also times when
[22:37] you're at the last leg of a project.
[22:39] You're thinking about refining, where
[22:41] the small details are often the ones
[22:43] that get left behind. And that's when
[22:45] working on production makes a lot of
[22:47] sense.
[22:49] This is a time when we want to start
[22:51] from reality, work within realistic
[22:53] constraints, so that we can test actual
[22:56] behavior, and ultimately get the power
[22:58] to ship with confidence.
[23:02] So, let me set the scene for our demo.
[23:04] Let's say I'm a product manager. I'm
[23:07] working for a company called Offtrail,
[23:10] and Offtrail is an outdoor meetup
[23:11] platform.
[23:13] This helps people discover outdoor
[23:15] activities in their area, meet
[23:17] like-minded people to do outdoor
[23:19] activities with, and hang out and enjoy
[23:21] their community. But,
[23:24] we need to make some money. So, we're
[23:26] partnering with a bunch of sports brands
[23:28] to deliver some brand sponsors events.
[23:32] We're going to pilot this out with two
[23:33] different customers, Cadence and Drift.
[23:36] We're going to meet Chad in a moment.
[23:38] Chad is the CEO of Cadence. I just got
[23:41] off a pretty stressful call with him, so
[23:43] I'm just going to play back what he had
[23:45] to say.
[23:47] Hey Chad, thanks so much for your time.
[23:49] I heard you had some feedback about
[23:50] Offtrail's website, so I've pulled it up
[23:52] and I'm hoping to hear what you have to
[23:53] say.
[23:54] >> Yeah, for sure. We're super excited to
[23:56] be sponsoring some of the events on
[23:58] Offtrail's, but it wasn't obvious to me
[24:01] that these were Cadence sponsored
[24:02] events, and we really want the attendees
[24:04] to know that they're coming to one of
[24:05] our events. Is that something you guys
[24:07] can work on?
[24:08] >> Uh okay, got it. Yep, I can take this
[24:11] back to the team.
[24:12] >> Perfect, thank you.
[24:14] >> Cool, bye.
[24:18] Great. So, it wasn't actually that
[24:20] stressful, but in the moment when you're
[24:21] talking to a CEO, it can feel a little
[24:23] intense. Um what I'm going to do is use
[24:27] our new tools in Make.
[24:29] So, for those of you who aren't familiar
[24:32] with running Make on your local code,
[24:34] the nice thing is we have access to the
[24:36] entire production code base. We did this
[24:39] by cloning the repository through our
[24:41] connected GitHub account, and saving
[24:43] that code directly on my computer.
[24:47] This enables me to prototype and build
[24:49] directly on production code, meaning
[24:51] that the code that is produced will
[24:53] reflect the patterns of my code base,
[24:55] and it will feel safe to make changes
[24:57] cuz it's all local to my machine. In
[25:00] this case, I'm about to leverage the
[25:02] context of the code base to map out and
[25:04] understand the product. So, moving to
[25:07] our demo,
[25:12] I have our website pulled up here.
[25:15] It's fully interactive. It's what our
[25:16] product our website looks like. Here is
[25:19] one of the events that Cadence is
[25:21] sponsoring, the Canyon Crew Meetup. And
[25:23] I have asked the agent to
[25:26] basically map out our website so that I
[25:28] can understand all of the different
[25:30] interaction points where maybe we want
[25:31] to highlight a sponsorship. Um and here
[25:34] I can go and navigate to that FigJam
[25:37] that was created.
[25:39] So, we have a FigJam here.
[25:42] Uh you can see the different web pages.
[25:44] So, we have the event detail page, the
[25:45] profile page, the map page, and then
[25:48] finally the homepage. I'm thinking that
[25:51] we'll focus on the featured event card
[25:53] cuz that's the one on the homepage that
[25:54] everyone's going to see, and I have a
[25:56] feeling that Chad might give us a little
[25:57] more money if I put him right in the
[26:00] front and center. So, navigating back to
[26:03] my website,
[26:04] I have it loaded here, and the first
[26:07] thing that I'm going to do is
[26:10] create a prompt. Uh sorry, create a
[26:13] branch. And the reason why I'm going to
[26:15] do that is so that my work is completely
[26:17] protected and I'm able to ideate without
[26:19] being worried about being that one
[26:21] product manager who brought down prod.
[26:23] So, let's get started. Creating L's
[26:26] sponsor.
[26:28] And
[26:30] and I am going to check that out. You'll
[26:33] notice that I'm checking out the latest
[26:34] from main, meaning if there were any
[26:36] code changes created and added to the
[26:38] repository since I last used it, I'll
[26:40] have access to all of that information
[26:41] and data. And you'll see I'm now on that
[26:44] branch.
[26:47] And the first thing I'm going to do is
[26:48] use our new annotation tool. And I'm
[26:51] thinking that a good place to put this
[26:53] sponsored badge is on this image right
[26:55] here. So, I'm just going to leave a
[26:56] comment and say to the agent,
[26:58] "Add a badge
[27:02] saying 'sponsored'."
[27:06] And I will pass that off to the agent to
[27:08] get to work.
[27:12] I'm going to go back to the slides just
[27:13] for a little bit while the agent is
[27:15] doing its job.
[27:17] So, I want to briefly just touch on some
[27:19] things that we're thinking about to make
[27:21] it so that we can work with agents, but
[27:24] do a little less prompting.
[27:28] For me, I really like annotating.
[27:30] Annotating is a more visual way to
[27:32] prompt and give context. Sometimes, I
[27:34] find it pretty tricky to guide an agent
[27:37] to make the exact change that I'm trying
[27:38] to make. But using annotations, I can
[27:41] point exactly at what I want and hand it
[27:43] over to the agent. No more really
[27:45] annoying long prompts where I have to
[27:47] write, "Make a change in the top right
[27:48] on that image that looks like this, and
[27:50] make sure you get it right, and don't
[27:52] change anything else."
[27:54] I can just point, type the prompt, and
[27:56] send it over to the agent.
[27:58] And you hear that ding, it means it's
[28:00] done with its work. Uh
[28:02] we also know that Git workflows might be
[28:05] a new way of working for many of you.
[28:08] Uh especially if you've never worked in
[28:09] a code base before. So, we have spent a
[28:11] lot of time getting to know our users
[28:14] and making sure that we design this in a
[28:16] way that felt very intuitive to get
[28:18] started. Because we want to make sure
[28:19] that we're giving you the power of
[28:21] source control workflows, and then also
[28:24] make sure that you're starting to learn
[28:25] about the benefits. So, that when you do
[28:26] contribute to code, you're doing it in a
[28:28] safe way.
[28:31] For example, similar to in Figma design,
[28:34] branching is a way to work without ever
[28:36] having to worry about anyone else. Using
[28:38] branches, we've made it easy to check
[28:40] out other people's work. Maybe you could
[28:42] just paste a link or use the drop down
[28:43] to switch and see what they're up to.
[28:46] We've also know that when you're using
[28:49] Sigma, one of the greatest benefits it
[28:51] brought 10 years ago to me at least was
[28:53] it saved for me. So, you don't have to
[28:55] worry about saving. And we brought that
[28:57] benefit directly into make by auto
[29:00] committing the changes after each
[29:01] prompt. So, you don't have to worry
[29:03] about whether your work is saved. It
[29:05] just is.
[29:06] You'll be able to go back to previous
[29:08] commits, revert them, just like version
[29:10] history in a Figma file.
[29:12] Switching back over to our demo, since
[29:14] we know that our agent did what it was
[29:16] supposed to,
[29:18] you can see over here a really tiny
[29:21] sponsored badge got added.
[29:23] I don't feel very good about that. I
[29:26] Again, I'm trying to impress Chad, show
[29:27] him that we're doing a lot of good work
[29:29] here. So, I'm just going to leave one
[29:30] more comment to the agent and just
[29:32] mention,
[29:33] make this a little
[29:36] bigger and bolder.
[29:40] I'm going to pass that off to the agent.
[29:42] And as I mentioned, the nice thing about
[29:43] annotations is if you look at this nice
[29:46] little shimmer effect, we know the agent
[29:49] is working on the right thing. And it
[29:51] helps me at least have confidence that
[29:53] it's not going to go mess up the whole
[29:54] code base at least. And that ding is my
[29:58] evidence that it did what it was
[30:00] supposed to.
[30:02] Okay, it looks a little bigger. Not as
[30:04] big as I wanted it. That's okay. I feel
[30:07] pretty good about what I've done so far.
[30:09] So, I'm going to hand this over to Iris,
[30:11] my designer, to let her see the work
[30:14] that I've done so far.
[30:16] Much like sharing in Figma, there's a
[30:18] share button. Uh and what's nice is
[30:21] I have an easy way to push my changes so
[30:23] that everyone can have access to the
[30:25] code if they want to check out the work
[30:26] that I'm working on.
[30:29] Just making the push. I will add Iris.
[30:34] Invite her to my file.
[30:36] And now over to you, Iris.
[30:39] >> Great. So, L shared her branch with me.
[30:43] This is super helpful because nothing
[30:45] gets lost in translation. I can see
[30:48] exactly what where her head's at.
[30:55] Okay, so
[30:59] whoops, sorry.
[31:01] Okay, let's pretend this is the branch I
[31:03] opened.
[31:04] What is this? A badge for ants?
[31:08] I think Chad's going to want more of his
[31:11] branding here. So,
[31:14] let's explore that for him.
[31:16] Um
[31:18] So, here's the diagram that L made
[31:20] earlier using that MCP tool. And it's
[31:24] great because do you ever get a moment
[31:26] where you're wondering is this actually
[31:28] implemented? You have to go into the
[31:30] app, you have to create a test user, you
[31:32] get lost, and you don't find the right
[31:34] state. Well, design files, they can now
[31:37] represent more of what's in production.
[31:39] A lot of this time I have to do this
[31:40] manual work to find out, but with this
[31:43] diagram, I can quickly understand all
[31:45] the surfaces where this badge needs to
[31:47] show up and it's visibility into
[31:49] production code that I never had before,
[31:51] and I'm going to make sure that the
[31:53] design solution I come up with covers
[31:54] everything.
[31:56] And so, L helpfully
[31:58] uh tagged some of these as P0.
[32:01] And I have a couple sponsored badges
[32:04] here that I was playing around with.
[32:09] Because I didn't really know what I
[32:10] wanted yet.
[32:12] But I knew I didn't want what L gave me,
[32:14] so I drafted up a few ideas for badges
[32:16] in the design file here. Sometimes you
[32:19] want to work with a blank canvas and not
[32:20] be constrained to prompting for changes.
[32:23] And I also explored what they could look
[32:25] like in the page.
[32:28] So, let's use make to test out how it
[32:30] looks in the app.
[32:34] I'm going going the link to this.
[32:38] I'm going to go back
[32:39] to make.
[32:42] I'm going to select
[32:45] this area that I know I want it to be
[32:47] in, and I'm just going to prompt
[32:50] add this sponsored badge
[32:53] according
[32:54] to
[32:55] my Figma design.
[33:02] And then all I have to do is apply those
[33:05] changes.
[33:09] So, while that's happening, let's switch
[33:11] back to some slides.
[33:15] The beautiful thing about make is that
[33:16] the Figma MCP server is built directly
[33:18] into make, which means you don't have to
[33:20] set it up manually. It'll just work. And
[33:22] it has all the benefits of the MCP
[33:24] server you've been using with your AI
[33:26] coding tools already.
[33:28] All the same tools are available,
[33:30] including the ones that helped L go from
[33:32] code to design.
[33:35] And there are tools that help keep your
[33:37] design system connected between design
[33:39] and code as well.
[33:44] So, I already
[33:47] did this
[33:48] with the magic of AI. I already did
[33:50] this. I
[33:53] noticed that the agent
[33:55] built it for me. It looks pretty good.
[33:56] It's really close to what I had
[33:58] designed, but it's not quite perfect.
[34:01] But, do you see this here? Are you
[34:03] noticing something here? Something kind
[34:06] of cool on this right side. Um all I
[34:10] have to do
[34:11] to make this
[34:12] more to my spec is
[34:14] move things around. You see that that
[34:16] data? I can just like drag and drop it
[34:17] AND IT'S THERE.
[34:20] >> [applause]
[34:23] >> AND YEAH, MAYBE MAYBE SOME OF THE COLORS
[34:25] weren't quite right. Maybe you know, the
[34:27] alignment of this isn't right. I
[34:29] All I have to do
[34:31] is use the tool here
[34:33] to fix it.
[34:35] This really helps me get fine-grained
[34:37] control over the result and it feels
[34:41] more native to me to be able to do it
[34:43] this way than having to prompt to do it
[34:44] this way.
[34:47] So, there's also something super cool
[34:49] about this design panel that I'm about
[34:52] to show you. Remember how I said that
[34:54] design systems in this new workflow,
[34:57] it's hard? Well, we have a solve for
[34:59] that.
[35:01] Let's say I click on this and I think
[35:04] our friend Chad might want his company's
[35:07] name to be a bit bigger, don't you?
[35:09] >> Yeah, I mean, I'd like more money for
[35:10] sure.
[35:11] >> Yeah. Okay, well, wait, what Wait,
[35:14] what's this?
[35:15] What's What's this? What is this?
[35:19] Oh my god, what is that? Um if I click
[35:22] on that,
[35:24] my variables are there.
[35:27] So,
[35:29] >> [applause]
[35:31] >> I can also change the color here
[35:34] and use the variables
[35:36] there as well.
[35:38] You might be asking yourself, well, how
[35:40] does Make know about my variables?
[35:43] Let me explain how we have this and I'm
[35:45] going to switch back to the slide.
[35:51] Make can detect your components and
[35:53] automatically generate the right
[35:54] properties for them so you can edit them
[35:56] in the editor.
[35:57] So, you'll see in the slide that there's
[35:59] this little button called generate
[36:01] properties at the bottom of this
[36:02] component section of the edit panel.
[36:05] We do the same thing with variables from
[36:07] your code base. The same way we detect
[36:09] component properties, we can also detect
[36:11] variables and show you the ones that are
[36:13] relevant for the element you've
[36:14] selected.
[36:15] You'll be able to choose from color and
[36:17] spacing variables from your code base as
[36:20] well as your text styles.
[36:25] So, let's actually select a component so
[36:27] you can see this in action.
[36:29] I'm going to select this big register
[36:32] button here.
[36:34] And I can play around with the
[36:36] properties of that. I can add that icon.
[36:38] I can change the size.
[36:40] And I can do all of that without
[36:42] prompting, and I can see it in real
[36:44] time.
[36:46] >> [applause]
[36:50] >> So,
[36:54] sometimes you get
[36:56] really far down the path of prompting,
[37:00] and maybe your design system
[37:04] has diverged
[37:06] a bit. Like,
[37:08] you went to town
[37:10] on a component here.
[37:12] Like, look, I I
[37:14] got the logo to show up. I I got it
[37:17] centered in here, but, you know, my
[37:18] design system component in my design
[37:22] library file hasn't been updated. Well,
[37:27] all I have to do to make that happen, to
[37:29] keep my design system in Figma in sync
[37:32] with code,
[37:34] is prompt the agent.
[37:36] I can ask, "Can you update the sponsored
[37:40] badge component in the Offtrail design
[37:44] library to reflect the changes I made
[37:47] here?"
[37:51] And
[37:52] I could do that.
[37:55] But,
[37:58] this is the result.
[38:01] So, what's great about being able to
[38:03] update the Figma design library is that
[38:06] my team members can also benefit from
[38:08] the updates I make in code, and
[38:10] potentially they can use it in their
[38:11] design files, as well.
[38:22] So,
[38:23] let's say I get really deep.
[38:27] It's It's been a while since this um
[38:29] feature's been launched, and
[38:33] we did something for Chad that we
[38:36] thought would be really nice for him. We
[38:38] created an event detail page just for
[38:41] his brand.
[38:43] Um
[38:44] but
[38:46] we created this entirely through
[38:47] prompting, which means there isn't a
[38:49] Figma design for it.
[38:55] So, here's this page. Lists all of
[38:57] Cadence's events that they've sponsored.
[39:00] Let's say I wanted to make some changes
[39:01] to it, or I wanted to
[39:04] have my team take a look at this and and
[39:06] help give me some better ideas, or maybe
[39:09] explore entirely an entirely new way to
[39:12] design this page.
[39:14] Well, there is this tool here called
[39:16] copy designs.
[39:18] So, if I click on that,
[39:21] I can send the design layers
[39:24] back to the canvas.
[39:26] >> Yes!
[39:26] >> Right there.
[39:28] >> [applause]
[39:32] >> So,
[39:34] if I made some changes to this, let's
[39:36] say we just got rid of that section
[39:37] there,
[39:45] if I can see my UI,
[39:50] you can see that we detect the changes
[39:52] you've made,
[39:54] and we can send those back to make to
[39:55] implement them.
[39:58] >> [applause]
[40:05] >> But, let's say I'm happy with this as it
[40:07] is.
[40:10] To get this implemented, I just have to
[40:11] click create PR,
[40:14] and that's
[40:16] going to create a pull request to the
[40:17] repository so that my engineers
[40:20] can review my code.
[40:23] And all the details
[40:24] are ready to go.
[40:26] And all I have to do
[40:28] is hit create pull request.
[40:30] >> [applause]
[40:33] >> So, that's how you use make to ship
[40:35] changes directly to production. And I'll
[40:37] hand it back to Elle to close THIS OUT.
[40:41] >> [applause]
[40:46] >> THANK YOU, IRIS. SUPER EXCITING. I love
[40:48] all the design systems integrations,
[40:50] especially as a non-designer. That way,
[40:53] I know I'm not messing things up when
[40:54] I'm, you know, ideating.
[40:59] So, we wanted to share some of our
[41:00] guiding principles in building these
[41:02] solutions. Remember when we talked about
[41:04] exploration from the opening?
[41:07] By bringing code closer to design, we
[41:10] now have the access to the same
[41:12] iterative design process that you've
[41:15] been used to for many years, by having
[41:17] multiple solutions on the canvas.
[41:20] We also know that collaboration is at
[41:23] the heart of design. And it's important
[41:26] that every design medium that we build
[41:28] is collaborative.
[41:30] Instead of waiting to share your work
[41:32] through a pull request, you're actually
[41:34] able to work in the open by easily
[41:36] sharing files or playing together with
[41:38] code on the canvas in real time.
[41:42] You're also now able to work
[41:44] collaboratively at scale by using design
[41:47] systems that are in sync with the code
[41:48] that you're working on.
[41:51] And finally, shipping ties it all
[41:53] together. Now, within Figma, you have
[41:55] the tools available to ship your
[41:57] changes.
[41:59] You can use make directly to push those
[42:01] changes back to production.
[42:04] And ultimately, we're doing all of this
[42:06] for you so you can push the envelope and
[42:09] take ideas further than ever before.
[42:12] If you're interested in trying either of
[42:14] the products that we talked about today,
[42:16] you can follow these QR codes, and as
[42:19] the owner of this wait list, I will make
[42:21] sure to prioritize you all for attending
[42:23] the talk. So, thank you.
[42:27] >> [applause]
[42:32] [applause]