Ben's Bitesbensbites.com · 11 September 2026 · 2 posts · not counted as a party

Ben’s session #6

Sidebar.iojudgmentkit.ai · 4 September 2026 · not counted as a party

The judgment layer for AI-generated UI Stop AI from building the wrong interface. A design system tells an agent how interface elements should look and behave. JudgmentKit tells it which interface the user’s work requires, what should stay hidden, and what must be repaired. Use JudgmentKit’s design system—or bring your own. Judgment before components A design system can make the wrong interface consistent. JudgmentKit prevents that mistake before the components are composed. Traditional design system Defines how interface elements look, behave, and remain consistent. JudgmentKit Defines what the interface must help someone do, decide, and understand. Together JudgmentKit uses the design system you choose and tells the agent what to repair. Failure-to-repair preview First drafts should start from the work, not from available internals. Failure The screen follows the system, not the work.Generated interfaces often mirror available internals instead of the activity a person is trying to complete. Judgment The activity is named before the UI.JudgmentKit asks what the user is doing, what decision matters,

commandline.microsoft.comcommandline.microsoft.com · 3 September 2026

When I returned from maternity leave in March 2026, I felt like I had entered an alternate universe. I rejoined a newly restructured organization, moved to a different team, and was managing a new portfolio of products and people within Azure Developer Services. I expected to spend time learning a new product space, but I didn’t expect to spend time relearning what it means to be a designer. The teams around me were already using GitHub Copilot and agents in their daily work. Designers on my team were moving beyond making static mockups and clickable prototypes in Figma. Some were contributing directly to production code using VS Code or the GitHub Copilot CLI. The traditional boundary between design and engineering seemed more blurred than ever. Even though I had spent portions of my leave experimenting with AI, I was still blown away by how quickly things had changed in such a short period of time. The same forces that were helping teams execute faster were also making it harder to achieve consistency across surfaces. As I acclimated to my new surroundings, I found myself asking a lot of obvious questions (my kinder rebrand of “

pipshea.netpipshea.net · 2 September 2026

Product resource · Agentic IDEs · 2026 A remix of the 2011 Critical Engineering Manifesto for Design Engineers. Explainer In 2011, Julian Oliver, Gordan Savičić and Danja Vasiliev published the Critical Engineering Manifesto, urging engineers to treat the technologies we depend upon as objects of study, suspicion, and intervention. Fifteen years later, I’ve remixed their manifesto for the Critical Design Engineer: a person who wishes to critically inhabit the space between software design and engineering. I have created this manifesto as a set of guardrails for myself as I navigate agentic engineering capabilities as a software designer. The structure, numbering, and cadence belong to Oliver, Savičić and Vasiliev. Where possible, I have tried to maintain kernels of their ideas in each statement. The manifesto’s source text lives in version control, published as a public Github Gist, under the same GNU Free Documentation License as the original. It carries a commit history, an author signature, and an open invitation to fork. Manifesto 0. The Critical Design Engineer considers code to be a design material, and works it directly. 1. The Criti

Figma blogfigma.com · 2 September 2026 · 2 posts

The Coinbase Design System (CDS) team supports the largest U.S. cryptocurrency exchange across mobile and web for consumers and businesses. They’ve scaled a design system for quality, consistency, and accessibility—but what needs to change when its primary users shift from engineers to agents? Technical Lead Erich Kuerschner saw an opportunity to improve agent output with the Figma MCP serverThe TL;DR on MCP: Why context matters and how to put it to workFigma’s MCP server brings your design decisions into the tools where code gets written—so what gets built actually matches what was designed. Here’s what that unlocks for everyone who builds products., Code ConnectBetter code, fewer tokens: The benefits of Code Connect in MCPWhen going from design to code, agents lack the context of your production components. With Code Connect in Figma’s MCP, they get that context. We measured its impact on token usage, task duration, and code quality., and CDS’ own agent skills. To test this, he ran an evaluation and found that on average, Code Connect cut costs by 22.5% and task completion time by about 22%.“The tests showed us

Anshu Chimalalennysnewsletter.com · 1 September 2026

👋 Hey there, I’m Lenny. Each week, I share deeply researched product, growth, and career advice. For more: Lenny’s Jobs | Lenny’s Podcast | Lennybot | How I AI | Become an AI-Native Builder and my other favorite AI/PM courses Subscribe now P.S. Get a full free year of Cursor, Notion, Replit, Lovable, Wispr Flow, Linear, ElevenLabs, Factory, PostHog, Granola, Brain.fm, Waking Up, and more, by becoming an Insider subscriber (while supplies last). Learn more. I’d always thought AI was bad at design. But after reading this mind-blowing post by Anshu Chimala, I realize I was just doing it wrong. Anshu led software engineering and design teams at Apple for 12 years, focusing on research and prototyping for future AI products. He regularly shares design tutorials and demos on X (he’s one of my favorite follows). For deeper dives into crafting distinctive experiences with AI, check out his Substack and connect with him on LinkedIn. Let’s get into it. A conversational calorie tracker, built in three prompts with Claude Fable 5: A space exploration game, built in two prompts with Claude Opus 5: A dynamic landing page, built in three prompts wi

Vercel changelogvercel.com · 31 August 2026 · 3 posts

Across Vercel, we use coding agents to design and build pages that have to look and feel like Vercel. The typography, color, and composition all need to carry the same judgment that we put into the pages we already ship ourselves.We recently wrote about product-design, our skill that teaches agents how we design when they work in our codebases. The skill lives in each repository alongside the code that it governs, explaining how agents can find and understand our design system as well as product guidelines for whatever they are building.This works great when agents are working in our codebases, where everything the skill needs is right there. But what about reports, proposals, and the one-off pages that still have to look like Vercel but get made in tools that can't read any of those files? For us, the answer was design.md, one public file any agent can load.Copy link to headingHow we approached building design.mdWhat made product-design work well was that the design system and product guidelines were sitting right there in the repository for agents to read. We needed a way for agents and tools outside that environment to reach the

linear.applinear.app · 26 August 2026

It took much longer than anticipated, and at times it was a struggle to keep the momentum going, but more than a 1,000 PRs later, we migrated Linear’s React applications from styled-components to StyleX. styled-components served Linear surprisingly well for a long time. Its API was very flexible, styles stayed colocated with components, and you could reach for regular CSS whenever you needed something more custom. That suited us because our team is unusually sensitive to little things, like the occasional pesky border radius. Eventually though, the endless configurability became a liability. CSS already makes it too easy to style things at a distance, and patterns like styled(Button) made it normal to reopen a component from the outside rather than make its styling contract explicit. We felt the pain of this sharply after Linear’s redesign a few months ago, which has left us chasing a long tail of UI regressions. As our team grows, we wanted to create a stronger foundation for how UI is composed. Defining these boundaries is becoming especially important as agents contribute more and more to our codebase. Another more practical reason to mi

@murphytruemanblog.murphytrueman.com · 25 August 2026

GitClear published a report this year that got me thinking about how we measure design system adoption. Across four year and 623 million code changes, they found reuse falling and duplication climbing across the codebases they analysed. Calls to functions in other files are down 35% since 2023, refactoring is down 70%, and duplicated blocks of code are up 81%.Most of those numbers come from general codebases, where nobody promised reuse in the first place. Inside a design system, the trend should run the other way. Reuse is the whole point, and most teams track adoption to prove its happening. I've been asking whether adoption still measures what we think it does.Most adoption dashboards are trying to answer a pretty simple question: is this component being used? Import counts, coverage percentages, a weekly graph that trends up. All of that is still useful. What they can't tell you is whether the component is being reused, or just copied for the parts someone likes. Both can look like adoption.Here's what I mean: A team pulls Card from the design system and needs it to work slightly differently for what they're building. They wrap it in a local compo

writing.mariusz.ccwriting.mariusz.cc · 6 August 2026

ai Featured Once you have an established design system in code, the interface already inherits a set of visual rules. This creates a world in which an AI coding tool can read a sketch and build out a passable interface from it using those rules. Photo by Danae Paparis / Unsplash TL;DR: Recently, I went from "Who even needs wireframes?" to tldraw becoming my preferred tool for interface design. In fact, I might be using tldraw more than Figma or Paper, depending on the stage of the work.That might sound like a hot take if you define a product design tool as a place for polished screens, high-polish typography and lovingly adjusted spacing. tldraw gives you rectangles, arrows, scribbles and text, and that's a feature.Once you have an established design system in code, the interface already inherits a set of visual rules. Buttons have sizes, states, prominence. Dialogs and modals have structure. Component contracts and slots define the available properties and valid ways to combine them.This creates a world in which an AI coding tool can read a sketch and build out an interface from it using the design system. I saw this idea brought to life for the first

Patrick Neemanuxdesign.cc · 2 August 2026 · 2 posts

A single plain-text file open on a dark screen, its top half typed values and its bottom half written sentences, feeding outward to a design tool, a code editor, and a coding agent. Like a mullet, the business is up top for the machine, and the party below for the person. A single file is the standard we need that both your team and your agents read as truth. Ask a coding agent to build a screen today and watch what it reaches for: Some gray Material button, a shadcn card, a stack of defaults that belong to no brand in particular. That is not the agent failing: It is the agent working from nothing, because your visual identity lives in Figma files, a slide deck, and the heads of three senior designers, none of which a model can read at build time. Without a written source of truth, agents fall back to generic components regardless of your brand. Literally, any components it can find. The fix is one plain-text file, checked into the repository, that states your design two ways at once: machine-readable tokens up top, human-readable rationale below. In April 2026, Google Labs made the DESIGN.md forma

Tony Aliceanngroup.com · 24 July 2026

Summary: As more interface work is AI-generated, the output of research and design shifts from documents written for humans to curated context that guides AI. Context Is the New UX Deliverable Everyone Is Designing AI-Ready Deliverables DESIGN.md A Hypothesis: UX.md Curation, Not Handoff Open Research Context Is the New UX Deliverable AI models produce output based on context. Context is everything the model can see when it does the work: your request, plus whatever instructions, standards, examples, and background information come along with it. Context enables you to avoid middle-of-the-road output. For example, an AI model has been trained on a huge number of search screens, so when you ask for one, it produces an average search screen. It knows what software generally looks like. It doesn't know your users, your domain, your design standards, nor anything your team has learned from research. Unless that knowledge is in the context, the model designs without it. Context leans a model’s output in a particular direction. Think of a skilled builder designing your house without ever meeting your family. They design the average house.

karolinaszczur.comkarolinaszczur.com · 22 July 2026

Design systems operate under one of the following governance models: centralised, federated, or hybrid. All approaches have different benefits and drawbacks, swaying the decision-making scales depending on organisational priorities, maturity, size, and resourcing. Not all decisions are made the same, as one of these models stands to upend what design system teams care about most: cohesion, consistency, and a high bar for excellence. Yes, I’m talking about federated design systems. A federated system (also known as decentralised) operates with no centralised ownership. Instead, it relies on feature teams maintaining it, most often as a side-track to delivery and bug fixing sprints. Federation is the least favoured design system model, with only 13% of teams working within that framework, based on the latest ZeroHeight Design System Report (up from 9% a year prior). Interestingly, How We Document, their first iteration of annual reporting, showed the highest level of dissatisfaction among the federated cohort, pointing to possible challenges with that model. While these surveys might not be fully representational of the design system practice, it’s a

Phil Mortonphilmorton.co · 20 July 2026

If there’s anything that AI is particularly good at, it’s writing code. The whole software engineering profession has been turned upside down as more and more code is written by agents, with humans supervising and reviewing. If LLMs have product-market fit in anything, it’s software engineering.Yet if you’ve tried AI design tools like Figma Make, Claude Design and so on, you might be disappointed. No matter how much context you give it, AI tends to produce design work that looks plausible, but is very generic and on further inspection full of (obvious to us humans) flaws.Having used AI design tools on a few projects recently, it left me wondering, “is it me or is AI just bad at design?”Turns out that, no, it’s not just me. There are some fundamental technical reasons why AI is nowhere near as good at designing as it is at coding.What you mean by ‘bad’?If you haven’t tried these tools in anger, here’s one example from my iOS app, Pegs Out.I recently added the ability to see why a particular day is good or bad for drying your laundry outside, based on the underlying weather conditions. It tells the story of the day in a style similar to a data journalism arti

blog.murphytrueman.comblog.murphytrueman.com · 17 July 2026 · 3 posts

Design systems have spent years borrowing from how software gets built. Versioning, semantic naming, explicit contracts, deprecation cycles. The API framing I wrote about last year was the same premise, treating a component library as an interface other systems consume rather than a folder of pictures. Most of that borrowing is now considered normal practice. The next thing to take comes from a different part of the stack.When you let an agent generate against your system, you're running a model you don't control against rules you wrote, and hoping the output respects them. That's the same problem the people shipping LLM features have been dealing with for a couple of years. One of their answers is evals.An eval is a test for output you can't predict. You hold a set of inputs constant, run them through the model, and check the results against assertions about what a good answer contains. promptfoo, acquired by OpenAI in March, made these cheap to write and run in CI on every change. Because the same input can produce a different output next time, you run each case several times for nondeterministic tasks and watch for the result that wavers.What this looks

Ben Callahanbencallahan.com · 13 July 2026

July 5, 2026 Ask a design system team how they’ll raise the quality of the products they support, and you’ll usually hear one of two options. The first is to make better components, perhaps with more opinionated defaults. The second is to tighten up the quality gates: give the DS team the authority to approve quality, not just the aspiration to improve it. These are both good plans. But they don’t necessarily result in the end products actually getting better. A design system can only raise the quality floor. It sets the baseline below which nothing should ship. An accessible-by-default button, a holistic and thoughtful approach to spacing, a template that starts a consuming team ten steps ahead. But a design system alone can’t raise the quality ceiling. That’s not something you can do by delivering assets. The worst product teams can make awful experiences with the best design systems. That’s because the quality ceiling is set by the choices product teams make with what you give them. It’s their restraint, it’s where they push, and it’s knowing when to deviate from the standard because the standard isn’t serving the end us

Joey Banksnewsletter.baselinedesign.com · 13 July 2026

Names are how your system explains itself. To designers, engineers, and AI. You can't get very far into a design system before you're talking about naming. Not the clever kind, but the everyday kind: what we call the components in a new system, the tokens, the layers underneath that hold it all together. We've been thinking about this one a lot at Baseline, because every team we work with runs into one of two problems here. Sometimes, both! And in today’s age of AI, it matters even more. But more on that soon.The first problem shows up before anything gets made. Someone asks how we should approach naming, and the honest answer is that we don't always know right away. The team might still be proving the system matters at all, and naming feels a long way off. So the work waits. A doc gets started, comments collect, a few LGTMs land, and weeks go by. Naming starts to feel like a decision you only get to make once, so nobody wants to be the one to make it. I can't blame them, that's a lot of pressure to carry.The second problem shows up much later, after a team has agreed on naming. The structure feels good, token and component work kicks off, and it's all coming

Jenny Xiefigma.com · 13 July 2026

Customer service is the next industry AI is poised to reshape, and Decagon is building the platform to do it. Just three years in, the company’s AI agents span voice, chat, and email, replacing the ticket queues and hold times that have defined customer service for decades. That’s how Decagon landed on the CNBC Disruptor 50 list—but what got them there isn’t just what they build. It’s how they build.Building a design system for quality at scaleAt an AI-native company like Decagon, the design-to-code loop moves fast, but it can break down just as quickly. Coding agents need precise inputsWhy you should care about design contextAs developers increasingly use agentic coding tools, the structure and clarity of design files matters more than ever. By thoughtfully organizing your work, you can help your developer counterparts build more efficiently and accurately. to produce reliable output. But without a design system, every component comes down to a judgment call—and that doesn't scale. When Product Designer Jennifer Xu joined Decagon, there was no design system; just a growing product and a team moving fast enough to feel the absence of

Huei-Hsin Wangnngroup.com · 10 July 2026

Summary: Use this maturity model to assess your design system’s health and identify where to focus next. Design-system maturity frameworks often follow a linear progression: you start by building components, move to driving adoption, hit the growing pains of scale, and eventually reach a steady state of governance and evolution. But design systems don't mature in a straight line — the reality of design-system work is much messier and more multifaceted than a ladder can capture. This article proposes an alternative that treats design-system maturity as a multidimensional assessment rather than a sequential journey. Where Linear Models Fall Short The 6 Core Dimensions Assess Your Design-System Practice Alignment Over Assessment Summary Where Linear Models Fall Short While sequential maturity stages help visualize how systems evolve over time and establish broad milestones that organizations can use to benchmark progress, the linear model flattens the reality of design-system work. Maturity isn’t always forward progress. Linear maturity models typically frame growth as a steady climb toward an ideal end state. In reality, many design sys

Christine Vallaureuxdesign.cc · 28 June 2026 · 4 posts

A concept on the horizon, explored A token holds a single decision. A component is a whole assembly. The interesting work lives in the gap between them, and people have worked that gap for years under different names. What it never had was one shared definition that every tool could build from. That gap used to be harmless. “The heading” might live in your CSS, your Figma file, and iOS, drifting slightly out of sync, and a designer just smoothed it over by eye. But it’s often an agent reading your files now, and an agent doesn’t smooth anything over. It builds exactly what it finds and guesses the rest. The drift didn’t get worse. It just stopped being free. Jake Albaugh from Figma gave that gap a name: hypertokens. It belongs to a bigger argument he was making, that AI speeds up execution but not clarity, and that your intent has to stay human-authored for any of this to be worth it. Hypertokens are one piece of that: a way to hand a machine your intent without it guessing. To be clear up front, this is not a shipped feature or an official Figma announcement. It is a concept Jake and his team at Figm

Darren Yeouxdesign.cc · 25 June 2026

As AI pulls product development closer to code, Config 2026 reveals Figma’s high-stakes gamble to survive an era of agentic workflows in a code-native environment At Config 2026, Figma is responding to AI pressure by expanding its canvas into code layers, motion, and shaders to prevent teams from bypassing design handoffs entirely. The real test for the platform is no longer about competing with other design tools but proving that a canvas-first workflow can stay relevant in an AI era of code-first, agentic software building. (image source: Figma) For more than a decade, Figma defined modern product design. It made collaboration effortless, turned design into a shared language, and became the default workspace for teams building software. But as AI reshapes how products are planned, prototyped, and shipped, the central question is the extent of Figma’s usefulness. Or rather, will the canvas remain at the centre of gravity, if at all? Unlike the previous conference, Config 2026 makes that question more urgent. Figma no longer just defends a collaborative design canvas; it is actively expanding that canvas into code, motion, shaders, and agent-driven w

Dolphiauxdesign.cc · 24 June 2026

Your design system runs on one person’s judgment — AI is about to prove it 76 open contributions to IBM’s Carbon design system, each waiting to clear the same gate. Some have been here since April. The label says it plainly: “one more review.” Source: Carbon Design System on GitHub, captured June 2026. It is 6:40 on a Friday. Nine contributions are waiting for review, and every one of them is waiting on the same person. One changes a button’s hover state. One renames a token in a way that will break three teams if I miss it. One adds a date picker that looks fine and is completely inaccessible to anyone using a screen reader, and the only way anyone catches it before it ships is if I catch it, tonight, by hand. This is not one bad Friday. This is the job. When you own a design system, you become the place every change funnels through, and for a long time, I thought that was what good governance looked like: a high bar, held by someone who cared. It took me an embarrassingly long time to see it for what it actually was. The system had a single point of failure, and the single point of failure was me. AI did not