Figma Links Design Platform to AI Agents via MCP to Curb Code Bloat

Figma deep dive: Agentic workflows and the MCP | Config 2026 — Figma

Figma

Relying on vague AI prompts triggers cognitive surrender and technical debt, meaning developers must feed agents structured design context to generate leaner code.

AI-assisted summary of Figma deep dive: Agentic workflows and the MCP | Config 2026 — original source. Check the original for full context.

Source published:

Key ideas

  • Figma's Model Context Protocol (MCP) server and Code Connect pipeline dramatically reduce AI token sprawl by injecting production component mappings, yielding leaner generated code with less AI overhead compared to raw canvas dumps. (12:05)
  • The widespread risk of 'cognitive surrender' leads practitioners to uncritically accept automated visual polish as quality, obscuring unstated constraints and producing high-maintenance technical debt. (0:16)
  • Figma is introducing 'hyper tokens' based on the Design Tokens Community Group (DTCG) specification to bundle multi-property design decisions across typography, elevation, layout, and motion into unified semantic units. (14:22)
  • Using FigJam as an MCP-connected agentic canvas allows teams to structure human intent, review agent execution plans on sticky notes, and preserve workflow state across LLM context window boundaries. (23:03)

Detailed notes

## Background Published by Figma on YouTube on June 26, 2026, this Config 2026 deep-dive presentation explores how Figma's platform can be leveraged to work efficiently with autonomous agents using the Model Context Protocol (MCP). According to the description, the session focuses on how upfront clarity and rich design context enable practitioners to employ AI with intentionality rather than falling into superficial automation.

## TL;DR Addressing widespread industry anxiety around generative AI, the talk warns against 'cognitive surrender'—the passive acceptance of statistical average outputs driven by surface-level polish. Jake demonstrates how structured design artifacts, such as design tokens, Code Connect snippets, and emerging 'hyper tokens,' drastically compress context to help coding agents write leaner, more maintainable software. He showcases FigJam as a collaborative visual workspace and orchestration hub where autonomous agents coordinate tasks, maintain persistent memory across context windows, and compile their own skill definitions via MCP. Finally, the framework is proven through Stegasound, an interactive case study transforming an eight-and-a-half-year audio steganography project into a live production website in a single evening.

## Atmosphere & style The presentation strikes a compelling balance between rigorous technical systems engineering and deeply candid, humble introspection. Delivering slides hand-drawn with the Figma Slides pencil tool, Jake shares his own vulnerabilities about burning tokens and losing conviction, grounding dizzying multi-agent workflows with relatable analogies like ordering cheese sandwiches. Watching the session feels like witnessing an authentic creative breakthrough that deflates generative AI hype, culminating in an impassioned, philosophical plea to preserve human intentionality at the core of software craft.

## Bulletin - [12:05](https://www.youtube.com/watch?v=D5WUW9X_-L0&t=725s) Figma's Model Context Protocol (MCP) server and Code Connect pipeline dramatically reduce AI token sprawl by injecting production component mappings, yielding leaner generated code with less AI overhead compared to raw canvas dumps. - [00:16](https://www.youtube.com/watch?v=D5WUW9X_-L0&t=16s) The widespread risk of 'cognitive surrender' leads practitioners to uncritically accept automated visual polish as quality, obscuring unstated constraints and producing high-maintenance technical debt. - [14:22](https://www.youtube.com/watch?v=D5WUW9X_-L0&t=862s) Figma is introducing 'hyper tokens' based on the Design Tokens Community Group (DTCG) specification to bundle multi-property design decisions across typography, elevation, layout, and motion into unified semantic units. - [23:03](https://www.youtube.com/watch?v=D5WUW9X_-L0&t=1383s) Using FigJam as an MCP-connected agentic canvas allows teams to structure human intent, review agent execution plans on sticky notes, and preserve workflow state across LLM context window boundaries.

## Key takeaways - [03:29](https://www.youtube.com/watch?v=D5WUW9X_-L0&t=209s) AI tools accelerate raw execution rather than clarity; without explicit, upfront constraints, models default to statistical averages that lead to high-maintenance dead ends. - [00:16](https://www.youtube.com/watch?v=D5WUW9X_-L0&t=16s) Cognitive surrender happens when practitioners uncritically adopt an LLM's output as their own judgment, shedding the rigorous work of validating details and edge cases. - [07:12](https://www.youtube.com/watch?v=D5WUW9X_-L0&t=432s) Design is an exacting specification rather than merely a visual preview, serving as a compressed language to translate convergent intent into shippable production code. - [09:07](https://www.youtube.com/watch?v=D5WUW9X_-L0&t=547s) Dumping raw visual styling from canvas components into an agent's context window creates cognitive noise equivalent to receiving an encyclopedia when ordering a sandwich. - [12:05](https://www.youtube.com/watch?v=D5WUW9X_-L0&t=725s) Supplying precise Code Connect snippets to agents triggers a compounding efficiency: agents write a higher share of the required implementation while producing substantially less total code. - [12:05](https://www.youtube.com/watch?v=D5WUW9X_-L0&t=725s) The Code Connect template API is framework-agnostic and supports slots rendering, allowing teams to map dynamic, nested components across any frontend library. - [14:22](https://www.youtube.com/watch?v=D5WUW9X_-L0&t=862s) Hyper tokens bridge the gap between low-level style variables and full components by bundling related design choices into single named abstractions for models to reference. - [14:22](https://www.youtube.com/watch?v=D5WUW9X_-L0&t=862s) A format-agnostic, DTCG-based JSON schema can act as a deterministic single source of truth for compiling design tokens, CSS layers, Svelte components, and Code Connect bindings. - [18:26](https://www.youtube.com/watch?v=D5WUW9X_-L0&t=1106s) Manually editing agentic Markdown skill files creates brittle, unreadable code diffs; teams should maintain a human-curated source of truth and delegate only the compilation step to models. - [20:45](https://www.youtube.com/watch?v=D5WUW9X_-L0&t=1245s) Mapping agent onboarding and skill documentation onto a visual FigJam canvas forces human clarity and provides structured references, anti-patterns, and edge cases for agents. - [20:45](https://www.youtube.com/watch?v=D5WUW9X_-L0&t=1245s) Agents can self-correct and validate domain competence by completing 'homework' tasks and checking their generated Code Connect templates against an answer key before committing files. - [23:03](https://www.youtube.com/watch?v=D5WUW9X_-L0&t=1383s) FigJam can serve as an interactive agentic interface where coordinator agents decompose monolithic prompts into visible sticky-note plans for human review before execution. - [25:56](https://www.youtube.com/watch?v=D5WUW9X_-L0&t=1556s) Providing raw library source code alongside visual assets directly to design agents significantly improves visual design accuracy by grounding models in technical mechanics. - [28:44](https://www.youtube.com/watch?v=D5WUW9X_-L0&t=1724s) Figma Make prototypes allow agents to extract behavioral mechanics, animation timing, and interactive logic without forcing direct code translation across incompatible tech stacks. - [28:44](https://www.youtube.com/watch?v=D5WUW9X_-L0&t=1724s) Context window degradation during prolonged agent sessions can be mitigated by having outgoing agents summarize state, architectural decisions, and next steps back into FigJam for subsequent agents. - [28:44](https://www.youtube.com/watch?v=D5WUW9X_-L0&t=1724s) Human intent and consideration are the defining factors that give software meaning; automated systems cannot substitute for creative discernment and conviction.

## Detailed walkthrough ### [00:16](https://www.youtube.com/watch?v=D5WUW9X_-L0&t=16s) Good Things Take Time and the Trap of Cognitive Surrender

The session opens with an exploration of why design context matters when dealing with modern AI tooling—ranging from design systems and Figma's Model Context Protocol (MCP) server to Code Connect, Figma Make, and FigJam. While tools and models are advancing rapidly, meaningful design thinking remains constrained by the constant daily pressure to move faster and produce more. Reflecting on past talks about uncertainty, the speaker notes how much has evolved: Figma launched its MCP server to pass rich context from Figma Design, Make, and FigJam into LLMs, connected that MCP server to the Plugin API to allow agents to write directly back into Figma and FigJam, and introduced Figma's native design agent straight onto the canvas.

Despite having the power to produce more artifacts than ever, foundational uncertainty lingers across the discipline. Designers grapple with anxiety over whether they need to learn command-line interfaces (CLIs) or integrated development environments (IDEs), whether they can afford bleeding-edge model subscriptions, or if they have simply been reduced to "command line spinner designers." This anxiety feeds directly into a psychological vulnerability known as cognitive surrender. Cognitive surrender occurs whenever human practitioners uncritically adopt an LLM's automated output as their own judgment, shedding the hard work of validating details, interrogating edge cases, or defining a distinct point of view.

The speaker shares personal vulnerabilities, admitting to succumbing to cognitive surrender both in day-to-day Figma work and in personal creative practice. In fact, while drafting this very presentation, the speaker spent days down unproductive rabbit holes, burning tokens and waiting for models to magically bestow clarity and conviction about the talk's message, before realizing the thesis had to come from within. A complete pivot of the presentation was required just one week prior.

> “Cognitive surrender is when we adopt an LLM's judgment as our own.”

[03:29](https://www.youtube.com/watch?v=D5WUW9X_-L0&t=209s) Polish vs. Consideration: The Seduction of Average Outputs

The core paradox of AI tools is that while they dramatically accelerate raw execution, they do not inherently provide clarity—and often directly obfuscate it. A designer might approach a prompt box armed only with a cocktail napkin sketch and a dream, typing something as superficial as: *"Computer, make this good."* When the model returns a pristine, highly styled UI, the designer instinctively assumes quality. The design community has spent decades conditioned to equate high visual polish with deep human consideration, because historically, reaching high fidelity required wrestling with dozens of structural trade-offs, constraints, and problem parameters.

Today, automated polish serves as an illusion. Unless an LLM is fed thorough, intentional context, it creates outputs derived strictly from statistical averages, devoid of the unstated constraints unique to the problem. Surface-level polish seduces teams into diverging down an unintended path simply because the artifact looks finished.

```mermaid flowchart TD accTitle: Polish vs Consideration Flow accDescr: Diagram contrasting unconsidered AI generation resulting in cognitive surrender against upfront structured intent.

subgraph LowIntent["Low-Intent / Vibe Workflow"] A["Vague Prompt\n('Make this good')"] --> B["Statistical Average Output"] B --> C["Seductive Surface Polish"] C --> D["Cognitive Surrender\n& High Maintenance"] end

subgraph HighIntent["High-Intent / Consideration Workflow"] E["Upfront Design & Intent"] --> F["Structured Design Context\n(Tokens, Components, Specs)"] F --> G["Agentic Execution via MCP"] G --> H["Maintainable Production Reality"] end ```

To demonstrate the effort required to steer generation, the speaker presents an initial queue-generation experiment, showing that an iterative, highly descriptive text prompt produced far superior results compared to an image-reference prompt. This phenomenon mirrors findings across the broader software development lifecycle. Citing a recent Google white paper on agentic coding, the speaker highlights that low-investment "vibe coding" causes immense friction in long-term maintenance and hits an absolute dead end when applied to complex systems. The alternative path is upfront platform design: investing early in structured APIs, deterministic constraints, and explicit agentic context.

> “AI accelerates execution, not clarity.”

> “Low investment vibe coding leads to high friction for long-term maintenance and a dead end for complex systems.”

> “Not having clarity upfront is at best multiplication by zero.”

[07:12](https://www.youtube.com/watch?v=D5WUW9X_-L0&t=432s) The Three Phases of Design and the Spec-Driven Approach

In software, shipping the wrong thing has always been far more dangerous and expensive than the engineering effort required to write code; rollbacks and damaged user trust carry astronomical costs. To ensure teams ship the right thing, work typically progresses through three core stages: 1. **What could exist:** Divergent exploration maximizing creative possibilities. 2. **What should exist:** Convergent alignment where teams refine intent, define exact constraints, and establish what they intend to make real. 3. **What does exist:** Downstream engineering execution bringing the specification into shipping production code.

```mermaid flowchart LR accTitle: The Design Evolution Pipeline accDescr: A three-stage progression of design thinking from divergent possibilities to convergent intent to production reality.

A["What Could Exist\n(Divergent Thinking)"] --> B["What Should Exist\n(Convergent Intent & Spec)"] B --> C["What Does Exist\n(Production Execution)"] ```

While design systems and LLMs can interact with every phase of this pipeline, the critical friction point lies in translating "what should exist" into "what does exist." Re-framing design through the lens of spec-driven development transforms the designer's output from a mere visual preview into an exacting specification. Design systems operate as a precise, compressed language that packs maximum intent into minimal surface area.

> “If we're honest, the hardest part has always been shipping the right thing.”

> “Design is so much more than a preview. It's a specification.”

[09:07](https://www.youtube.com/watch?v=D5WUW9X_-L0&t=547s) The Shape of Design Context: From Raw Values to Code Connect

To illustrate how context shape dictates LLM performance, the speaker deconstructs a basic design system button across multiple levels of abstraction: - **Raw styling values:** A verbose list of exact hex codes, padding pixels, and radii. - **Design tokens:** Although carrying a slightly larger payload than raw literals, tokens capture semantic relationships across multiple modes (such as encapsulating both light and dark modes simultaneously in half the descriptive space). - **Reusable component definitions:** A single component call encapsulating states like focus rings and complex interactive behaviors in a concise string.

Moving to production-level code, real-world components rarely mirror simple static designs. A production button might bind its label dynamically from a data layer rather than rendering hardcoded text like `"Hello World"`, and it will require custom click event handlers absent from canvas frames. In Figma, Code Connect allows teams to inject production component definitions directly into the MCP pipeline. Rather than forcing an LLM to guess implementations, Code Connect templates compile precise code snippets that provide literal strings to help the model infer semantic purpose while stubbing out functional event handlers to remind the model that operational logic must still be completed.

The limitations of default representations become glaringly obvious on complex UI patterns such as dynamic data tables utilizing slots. By default, Figma's MCP server serializes canvas components into raw React and Tailwind markup capturing every minute stylistic nuance. For a table component with dynamic currency formatters and data-layer rows, this default export generates an overwhelming wall of code—so massive the speaker had to reduce the presentation font size to 7pt just to display it. Most of that visual code is irrelevant noise when mapping to an established production codebase (like Svelte components backed by data formatters). Dumping all raw visual styling into an agent's context window is equivalent to ordering a cheese sandwich and receiving multi-volume encyclopedias detailing the agriculture of wheat, the biochemical history of cheese, and the physics of vertical stacking: by the time the agent finishes processing the irrelevant information, the window of utility has vanished.

[12:05](https://www.youtube.com/watch?v=D5WUW9X_-L0&t=725s) Code Connect and the Magic of Lean Code

Using a plain analogy of assembling a sandwich—slice of bread, slice of cheese, slice of bread—the speaker illustrates how straightforwardly Figma's Code Connect can describe a complex UI element like a table component. In a displayed Svelte code snippet from Code Connect, static Figma table rows are cleanly represented as a structured data array alongside precise definitions for the header columns. The snippet indicates exactly which component implementation to import from the codebase and how incoming design data should map into its properties.

This level of precision fundamentally alters how AI agents write software. When teams feed agents loose, verbose design context, agents may generate a high volume of raw code, but human developers must intervene substantially to make it shippable. Conversely, feeding an agent precise Code Connect snippets triggers an unexpected, compounding efficiency: the agent writes a much higher percentage of the total required implementation, yet the total volume of code produced drops dramatically. The speaker emphasizes this breakthrough: “There's less total code. At times so little that AI is used less to get to a better outcome. This is what we would call leaner code and lower AI usage. We're doing more with less.” The bloated difference generated under vague context is simply technical debt.

```mermaid flowchart TD accTitle: Impact of Context Precision on Agent Code Generation accDescr: Comparison showing how verbose context yields bloated code and high human effort, whereas precise context yields leaner code and less AI usage.

subgraph VerboseContext["Verbose Design Context"] A1["Unstructured Figma Data"] --> B1["Agent Generates Large Codebase"] B1 --> C1["High Tech Debt & Heavy Manual Fixes"] end

subgraph PreciseContext["Precise Context (Code Connect)"] A2["Structured Snippets & Mappings"] --> B2["Agent Writes Targeted Code"] B2 --> C2["Leaner Code, Less AI Usage & Faster Ship"] end ```

- Accurate Code Connect snippets define explicit imports, data arrays, and component property bindings directly tied to Figma components. - Precise context keeps models affordable and reliable by minimizing the inference overhead and reducing token sprawl. - A newly released Code Connect template API is completely framework-agnostic, enabling documentation across any frontend library or custom stack. - The Code Connect API now supports slots rendering, extending code mapping to highly dynamic, nested components. - Figma has shipped dedicated Model Context Protocol (MCP) tools for publishing Code Connect definitions and inspecting design libraries, alongside an agentic Code Connect skill.

---

[14:22](https://www.youtube.com/watch?v=D5WUW9X_-L0&t=862s) Bridging the Abstraction Gap: Hyper Tokens

Design abstraction extends far beyond isolated component instances into layout, typography, surface effects, and motion. Looking at the tiers of design context, an overlooked gap exists right between low-level raw tokens and full component instances: the layer of semantic style fragments. Without this middle abstraction, developers and language models are forced to repeatedly assemble individual design properties line-by-line—an approach the speaker humorously compares to navigating an “encyclopedia of cheese” via sprawling inline styles or lengthy utility class strings like Tailwind.

To solve this, Figma is developing “hyper tokens,” a modernized evolution of a time-tested pattern already visible in Figma Text Styles. A single text style packages font family, weight, line height, letter spacing, and size into one named reference that cleanly mirrors a CSS declaration block. Applying hyper tokens across shapes, surface elevations, responsive layouts, transformations, and motion allows multi-property design decisions to be referenced as a unified semantic unit. As the speaker explains: “Agents love reliable and clear abstraction. Hyper tokens can be leveraged to apply this idea we see here with Text Styles to everything.”

- Hyper tokens encapsulate groups of related design decisions into single named tokens, drastically cutting the inference burden on LLMs. - The concept addresses the entire visual spectrum: shape, layout, typography, surface effects, transforms, and temporal transitions. - A strongly typed, format-agnostic JSON schema authored around the Design Tokens Community Group (DTCG) specification provides the single source of truth for both basic tokens and hyper token recipe structures. - From this master schema, Figma deterministically compiles native Text Styles (bound to aliased variables with code syntax attached), component libraries, icon sets, base CSS layers, presentation layers (such as Svelte), and Code Connect bindings. - Downstream in Storybook, hyper tokens serve as an architectural index, allowing teams to inspect shared style fragment recipes across disparate elements—from simple buttons to complex tables, date pickers, and data charts. - The speaker invites attendees to a design systems meetup in the community lounge at 3:30 with TJ Petri to discuss these explorations and help shape the open tooling.

---

[18:26](https://www.youtube.com/watch?v=D5WUW9X_-L0&t=1106s) Managing Agent Skills without Cognitive Surrender

While skills represent one of the most powerful mechanisms for deploying human expertise to AI agents, maintaining those skills presents serious friction. Agent skills frequently amass thousands of lines of dense Markdown instructions. When humans try to manually adjust these files after an agent touches them, version control turns into a nightmare: “Editing agentic markdown output is kind of like editing minified code. The code diffs are a blend of arbitrary wording in agentic and human voices kind of smashed together.”

Faced with messy diffs, teams often suffer from “cognitive surrender”—blindly letting the agent edit its own instruction manuals. While this relieves immediate friction, it yields decision-making authority to models that lack broader product context. The superior architecture involves maintaining a human-curated contextual source of truth and delegating only the compilation and transformation step to agents. Furthermore, because different agent architectures harbor unique context windows, prompting biases, and operational requirements, a single centralized source can be compiled into multiple specialized skills tailored for each specific agent target.

```mermaid flowchart LR accTitle: Single Source of Truth to Multi-Agent Skills Architecture accDescr: Human expertise captured in a structured source is transformed by agents into tailored skills for distinct downstream models.

subgraph Input["Human Source"] A["Curated Source of Truth<br/>(Visual / FigJam / Schema)"] end

subgraph Transformation["Agentic Compilation"] B["Transformation Agent"] end

subgraph Outputs["Targeted Skills"] C1["Agent A Skill<br/>(Optimized Prompts)"] C2["Agent B Skill<br/>(Specialized Tooling)"] end

A --> B B --> C1 B --> C2 ```

- Skills do not replace human craft; their true function is to package and deploy human domain expertise directly into agent runtime loops. - Avoid manual edits on agent-generated Markdown files to prevent conflicting human/model voice collisions and unreadable code diffs. - Maintaining an upstream source of truth allows teams to programmatically compile specialized skill bundles configured to the quirks and biases of individual agent frameworks.

---

[20:45](https://www.youtube.com/watch?v=D5WUW9X_-L0&t=1245s) FigJam as the Living Canvas for Agent Onboarding and Skills

To eliminate the opacity of monolithic text files, the speaker moved the Code Connect skill—previously an unwieldy wall of Markdown—directly onto a visual FigJam canvas. Laying out concepts visually forces the creator to clarify instructions, structure, and intent: “I realized that when I codify my expertise on a canvas, because I'm much more aware of what I'm asking an LLM to do, it improves the clarity of the context that I provide.” The canvas acts as a shared visual medium where human reasoning is clearly mapped out so agents can reliably compile their own downstream skills.

The FigJam canvas is organized into distinct functional zones. An onboarding area informs the agent of its exact mission: ingest the board's contents and author a Code Connect skill inside the project's codebase. The main canvas body provides comprehensive reference material, containing step-by-step implementation guides, quick-reference sheets, common rules, anti-patterns, edge-case examples, and deep API documentation designed to be queried as external references on demand.

To validate comprehension before any code is permanently written to the repository, the canvas introduces an automated “homework assignment”: - The agent is assigned three test components, which it fetches out of Figma over the Model Context Protocol (MCP). - Following the guidelines on the canvas, the agent authors the corresponding Code Connect definitions and posts its work back onto the FigJam board. - The agent then fetches a hidden “answer key” containing reference Code Connect templates, evaluates its work against the baseline, and self-corrects its reasoning before generating the final production skill.

[23:03](https://www.youtube.com/watch?v=D5WUW9X_-L0&t=1383s) FigJam as an Agentic Interface and Contextual Canvas

The primary goal of having AI agents write Code Connect documentation is not expecting them to write flawless code on the first attempt, but rather allowing them to experience what inputs and context are actually required to produce high-quality Code Connect docs. By inspecting the delta between their initial draft and an ideal reference document, agents can learn from the exercise and write their own tailored version of that skill directly into the codebase. Jake explains that this completely changes how development skills are maintained: “The beauty here is that we can have the agents regenerate these skills whenever we want.” Whether an underlying model changes, best practices for structuring skills evolve, or specific technical requirements shift, teams retain a single collaborative source of truth inside FigJam that both humans and autonomous agents can read, update, and translate for their own consumption.

Having all this rich context laid out spatially on a canvas inspired a radical workflow shift: leveraging FigJam itself as an interactive agentic interface via the Model Context Protocol (MCP). Instead of juggling fragmented terminal windows or separate dashboards, Jake set up an orchestration loop where an external agent reads a dedicated prompt section in FigJam, executes design updates inside Figma, modifies local codebase files, and subsequently posts the visual and architectural results back onto the canvas. Because this was completely uncharted territory for autonomous agents, Jake built an extensive onboarding section directly into the FigJam document. While Figma's standard `use Figma` and `use FigJam` skills expose the underlying Plugin API, Jake provided highly specific, local code blocks showing the agent exactly how to refit FigJam sections and how to place embedded images at predetermined aspect ratios. Providing these concrete snippets kept the agent from having to infer canvas layout preferences, preventing custom formatting rules from polluting global skill definitions.

```mermaid flowchart TD accTitle: FigJam Agentic Interface Loop accDescr: Diagram showing how an agent reads tasks from FigJam, executes work in Figma and codebase, and writes progress back to FigJam. subgraph Canvas["FigJam Context Window"] direction TB Prompt["Prompt Section & Onboarding Rules"] Plans["Sub-Agent Task Breakdown"] Artifacts["Results: Screenshots & Status"] end subgraph Execution["Agentic Execution"] direction TB Agent["Coordinator Agent"] FigmaWork["Figma Design & Tokens"] CodeWork["Codebase Implementation (Svelte)"] end Prompt -->|"Reads task & schemas"| Agent Agent -->|"Decomposes task"| Plans Plans -->|"Dispatches sub-agents"| FigmaWork Plans -->|"Dispatches sub-agents"| CodeWork FigmaWork -->|"Posts visual diffs"| Artifacts CodeWork -->|"Reports back status"| Artifacts ```

To test the system on a complex task, Jake tasked the agent with building the data table and pie chart components shown earlier across both Figma and his codebase simultaneously. He instructed the agent to follow a deterministic schema compilation approach, deriving both design system elements and code components from a single source of truth powered by hyper tokens. After Jake embedded an example of the target Svelte component code and linked the task description, the coordinator agent immediately decomposed the massive prompt into smaller, discrete implementation plans for specialized sub-agents. It wrote these plans directly into FigJam sticky notes for human inspection. Jake was able to review and correct the game plan right on the canvas before sending the sub-agents off to work. As Jake noted while preparing his presentation, this setup completely changed his workflow: he could focus entirely on rehearsing his conference talk while passively watching the FigJam board populate with finished work in the corner of his eye.

- Code Connect documentation skills can be dynamically regenerated whenever LLM models, conventions, or guidelines change. - Specific onboarding scripts in FigJam (such as canvas bounding-box refitting and image aspect ratio calculations) reduce agent inference overhead without bloating global system prompts. - Sub-agents break monolithic specifications down into discrete visual plans inside FigJam, allowing human oversight and intervention before code is committed.

---

[25:56](https://www.youtube.com/watch?v=D5WUW9X_-L0&t=1556s) Speedrunning Imagination to Reality: The Stegasound Project

Jake grounded these architectural ideas in a tangible, deeply personal demonstration: taking an eight-and-a-half-year personal project from raw concept to a fully realized production website in a single evening using Figma’s platform. For nearly a decade, Jake has developed an experimental library called Stegaset, which encodes raw audio waveforms directly into visual pixels inside still images so the pictures themselves can be decoded and played aloud as sound. To prove it works, Jake played back an audio recording encoded entirely within an image right from the stage: “What's up, Config? It's Jake from the past and right now you're listening to audio that's been encoded into an image. That's right, no audio files. We're just listening to an image right now and isn't that something?” The project, dubbed Stegasound, pairs audio from meaningful live music performance videos with still frames extracted from those same shows, capturing personal memories through creative code.

```mermaid flowchart LR accTitle: Stegasound Fast-Track Pipeline accDescr: Pipeline showing how raw code algorithms and design agents flowed through FigJam and MCP into production code. subgraph Input["Context & Algorithms"] Algorithm["Stegaset Encoding Library (Source Code)"] Frames["Live Performance Stills"] end subgraph DesignPhase["Design & Systemization"] FigmaAgent["Figma First Draft (Visual Layout)"] FigJamPlanning["FigJam Human Context Window (Hyper Tokens)"] SysAgent["Coding Agent via MCP (Design System & Diffs)"] end subgraph BuildPhase["Animation & Production"] Makes["Figma Make (Interactive Algorithmic Prototypes)"] Production["Vanilla JS + Decoders (stegasound.jake.fun)"] end Algorithm --> FigmaAgent Frames --> FigmaAgent FigmaAgent --> FigJamPlanning FigJamPlanning --> SysAgent SysAgent --> Makes Algorithm --> Makes Makes --> Production ```

To build a modern interactive portfolio explaining this algorithm, Jake initiated a Figma design agent session. Rather than providing only vague aesthetic directions, he supplied both a frame of raw Stegasound imagery and the actual JavaScript source code of the underlying steganographic encoding library. Providing the raw algorithmic code enabled the design agent to grasp the technical mechanisms immediately, yielding an unexpectedly sophisticated visual draft. Once the draft was in place, Jake transitioned into FigJam to orchestrate his coding agent, which would simultaneously manipulate the Figma file and the local code directory via MCP while using FigJam as its communication hub.

Jake treated the FigJam board as a physical expansion of his own cognitive workspace, curating inputs to establish a high consideration imperative before triggering execution: “My intentions became much clearer as I tended to my human context window, throwing stickies together, bringing links and images and code examples into the FigJam as inputs.” The coding agent retrieved the visual design from Figma using MCP, analyzed it against hyper token concepts and modular style fragments, and proposed a structured design system plan for elements like typography. Jake refined the proposal on the canvas, then commanded the agent to apply those tokens across both Figma and the local repository. The agent systematically updated the design file and pasted visual before-and-after screenshot comparisons straight onto the FigJam canvas for Jake to review.

- Stegaset encodes acoustic waveforms directly into image pixel values, removing the need for separate MP3 or WAV audio assets. - Providing raw library source code directly to Figma’s design agents significantly improves visual alignment by giving the model deep domain context about how the underlying software functions. - The coding agent conducted programmatic design-token extraction across Figma layers via MCP, refactoring the design file and presenting before-and-after visual diffs directly inside FigJam.

---

[28:44](https://www.youtube.com/watch?v=D5WUW9X_-L0&t=1724s) Translating Figma Make Prototypes and the Consideration Imperative

To design the complex interactive visualizations that explain how pixel-based audio encoding works under the hood, Jake jumped into Figma Make. He built three separate animated prototypes inside Make, once again supplying the underlying mathematical encoding algorithms so the visualizations would represent the data processing accurately. A fundamental technical constraint surfaced during code conversion: Figma Make runs on React, but Jake’s production website was authored entirely in vanilla JavaScript. Because of this architectural mismatch, the agent was not tasked with copying raw component code, but rather with interpreting the behavioral patterns, timing, and visual mechanics discovered during the Make explorations and translating them into lightweight vanilla JavaScript implementations.

As the agentic session grew lengthy, Jake avoided context window degradation by asking the active agent to summarize its technical progress, architectural decisions, and next steps back onto the FigJam canvas. A fresh agent was spun up immediately after, reading the FigJam log to pick up exactly where the prior agent left off, extracting the Figma Make logic, and implementing the full interactive playground in the codebase. The live result at `stegasound.jake.fun` features an interactive waveform playground where clicking any image executes the client-side decoder: the blue pixel layer visually disappears in sync with the audio playback, revealing that the blue data points being erased are the exact sound waves traveling to the speakers.

Beyond shipping a complex technical website in a single evening, Jake emphasized that the most valuable artifact was having a complete, audit-ready record of the process: “I have a FigJam with all of my process and the steps I took to get to this outcome.” This visual archive can be ingested by future agents to jump-start future tasks or kept for human reflection.

Closing the presentation, Jake reflected on the personal discipline required to work with generative tools. To reinforce the importance of human intentionality, he deliberately drew every single illustration, letter, and arrow in his presentation slides by hand using the pencil tool in Figma Slides, intentionally stepping outside his comfort zone to give a technical AI keynote a human signature. He issued an impassioned warning against delegating creative discernment to automated systems:

> “Consideration is the most important part in all of this. Don't be fooled into giving that up. It's the only reason any of this matters. Your intent is the only thing that's going to make working with AI make any sense.”

- Agent context limits were overcome by having expiring agent sessions serialize their state, architectural decisions, and task lists back into FigJam for new agents to consume. - Figma Make prototypes served as functional conceptual references, enabling agents to translate React-based interactive behaviors into performant vanilla JavaScript. - The live demonstration is hosted at `stegasound.jake.fun`, rendering active pixel decoding in real time as sound waves play back. - Jake hand-drew every slide element with the Figma Slides pencil tool to model the core philosophy that human intent and care must remain at the center of AI-assisted design and development.

## Notable quotes > [03:29](https://www.youtube.com/watch?v=D5WUW9X_-L0&t=209s) AI accelerates execution, not clarity.

> [03:29](https://www.youtube.com/watch?v=D5WUW9X_-L0&t=209s) Low investment vibe coding leads to high friction for long-term maintenance and a dead end for complex systems.

> [00:16](https://www.youtube.com/watch?v=D5WUW9X_-L0&t=16s) Cognitive surrender is when we adopt an LLM's judgment as our own.

> [03:29](https://www.youtube.com/watch?v=D5WUW9X_-L0&t=209s) Not having clarity upfront is at best multiplication by zero.

> [07:12](https://www.youtube.com/watch?v=D5WUW9X_-L0&t=432s) Design is so much more than a preview. It's a specification.

> [28:44](https://www.youtube.com/watch?v=D5WUW9X_-L0&t=1724s) Your intent is the only thing that's going to make working with AI make any sense. — Jake

> [07:12](https://www.youtube.com/watch?v=D5WUW9X_-L0&t=432s) If we're honest, the hardest part has always been shipping the right thing.

> [18:26](https://www.youtube.com/watch?v=D5WUW9X_-L0&t=1106s) Editing agentic markdown output is kind of like editing minified code.

## Mentioned Figma, Model Context Protocol, Code Connect, Figma Make, FigJam, Figma Slides, Google, React, Tailwind, Svelte, Design Tokens Community Group, Storybook, TJ Petri, Jake, Stegaset, Stegasound

## Video description Clarity at the front of a process makes agentic workflows successful, and design context can help you use AI with intentionality. In this talk we'll dive into how Figma's entire platform can be leveraged to work with agents efficiently. ____________________________________________________

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/

[Source](https://www.youtube.com/watch?v=D5WUW9X_-L0)

Reading summary

At Figma's Config 2026, speaker Jake argued that while AI accelerates execution, it cannot generate clarity, warning practitioners against "cognitive surrender"—the uncritical adoption of automated model outputs. He advocated for a spec-driven development model where high-consideration human intent is structured into deterministic design systems, Code Connect snippets, and visual canvases via the Model Context Protocol (MCP). The Trap of Cognitive Surrender and Seductive Polish (0:16) Designers face mounting pressure to produce artifacts rapidly, which often induces anxiety and leads to cognitive surrender: uncritically accepting an LLM's automated output rather than evaluating edge cases and trade-offs. The design field historically equated visual polish with deep structural consideration. However, automated polish masks the absence of thought, yielding statistical averages that miss unstated problem constraints. Spec-Driven Development and Precision Context (7:12) In software, shipping the wrong product remains far more expensive than writing code. Transitioning from divergent exploration ("what could exist") to convergent alignment ("what should exist") requires treating design as an exacting specification rather than a cosmetic preview. Injecting precise context drastically alters agentic code output. Hyper Tokens and Style Fragment Abstraction (14:22) Between basic primitive tokens and full component instances lies an abstraction gap of semantic style fragments. Without intermediate abstractions, models must redundantly reassemble styling rules line-by-line. In response, Figma is developing "hyper tokens"—an evolution of Figma Text Styles applied across shapes, surfaces, responsive layouts, transforms, and motion. FigJam as a Contextual Interface for Agents (18:26) Maintaining agent skills through monolithic Markdown instruction files leads to unreadable code diffs when human and machine edits mix. The speaker moved agent skill definitions directly onto visual FigJam boards to clarify intent and allow agents to evaluate their work against baseline "answer keys" over MCP before authoring repository skills. Translating Prototypes into Production via Stegasound (25:56) Jake validated this workflow by shipping Stegasound, an interactive website based on an eight-and-a-half-year steganography project that plays audio encoded directly into image pixels. By feeding the underlying algorithmic JavaScript into Figma's design agent and orchestrating tasks through FigJam, a coding agent extracted tokens, updated Figma layers, and showed visual diffs on canvas. Generative tooling accelerates execution, but delegating discernment risks accumulating bloated code and brittle architectures. Maintaining a human-curated single source of truth across visual and schema layers ensures AI models serve as efficient compilers of explicit human intent rather than arbiters of product judgment.

Source quotes

[3:29] AI accelerates execution, not clarity. [3:29] Low investment vibe coding leads to high friction for long-term maintenance and a dead end for complex systems. [0:16] Cognitive surrender is when we adopt an LLM's judgment as our own. [3:29] Not having clarity upfront is at best multiplication by zero. [7:12] Design is so much more than a preview. It's a specification. [28:44] Jake: Your intent is the only thing that's going to make working with AI make any sense. [7:12] If we're honest, the hardest part has always been shipping the right thing. [18:26] Editing agentic markdown output is kind of like editing minified code.

Original transcript

[0:16] How's it going everyone? [0:19] Doing good? [0:22] Today we're going to be talking about [0:23] the importance of good design context. [0:26] We're going to see this across design [0:27] systems, Figma's MCP server and design [0:30] agent, code connect, make, and even [0:34] FigJam. [0:36] It's a lot to cram into 30 minutes, but [0:38] before we dive in, let's align on why [0:40] any of this is worthwhile. [0:43] Good things take time. [0:46] It's something that we all know and [0:48] something that we've all experienced. [0:50] Finding enough time to meaningfully [0:52] consider our work is challenging. [0:56] Everyday we feel the pressure to move [0:59] faster and to create more. [1:02] This gets in the way of meaningful [1:04] design thinking. [1:06] And it also creates a lot of room for [1:08] uncertainty. [1:10] Last year I stood, I don't know, right [1:14] here [1:15] and we talked about uncertainty. [1:18] And things were moving fast then [1:20] and since then a lot has happened. [1:23] We launched our MCP server, providing [1:25] LLMs with context from Figma design, [1:28] make, and FigJam. It was a huge step in [1:31] improving many of the workflows that [1:33] we're going to be talking about today. [1:36] Earlier this year we combined our MCP [1:38] server with the plugin API, allowing [1:41] teams to write to Figma and FigJam. [1:44] And now, yes. [1:48] And now Figma's design agent is also on [1:50] the canvas. [1:51] These tools enable us to produce more [1:54] than we ever have before. [1:56] And yet, [1:58] that uncertainty hasn't really gone [2:00] anywhere. [2:02] We ask ourselves, do I need to learn how [2:05] to use a IDE or a CLI? [2:08] Can I afford the latest model? [2:11] Or am I just a command line spinner [2:14] designer now? [2:16] Nowhere is uncertainty more evident than [2:20] in the notion of cognitive surrender. [2:23] Cognitive surrender is when we adopt an [2:25] LLM's judgment as our own. [2:29] This relieves ourselves of the burden of [2:31] validation, and often the work required [2:34] for a distinct point of view. [2:36] And this isn't just theory. [2:38] In both my work at Figma and in my [2:41] personal creative practice, I found [2:43] myself falling into cognitive surrender [2:46] more often than I would have expected. [2:48] Even in preparing this talk, I went down [2:50] the wrong path, wasting a ton of tokens, [2:54] and a ton of time waiting for LLMs to [2:57] give me clarity and conviction about [2:59] today's content, [3:01] instead of just looking to myself. [3:04] I pivoted this talk last week, and [3:07] couldn't be more excited about it. [3:09] But if I care so much about this [3:10] material, why did I surrender my [3:13] consideration so easily? [3:16] Perhaps I'm worried that my ideas are [3:18] just not good enough. [3:21] Maybe I'm afraid to fall behind. [3:25] Or maybe [3:26] I just want to fit in. [3:29] AI has got us letting go of the very [3:32] thing that we're responsible for. [3:35] And that's a shame because AI [3:36] accelerates execution, not clarity. [3:40] If anything, AI can get in the way of [3:42] clarity. [3:43] Here's an example. [3:45] We sit down at a prompt box with the [3:47] back of a napkin and a dream, [3:50] and after much consideration, we start [3:52] the design process. [3:54] Computer, [3:56] make this [4:00] good. And then we send it off, and after [4:03] the computer does what we want, we're [4:06] left with something polished. [4:10] And we've been trained to trust polish. [4:13] We recognize it as a sign of [4:15] consideration. [4:16] In the past, the process of polish was a [4:18] natural quality filter for ideas. [4:22] You couldn't get to this level of [4:23] fidelity without making decisions about [4:26] the factors that surround the problem. [4:30] Now, unless you're providing this [4:31] context to an LLM, it can't possibly [4:33] make a similar decision. This outcome is [4:36] built on averages and is absence absent [4:39] of the things that we have yet to [4:40] consider. [4:42] When we surrender our consideration, we [4:44] get polish on the surface, but something [4:47] far less meaningful under the hood. [4:50] Clarified intent at the front of the [4:52] process is what ultimately makes that [4:54] difference. [4:56] The biggest risk of polish is that it [4:59] will take us off an ideal path. [5:02] Polish can seduce us into a different [5:05] direction, offering a more complete [5:07] output. [5:08] But that output might be very different [5:10] than if we had spent any time with our [5:13] ideas. [5:15] Now, staying on top of our intent [5:17] requires effort. This is my first [5:20] attempt at generating that queue. [5:22] You can't improve your process if you [5:25] don't start with a target and take the [5:27] time to work toward it. [5:30] Here, I learned that a more descriptive [5:31] prompt got to a better outcome than [5:34] including an image reference. [5:37] Warts and all. [5:39] Now, this tension is not exclusive to [5:41] product design. [5:43] The entire software development life [5:45] cycle is experiencing the same growing [5:47] pains. This recent white paper from [5:50] Google describes the impact of intent in [5:53] agentic coding. [5:54] It states that low investment vibe [5:57] coding leads to high friction for [5:59] long-term maintenance and a dead end for [6:02] complex systems. [6:04] What's the alternative? [6:07] Upfront platform design. [6:09] Invest in APIs, deterministic layers, [6:12] and structured agentic context. [6:15] Driving clarity upfront is a higher [6:18] expenditure, but pays dividends as you [6:21] create maintainable software. [6:24] So, what does this mean for design? [6:26] Well, we often talk about 100Xing our [6:28] workflow. [6:29] So, what are you 100Xing? [6:33] Not having clarity upfront is at best [6:35] multiplication by zero. [6:38] You have to start with intent. [6:41] But, prioritizing that intent requires [6:44] effort. [6:46] So, what if we embraced a consideration [6:50] imperative? [6:51] Prioritizing clarified intent at the [6:54] front end of our process could combat [6:56] that pull toward cognitive surrender. [7:00] Today, we're going to be talking about [7:01] how to make intent become reality. [7:04] So, that we can feel confident in [7:07] investing in consideration. [7:09] Let's dive in. [7:12] We like to talk about the effort [7:13] required to ship the right code. [7:15] But, if we're honest, the hardest part [7:17] has always been shipping the right [7:19] thing. [7:21] Shipping the wrong thing is the biggest [7:23] threat in design. [7:25] Rolling back a feature, making the wrong [7:27] impression with your users can be very [7:29] costly. [7:30] This makes the effort and the time [7:32] working toward the right thing well [7:34] worth the investment. [7:36] So, how do you get to the right thing? [7:38] Well, it starts by pursuing what could [7:40] exist. Here, we maximize that divergent [7:43] thinking [7:44] and then we work together to refine our [7:46] intent and converge that thinking into [7:49] what should exist. [7:51] This is where we describe what we intend [7:53] to make real. [7:55] Then that gets translated into what does [7:57] exist as we execute on that plan and [8:00] bring that intent to production. [8:03] Now each one of these steps comes with [8:05] some friction and some of that's good [8:07] and some of that's bad. And while design [8:10] systems can support each of these steps [8:12] and you can queue up an LLM anywhere [8:14] along this path, we're going to focus [8:16] right now on this part of the process. [8:19] If you want well-designed outcomes, [8:21] intentionality around what should exist [8:24] is necessary. [8:26] But translating it to production needs [8:28] to be efficient. [8:31] I LinkedIn this at the beginning of the [8:34] year. I think that's what it's called. [8:36] Uh the framing of spec-driven [8:38] development has improved the outcomes [8:41] that I get when I work with LLMs, [8:43] especially when doing design work. [8:46] Design is so much more than a preview. [8:48] It's a specification. [8:50] What goes into a good design spec? [8:53] Well, good specifications are precise. [8:56] And in our world, design systems are [8:58] precise language. [9:00] Design systems fit more intent into less [9:04] surface area. [9:07] Let's talk about the shape of that [9:08] context. [9:11] Here we have our favorite reusable [9:12] entity, the button. [9:14] How would we explain it to an LLM? [9:16] Well, the raw values look something like [9:18] this. [9:20] And those values could be abstracted [9:21] into design tokens. [9:24] While this is a bigger payload than [9:25] those raw values, it's actually more [9:26] precise. [9:28] In our system, design tokens represent [9:30] both light and dark mode. So we're [9:32] actually fitting twice as much [9:34] information into to space. [9:37] Now if we have a reusable UI component, [9:39] we can simplify this even further. [9:41] Let's add that focus ring to represent [9:43] all the interactivity encapsulated by [9:46] that one short description. [9:48] Now, we can communicate quite a bit to [9:51] an LLM here with one short statement. [9:54] Let's talk about this in production [9:55] terms. So, for this component in Figma, [9:59] this is the sort of production code that [10:00] we want to have the agent write. [10:02] Note that the label does not say hello [10:04] world, it is loading a greeting from the [10:07] data layer. [10:08] We also have a click event that's not [10:10] specified anywhere in our design. [10:13] And in Figma, Code Connects allows us to [10:15] provide production component context for [10:17] this button via MCP. [10:20] So, to describe this component, Code [10:23] Connect templates can compile code [10:25] snippets that end up looking like this. [10:27] And while some of this is identical to [10:29] the production code, not all of it is. [10:31] We can provide a literal string label [10:33] for the button to help the agent infer [10:36] the right type of message that's going [10:37] in there. [10:38] And we can stub out an event handler to [10:41] remind the LLM that this code is [10:42] representational and that it still needs [10:44] to do some work. [10:46] Now, I know some of you are thinking [10:47] about components getting a lot more [10:49] complex than this. [10:51] So, here's a table. With slots, we're [10:54] able to describe this sort of thing with [10:55] dynamic content in Figma. [10:58] This is how it might look as production [11:01] Svelte code. [11:02] There's a formatter that transforms the [11:04] strings into currency values, and the [11:08] rows in the table are actually coming [11:09] from a data layer in the code base. [11:14] Now, by default when providing this [11:16] design to agents via MCP, we faithfully [11:19] describe the Figma table components as [11:22] React and Tailwind. All of their visual [11:25] style is in here, but this is a ton of [11:27] context. [11:29] I had to bring the font size down to [11:30] seven just to fit it onto the screen. [11:33] Outside of the table header text, not [11:35] much of this is that relevant when we're [11:37] trying to generate design systems back [11:40] to code on the right. [11:42] The reusable elements simply aren't [11:44] described in production terms. [11:47] This is like if I asked you to make me a [11:49] cheese sandwich and I gave you [11:51] encyclopedias on bread, the history of [11:54] cheese, the math behind stacking things, [11:58] I'd no longer be hungry by the time you [12:00] were ready to go and make a sandwich. [12:03] Instead, I could just tell you slice of [12:05] bread, slice of cheese, slice of bread, [12:08] put them together and give it to me. [12:11] With Code Connect, that's how plainly we [12:13] can describe our Figma table component. [12:16] This snippet from Code Connect is [12:18] actually in Svelte and it expresses the [12:21] static Figma rows as an array of data. [12:24] It also accurately describes the table's [12:26] header columns. [12:29] The rest of the code says exactly what [12:31] code component to bring in and how the [12:33] data should be fed into it. [12:35] This is the sort of context that makes a [12:37] big difference. [12:38] We've seen that when teams provide [12:40] agents with verbose context for a [12:42] design, [12:44] agents write a majority of the code, but [12:46] people have to fill in quite a bit to [12:47] ship that feature. [12:49] When we provide agents with precise [12:51] context like Code Connect snippets, [12:54] agents write far more of the total code. [12:57] Something very magical happens. [13:00] There's less total code. [13:03] At times so little that AI is used less [13:06] to get to a better outcome. [13:09] This is what we would call leaner code [13:12] and lower AI usage. We're doing more [13:15] with less. [13:17] But what about all this code that we [13:19] didn't write? [13:20] Well, that's sitting in the agentic [13:22] output from less precise context. [13:25] We describe this as tech [13:28] Now this describes the value of code [13:30] connect and components, but the learning [13:32] here is actually much bigger. [13:35] Precise context in general helps agents [13:39] do more of the work, write better code, [13:41] and be more efficient. [13:43] And this makes them affordable. [13:46] For this reason, we've been putting a [13:47] lot of effort into improving code [13:49] connect this year. [13:51] We have a new template API that's [13:52] completely framework agnostic, allowing [13:54] you to document anything you have. And [13:57] we've shipped slots rendering in the [13:58] code connect API, extending it to your [14:01] most complex components. [14:04] We've also shipped MCP tools for [14:07] publishing code connect, and tools that [14:09] help agents understand your Figma [14:11] library with code connect in mind. [14:14] And we shipped a code connect skill that [14:16] enables agents to work with the code [14:18] connect API. [14:19] We're going to come back to this in a [14:21] second. [14:22] Now design abstraction is a lot bigger [14:24] than components. [14:26] Do we work towards similar outcomes for [14:28] things like layout, typography, or even [14:31] motion? [14:33] Earlier, we talked about these three [14:34] types of context. [14:36] But there's actually a pretty big gap [14:38] right here. We don't talk about this [14:40] space that often. [14:43] This abstraction layer describes [14:45] semantic style fragments and reduces [14:48] inference when applying groups of styles [14:51] together. [14:53] One way we're thinking about this space [14:55] at Figma is a concept that I'm calling [14:57] hyper tokens. Fancy name, but this [15:00] pattern has been around forever. [15:02] In Figma, this plays out already with [15:04] text styles. A text style encapsulates [15:07] many style decisions. This maps well to [15:10] a CSS declaration block, but the biggest [15:13] win here is that instead of having to [15:15] recreate this per property in something [15:18] like Tailwind or inline style, which is [15:21] ultimately an encyclopedia of cheese, [15:25] we can refer to all that style as a [15:27] single named value. [15:29] Not only is this easier for us, [15:32] it significantly reduces the amount of [15:34] inference for LLMs, just like Code [15:37] Connect. Agents love reliable and clear [15:41] abstraction. [15:42] Hyper tokens can be leveraged to apply [15:45] this idea we see here with Text Styles [15:47] to [15:48] everything. Shape, layout, typography, [15:52] surface effects, transformation, change [15:54] over time. [15:56] What would be enabled if we worked [15:58] within a set of constraints like this [16:00] for reusable style fragments? [16:03] This is one of the areas that I've been [16:04] investing in uh at Figma. We're [16:07] exploring a strongly typed and form [16:09] agnostic schema to describe the visual [16:12] language of your design system [16:14] that can be deterministically compiled [16:16] from a single source of truth [16:18] into all of the libraries, [16:20] documentation, rules, skills, and [16:23] context that your team and their tools [16:25] need. [16:26] Here are a couple quick examples of what [16:28] this looks like. [16:30] Here I have a JSON schema that I've [16:32] authored that leverages the DTCG uh spec [16:36] for design tokens. It also adds an [16:38] additional file for hyper token [16:40] structures, which are then combined uh [16:43] in recipes for components. [16:46] We can then deterministically compile [16:48] this source of truth schema into all of [16:51] our design system's forms. Here we can [16:53] see Text Styles that are bound to [16:55] variables that are aliasing each other [16:57] and have code syntax on them by default. [17:00] And in addition to our component [17:02] library, we also can generate our icon [17:04] library from the same source. [17:06] We create and publish Code Connect in [17:08] this process as well. [17:11] Now, we're not just deterministically [17:12] creating systems here in Figma. [17:15] We can also create a base CSS layer, a [17:18] base Svelte presentation layer that can [17:20] be wrapped in a functional library, [17:22] and not just buttons. We're compiling a [17:24] date picker, a table, and charts as [17:26] well. All from a single source of truth. [17:29] Once adopted, we can benefit downstream [17:32] from the use of those hyper tokens in a [17:33] few ways. [17:35] In our deterministically compiled [17:37] storybook stories, we can look at how [17:39] different style fragments are used in [17:41] this button, but then we can also see [17:43] which other components use those same [17:46] patterns. [17:48] We can get this insight on the design [17:49] side as well. Hyper tokens become an [17:52] index for your design thinking, allowing [17:53] you to see how combinations of style [17:56] fragments are used across many [17:57] components in your system. [18:00] And we can also use them to rapidly bind [18:03] multiple properties to variables in just [18:05] a few clicks. [18:08] If you're interested in learning more [18:09] about these explorations and our [18:11] thinking here, TJ Petri and I are going [18:13] to be in the community lounge upstairs [18:15] at 3:30 for a design systems hang. [18:18] Come talk to us about design systems and [18:20] get a sneak peek of what's on the [18:21] horizon here. We want to build this in [18:23] the open and hear from you. [18:26] So, let's talk about skills for a [18:27] second. [18:28] Skills don't replace your expertise, [18:31] they deploy it. [18:33] Here we are sitting with our expertise, [18:35] and there's a lot in here, not all of [18:37] it's relevant at this moment. That's [18:39] okay. [18:40] And here are our agents. [18:43] >> [clears throat] [18:44] >> Ah, yes, here they are. [18:46] So nice of you to join us. [18:48] Now, skills are one of the best ways to [18:51] deploy your expertise to agents. [18:54] If we describe the behavior well, it'll [18:56] supplement LLM understanding, allowing [18:59] them to execute more specifically. [19:02] Now, that skill contains a lot of [19:04] context, at times thousands of lines of [19:07] text. So, it's often useful to leverage [19:10] another agent to help us maintain these [19:12] large bundles of contexts. [19:15] But this breaks down when we manually [19:18] update that skill. [19:20] Editing agentic markdown output is kind [19:22] of like editing minified code. [19:24] The code diffs are a blend of arbitrary [19:27] wording in agentic and human voices kind [19:30] of smashed together. [19:32] This isn't the way to go. [19:34] The easiest thing to do is to just leave [19:35] it to the agent. And while cognitive [19:38] surrender reduces that tension here, [19:40] we're deferring the most important part [19:42] of the work to an agent that may not [19:43] have all the context required to make [19:46] the best judgment. [19:48] So instead, we can create a contextual [19:51] source where we can provide the most [19:53] relevant information. [19:55] And whenever we update that source, our [19:58] agents can transform it into the latest [20:00] skill. [20:02] That's the piece that it does best. This [20:05] gives us control over the context while [20:07] delegating the transformation of it to [20:10] an agent that understands the target [20:12] audience. [20:14] But here's the thing, agents are all [20:16] different and might have different [20:17] requirements or biases when consuming [20:20] skills. [20:22] So far, we're compiling one skill for [20:24] everyone to share. [20:26] But in this setup, we can just let [20:28] agents compile that context with [20:31] themselves in mind. [20:33] We maintain one source of truth that can [20:35] be compiled into multiple skills, each [20:38] targeting a specific type of agent. [20:41] This is a better way to deploy our [20:43] expertise. [20:45] So, how can we make this happen? [20:47] What if I told you that the answer [20:50] is FigJam? [20:53] Earlier, I mentioned that we have a [20:54] skill that explains how to maintain and [20:57] create Code Connect. [20:58] This is roughly 2/3 of that skill. [21:01] And while markdown is an ideal format [21:03] for an LLM to consume, I personally find [21:05] it very difficult to nail down exactly [21:08] how our expertise is being codified [21:10] here. [21:11] So, I took all this markdown and I made [21:14] it come to life in a FigJam. [21:16] Not only is this format much easier to [21:18] parse than flat markdown files, going [21:21] through this process, I realized that [21:23] when I codify my expertise on a canvas, [21:26] because I'm much more aware of what I'm [21:28] asking an LLM to do, [21:30] it improves the clarity of the context [21:33] that I provide. [21:34] Because this isn't just for me. [21:37] I'm asking agents to compile their own [21:39] version of a skill with this. So, let's [21:42] dive into what this actually looks like. [21:45] In my FigJam, I have to onboard the [21:47] agent to this entire idea. So, this [21:50] section explains to the agent that its [21:52] skill its task is to create a skill in [21:54] the codebase. [21:55] It also explains how to do it with the [21:58] FigJam. [21:59] Now, there's a lot of context about Code [22:01] Connect in the main section of the [22:02] FigJam, and it covers a lot about Code [22:04] Connect, including a step-by-step guide, [22:06] a quick reference, some rules and [22:08] pitfalls, and advanced examples. There's [22:12] also this detailed API section. In a [22:14] skill, huge uh pieces of context like [22:18] this are often described as a reference. [22:20] References are accessed only as needed [22:22] instead of loaded every time the skill [22:24] is used. [22:25] Now, before the agent creates a skill in [22:27] the codebase, we also want to be sure [22:29] that it knows what it's doing. [22:31] So, I added a homework assignment inside [22:33] of the FigJam. It instructs the agent to [22:36] use all of that context that we just [22:37] looked at [22:39] and to create Code Connect for three [22:40] components using it before it writes the [22:43] skill. [22:44] The agent retrieves the components I [22:46] created just for this workflow via MCP, [22:49] then writes Code Con- uh Connect and [22:51] commits it to the FigJam. [22:54] Then, I have it retrieve the answer key [22:56] for Code Connect, [22:58] and this contains Code Connect uh uh [23:00] templates for it to compare its work to. [23:03] Now, the goal is not to get these agents [23:05] to write perfect code connect. [23:07] It's to get it to experience what could [23:09] help an agent write code connect. [23:12] They can look at the delta between what [23:13] they wrote and what a good code connect [23:15] doc looks like. And after completing the [23:17] exercise, they can write their version [23:19] of the skill for how to do that to the [23:21] code base. [23:23] The beauty here is that we can have the [23:25] agents regenerate these skills whenever [23:27] we want. Maybe the model changes or the [23:29] recommendation for how to structure a [23:31] skill changes or maybe we just need to [23:33] change the content of the skill. [23:36] We now have a single source of [23:37] contextual truth in FigJam that we can [23:40] work on maintaining together [23:42] and the agents we work with. [23:47] They can translate it for their own [23:48] consumption. [23:49] Now, looking at all that context on the [23:51] canvas got me thinking, if external [23:53] agents can access FigJam via MCP, what [23:57] if I used FigJam like an agentic [23:59] interface to work with them? [24:02] The idea was to have an agent read a [24:04] prompt section in my FigJam, [24:06] then go do some work in Figma, [24:09] then go do some work in the code base, [24:11] and then bring content back into the [24:13] section as it completes that task. [24:16] Now, to do this, since the agents were [24:18] going to be using this FigJam in ways [24:19] the world's never seen before, I needed [24:21] to create a thorough onboarding section. [24:24] And while our use Figma and use FigJam [24:26] skills describe how to use the plugin [24:28] API to do that, I wanted it to do [24:31] something very specific in my FigJam. [24:33] So, I provided example code blocks, like [24:36] how to refit a FigJam section the way I [24:38] wanted to and how to place images at the [24:41] aspect ratios that I wanted. [24:43] Now, these are based on how I want the [24:45] FigJam to be structured. So, we wouldn't [24:47] put this sort of a thing in a global [24:49] FigJam skill. [24:51] This also reduces the amount of [24:52] inference that the agent was going to [24:54] have to do while we work together inside [24:56] of the FigJam. [24:57] Now, for this task, I was creating the [25:00] table that we saw earlier and some other [25:01] components like this pie chart in both [25:04] Figma and my code base at the same time. [25:07] I wanted the agent to use the schema [25:09] compilation approach and [25:10] deterministically create the design and [25:13] code components from a single source of [25:14] truth with hyper tokens. [25:17] So, I described all of it in a Figjam [25:19] prompt. [25:20] I also gave an example of the sort of [25:21] spell code that I was going to want to [25:23] be able to write when it was done. [25:25] I gave the agent links to this and the [25:28] task and let it rip. [25:30] The first thing it did was it split up [25:32] this massive task into many plans for [25:35] sub agents. [25:36] It wrote these plans into Figjam for me [25:39] to go in and read and correct. [25:41] Then, after doing that, I asked agents [25:44] to go take those plans and report back [25:46] when they're done. [25:48] This allowed me to focus on the rest of [25:50] my talk while I watched my Figjam slowly [25:52] become more complete in the corner of my [25:54] eye. [25:56] Now, all this sounds great at a high [25:57] level, but I want to end things today [25:59] with something a bit more tangible. [26:02] I'm going to talk about how I speed ran [26:04] imagination to reality on Figma's [26:06] platform in one night. [26:09] I've been working for 8 and 1/2 years on [26:12] encoding audio into images. [26:16] The best part about these images is that [26:17] they can actually be played back as [26:19] audio. [26:20] Here I am recording a message into this [26:22] image [26:24] and we can listen to it play back. [26:27] >> What's up, Config? It's Jake from the [26:29] past and right now you're listening to [26:31] audio that's been encoded into an image. [26:35] That's right, no audio files. We're just [26:36] listening to an image right now and [26:38] isn't that something? [26:40] >> So, I have a project that uses this [26:42] library called Stegaset. [26:45] And these images here are moments from [26:47] videos of live music performances that [26:50] make me feel alive. [26:52] I encode pieces of audio from those [26:54] performances into a still frame for that [26:57] video. [26:59] This is the sort of project that got me [27:00] into creative coding years ago, [27:02] and I chose to design and build an [27:04] interactive website for this to explain [27:07] how it all works today. [27:09] I started with the design agent in [27:11] Figma. In addition to providing a frame [27:13] with all those stegasat images, [27:17] I also pasted the source code of my [27:19] encoding library to help Figma's agent [27:21] understand this concept. [27:23] Now, giving the agent the source code in [27:26] my code library got me so much further [27:27] than I anticipated. It landed on a great [27:29] initial design. [27:31] But now that I had that design as a [27:33] rough draft in Figma, I went into FigJam [27:35] to craft a prompt for my coding agent. [27:38] The agent would be working on both the [27:39] design and on the local code base and [27:42] using the FigJam to communicate with me. [27:45] I provided with context about hyper [27:47] tokens and all these schema ideas that [27:49] we've been talking about today, so that [27:51] it would be thinking about reusable [27:52] style fragments, especially for things [27:54] like typography. [27:56] Now, I was very intentional about [27:58] bringing a consideration imperative to [28:00] this. [28:01] My intentions became much clearer as I [28:04] tended to my human context window, [28:06] throwing stickies together, bringing [28:09] links and images and code examples into [28:12] the FigJam as inputs. [28:15] And after my coding agent retrieved the [28:16] design from Figma via MCP, provided me [28:20] an analysis for the design system [28:22] patterns that could be used here, [28:24] expressed as hyper tokens and token [28:26] structures. [28:27] And after I reviewed and modified that [28:29] plan, I prompted the agent to use the [28:31] MCP server to create that system in both [28:33] Figma and a code base. [28:36] And it made the design system's changes [28:38] in Figma to that rough draft and even [28:39] brought in screenshots for me to compare [28:41] the before and after. [28:44] Then I hopped into three makes to work [28:47] on animated and interactive sections of [28:49] the website. And again, I provided the [28:51] source code of my algorithms to make [28:54] sure that make was able to visualize my [28:56] code accurately. [28:59] Then back in FigJam, I explained that I [29:01] wanted my agent to interpret those makes [29:04] um that it was going to retrieve the [29:05] MCP. Now, make is React-based, and I was [29:08] building with vanilla JavaScript. [29:11] So, while these explorations in make [29:13] were meaningful, it was less about the [29:15] specific code that was in the make and [29:17] more about how to visualize these ideas [29:20] for a highly complex encoding algorithm. [29:23] There's a lot of make that was relevant [29:25] for the task as context, even though [29:28] most of the code in the make didn't even [29:30] need to be reused. [29:31] And when this agentic session was [29:33] running pretty long cuz I was doing a [29:34] lot, I asked the current agent session [29:37] to write relevant context back into [29:38] FigJam so I can have another agent pick [29:41] up where it left off. And that agent [29:43] followed that guidance to grab those [29:45] makes and to implement it into the [29:47] website in my code base. And after a few [29:50] finishing touches, this was the result. [29:52] We have the full page based on my [29:54] initial designs with Figma agent. We [29:56] have the animations and interactive [29:58] playground for the algorithms that were [30:00] based on my make explorations. And when [30:03] we click on the images, [30:05] it runs the actual decoder library [30:08] to playback the audio for each [30:09] stegasound. [30:12] You can see this [30:13] Yeah, it's pretty cool. [30:16] So, the blue disappearing is an actual [30:18] audio waveform that's been encoded as [30:20] pixels. [music] And so, as it [30:21] disappears, that's actually the sound [30:23] wave being played back. [30:25] You can see this demo at [30:26] stegasound.jake.fun. [30:28] Figma's platform helped me speed run [30:30] exploration, refinement, and execution [30:32] of a highly technical website in one [30:34] evening. [30:35] I've got a design file, a mini design [30:37] system, a code base. But the coolest [30:40] piece [30:41] is that I can show my work. [30:43] I have a FigJam with all of my process [30:46] and the steps I took to get to this [30:47] outcome. [30:49] I could analyze this with FigJam's agent [30:51] for some future endeavor, or I can just [30:54] hold on to it for posterity. I like [30:56] being able to see this. [30:58] As the tools change and our workflows [31:00] evolve, [31:01] the shape of how you bring your intent [31:03] and consideration to it will change as [31:05] well. [31:07] For this talk, I applied a consideration [31:10] imperative by leaning into illustration. [31:13] That's always felt outside of my comfort [31:14] zone. [31:16] I committed to drawing every figure, [31:18] arrow, letter with the pencil tool right [31:21] here in Figma slides. [31:23] And while that took a lot of the limited [31:24] time I had to prepare this talk, my hope [31:27] was that it would make a talk about AI [31:29] feel a bit more personal. [31:31] Certainly did that for me. [31:34] And as I think back to over a year ago, [31:37] standing right here [31:39] with all that uncertainty, and as you [31:40] prepare to leave the world of Config and [31:43] resurface in society, I just have one [31:46] request. [31:48] Don't let go. [31:50] Consideration is the most important part [31:52] in all of this. [31:54] Don't be fooled into giving that up. [31:56] It's the only reason any of this [31:58] matters. [31:59] Your intent is the only thing that's [32:01] going to make working with AI make any [32:03] sense. [32:05] I can't wait to see what you've made by [32:07] next year. [32:08] Thank you.