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)