An official Figma walkthrough of the agent (currently in beta, rolling out since May 20) through three phases of a real design project: exploring directions, processing feedback, and automating repetitive updates. The most practical detail: the agent works with your connected design system from the first prompt, so generated screens use your actual components, variables, and styles rather than placeholders. Also worth trying a prompt like ​“what would a growth-focused PM say about these designs?” to simulate stakeholder pushback before the actual review.

Matt Colyer, Figma’s director of product management for developers, makes the case on Dan Shipper’s AI & I podcast that the SaaS apocalypse narrative has it exactly backwards. He’s been running his own agents for two years and is buying more software subscriptions than ever, because shipping and maintaining a personal agent teaches you fast why people pay for someone else to run it. The more interesting half is about design specifically: chat is linear, which makes it good at converging on a single direction but terrible at generating lots of options. Figma’s on-canvas agent is a first attempt at the divergent side — letting you branch frames in different directions, then bring in a convergent agent to cluster them. He also walks through how the MCP server closes the code-to-design loop, and why ​“review” has quietly become the biggest bottleneck in AI-assisted product work.

Miggi compiles a thread of agent prompt examples paired with screen recordings of each one running.

Make can now connect to a local repo and edit your real production code, not just a sandboxed project. Designers point at an element, adjust properties or leave an annotation, and the agent finds the relevant code, commits the change, and opens a PR through standard GitHub flow (SSH for other providers). It also handles dependency installs and spins up the dev server for you. Closed beta on the Mac Beta desktop app and beta usage doesn’t burn credits.

The on-camera companion to the Make-on-Local-Code launch. The most interesting bits beyond the blog: a Figma editing panel inside Make for direct style changes, multi-element annotations pinned to the rendered screen (including voice mode), and MCP server support for resolving merge conflicts and CI failures. The pitch is that designers get agency to ship the change themselves while the engineer’s review workflow stays untouched – apple for early access.

Alexia Danton, Designer Advocate at Figma, walks through seven tactics for stretching Make credits further. The most useful ones are the least obvious: use the Edit tool and ​“Go to source” for small visual tweaks instead of prompting, codify repeated instructions into a guidelines.md file so Make doesn’t relearn your conventions every turn, and reach for Gemini Flash on routine iteration while saving Claude Opus for ambiguity and high-fidelity work.

Five workflows that show what Figma Weave is actually for: chaining AI nodes on a canvas to blend two references into a style guide, fan out variations across aspect ratios, run eight distortion filters in parallel, generate rotatable 3D models through Rodin 3D V2, and composite stills into rendered video.

A conversation between Figma’s Design Director of AI Gui Seiz and engineer Alex Kern on how AI inverts the old economics, code used to be expensive and design cheap, now both are cheap and the bottleneck moves to intent. The companion piece to the two MCP posts and the Code to Canvas tutorial elsewhere in this section.

A short onboarding walkthrough for the agent beta. Worth watching for the suggested starter prompts: generating alternative layouts, starting from scratch using your design system, working together on canvas, and getting feedback.

TBPN’s 20-minute interview with Dylan Field on the day of the Design Agent launch.

“We don’t think designers should generate a one-shot screen and call it a day.” That sentence from the announcement is Figma’s vision for the design agent in a nutshell. The framing is explicitly co-pilot, not auto-pilot: the agent runs in front of you on the canvas, riffs to spark an idea, and then hands it back to your mouse and direct manipulation. Pair that with native access to your libraries, components, and tokens, and the bet is clear – the winning AI design tool is the one that already knows your design system, not the one that generates the prettiest screenshot.

Rolling out gradually in beta over the coming weeks. During beta, the agent won’t consume credits. See also the official announcement at The Figma design agent is here.

Brett McMillin shows a concrete loop: an agent reads a coded export flow, finds every state the developer shipped (success, error, loading, edge cases), and generates fourteen designable frames on the canvas using the design system. From there, the designer riffs on three animation directions, the /sync-figma-token skill flags token drift between code and variables, and a generate_figma_design call produces an annotated side-by-side diff.

Emma Webster’s overview of why MCP exists and what it changes. Without context, AI coding tools work from a screenshot — they see the end result, not the decisions that went into it. The Figma MCP server hands agents structured access to components, tokens, and layout decisions instead. Useful as the conceptual baseline before getting into the applied workflows in the lab.

Round up of four AI workflows Figma sees teams adopting: prototyping in code first and pulling it back to the canvas via Codex to Figma, generating dozens of layout variations on the canvas, building a Figma Make prototype before writing the spec, and using Make kits with MCP to carry design system context into the code. The through-line is that the artifact teams align around is shifting from the mockup to the working prototype.

Yuhki Yamashita, Figma’s CPO, lays out the company’s worldview behind the Design Agent, Make, and Weave launches. When generating a working app is cheap, the bottleneck moves upstream: choosing the right direction and shaping it with care. He proposes a ​“go broad and deep at the same time” workflow, where Make spins up parallel prototypes and Weave becomes the room where teams compare, argue, and refine. A tidy thesis for a launch week, and the tools clearly exist to enact it.

Designer Fund surveyed 900+ designers across 60+ countries and conducted 20+ interviews with leaders from Anthropic, Framer, Linear, Notion, Shopify, Sierra, and Stripe. The headline number: half of respondents have shipped AI-generated code to production, and designers are now using double the AI tools they were a year ago. Designers are quietly absorbing PM and engineering work, but hiring loops, performance reviews, and team shapes haven’t caught up.

Figma Make now supports custom skills — markdown files that capture conventions and workflows you use repeatedly, callable from any prompt with a slash command. Pair /build-from-prd with a Notion connector and any PRD becomes a prototype that matches your standards.

Stephen Haney announces QuiverAI’s SVG generation inside Paper – vector output from text or references, aimed at logos, illustrations, and animations. QuiverAI​’s models have been on my radar since Dann Petty joined the team as a Founding Product Designer.

Paul Bakaus has packaged 23 design commands into a single agent skill that teaches Claude Code, Cursor, Codex, and Gemini CLI how to actually design. Type vocabulary, color systems, motion, spatial logic — the foundations most prompts miss. The Live mode that writes accepted variants back to source is where it gets genuinely interesting.

A useful baseline study on how people actually use AI well. The most uncomfortable finding for designers: in conversations that produce artifacts (code, UI, documents), users are less likely to question the model’s reasoning. Polished output suppresses critical evaluation, even though that’s exactly when it’s most needed.