Jake Albaugh, Developer Advocate at Figma, walks through setting up Code Connect from scratch — the NPM package, the config file, and mapping design properties to production code properties. The real payoff comes when he shows the before/​after through the MCP server: without Code Connect, an agent sees a flood of raw style data; with it, it sees clean, minimal component code it can actually act on. Unfortunately, Code Connect is still not available on the Pro plan.

Christine Vallaure walks through how A2UI, a Google-initiated open protocol, turns a designer’s component catalog into the sole source of truth for AI-generated interfaces. The AI assembles screens fresh for each user request, but it can only name components that already exist in the catalog — so the quality of every screen traces directly back to design decisions made upstream. The interesting flip: the careful work designers often do invisibly, states, tokens, semantic naming, accessibility, stops being a tax and becomes the engine.

Marcin Wichary, Design Architect at Figma, made this interactive essay about fingers, latency, and why our interfaces still fail the hands using them. Starting with 1890s typists who routinely hit 70 wpm when scientists said 40 was the ceiling, he traces a direct line from terminal echo buffers and UI blocking to Notes on a Mac that can’t keep up with your typing in 2026. The embedded demos — where you feel the difference between a blocked UI and a parallel thread — do more to explain debouncing and latency than any amount of text could. This essay is a fantastic companion to Marcin’s Unsung blog on software craft and quality.

Christine Vallaure walks through what ​“agentic design” actually means once an agent is reading your Figma file instead of a developer. The key shift: all the design-system hygiene we used to wave off as optional — primitives, semantic naming, modes, slots, props, and especially the long-neglected component Description field — now becomes load-bearing, because agents read literally and never ask you over coffee what you meant. A solid 10-minute orientation before diving into the more hands-on MCP pieces.

The Community profile redesign adds role, experience, tech stack, pinned work with images and links, and social channels. Combined with the FigPal customization, it reads less like a profile page and more like a creator landing page. Figma clearly wants Community to function as a discovery layer for designers, not just for resources.

Soleio’s guest is Rasmus Andersson: founding designer of Spotify, one of Figma’s first designers, co-creator of GraphQL, and creator of Inter. The part that stayed with me is his description of how Figma operated: one person on one problem for a year, sometimes binned at the end, while shipping something visible every month. He also makes a case that the production side of design — the part AI is eating fastest — was never actually the hard part. What’s left is the intention. The other link in this section is Soleio’s talk on the geometry of luck, making this pair worth watching together.

If you’re heading to San Francisco for Config, the official conference is just the start. This Luma calendar aggregates the unofficial satellite events — happy hours, dinners, morning meetups, and a comedy night — organized by community members across the city. Several are already at capacity or on waitlist, so worth checking sooner rather than later.

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

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.

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

Dan Hollick (design engineer at Cursor, formerly Tailwind and Raycast) shares a video walkthrough of the custom tooling he built to produce the illustrations for his book Making Software. This is what ​“designing the tool that designs the work” looks like in practice.

Luis Ouriach makes the case against single-number design system adoption metrics. His argument: one number collapses three things that should stay separate, across artifacts (a brand token and a complex data table component need different definitions of ​“used well”), surfaces (a logged-in dashboard component has no business on a sign-up screen), and people (a marketer, a senior product designer, and a front-end engineer all want different things from the same system). The throughline is that compliance with a benchmark is not the same as value, and most design system dashboards are quietly measuring the wrong one.

Kris Puckett, Design Manager at Stripe, spent months building Epilogue, a real iOS app with 14,000 lines of Swift, entirely through conversation with Claude. This essay is a specific and honest account of what the designer-building-with-AI experience actually looks like: what broke, what he learned about asking precise questions, what ​“vague frustration keeps you stuck, specific confusion gets you answers” actually looks like in practice. ​“I realized the bottleneck was never coding ability. It was articulation. The ability to describe what I wanted clearly enough that something else could build it.”

Karri Saarinen, CEO of Linear, writes one of the more grounded takes on AI’s current state. Linear’s cloud agent now fixes more than 1,000 issues per month, but Karri is clear that hard problems remain hard and design tools are still challenging to use. On having a design tool operate directly on the production codebase: ​“A lot of the design work I do is not production design. I am not trying to implement the final version or test every edge case. Most design work is about making decisions, understanding the problem, and finding the fit. That process generates many variations and messy ideas.”

The expertise paradox section is the most useful: ​“AI often feels most impressive in domains where you know the least.” Expertise makes AI harder to use but also more valuable, because experts know how to steer, constrain, and evaluate the output.

A useful companion to Google’s announcement above. Meng To shares 15 takeaways from actually using the format: when to Remix vs. Iterate, how to treat DESIGN​.md as ​“reusable project memory,” and why curation is part of the design process. The most actionable takeaway: ​“Start with DESIGN​.md, generate the first design, remix and expand it, create section variations, move into a builder, then assemble the full site.” Don’t miss his video tutorial on turning a DESIGN​.md into landing pages, mobile screens, and motion design.

“The role of someone who figures out what needs to exist, why, how it should work, how it should be positioned, differentiated and made memorable has never been more in demand.” Josh Puckett (also the maker of Pica included below) separates the deliverable from the practice: he agrees the mockup-maker role is going away, but argues the ​“what should this be and why?” role is more in demand than ever.

“The first casualty won’t be design. It’s the deliverable.” Tommy Geoco backs it with numbers: a recent State of Prototyping survey of 1,478 design engineers finds 80.9% spending most of their week vibe coding, and 59% having shipped their own internal tool in the last six months. ​“The design function isn’t being eliminated. It’s absorbing engineering.”

Pica is a native macOS font manager from Josh Puckett, built for designers who want proper font organization. ​“Organize into collections, test color themes and logos, watch folders, manage what’s installed, and much more.”

Jacob Miller left the PM role at Figma to build Diffui, a new way to approach the design to dev process with AI. In this thread, he compares designs generated by his tool and Claude Design. One is more expressive and diverse, another is more polished and organized. The point is not that one is better than another, but how can we combine different approaches and tools to get to the most interesting result.

Hugo Raymond breaks down Swap Instance vs. Slots as two ends of a control–composability spectrum: Swap Instance hard-locks a single nested component in a fixed position, while Slots act like open containers that accept almost anything and can be freely rearranged. For design system teams, his key point is that the ​“right” choice isn’t about which feature is more powerful, but about how much you trust consumers of your components and whether you fear incorrect composition more than full detachment from the library.