It’s Friday morning, the version of Figma open on my desktop is the same as last week, and I’ve been refreshing the Anthropic announcement page for about an hour. Welcome to Issue 001 of diffuse.design. I’m Jameson. I’ve been a product designer for eight years, and over the last six months I’ve watched the job I was hired for change faster than any period I can remember. This newsletter is my attempt to make sense of it in public, one issue at a time.
Let’s start with the obvious thing.
The news, briefly
Yesterday Anthropic shipped Claude Design, a product that reads your team’s codebase and design files, learns the design system inside them, and then generates prototypes, slides, and one-pagers from a prompt. It runs on Claude Opus 4.7. The early coverage reads the way you’d expect. TechCrunch calls it a tool for quick visuals. VentureBeat calls it a Figma challenger. The Register goes further and runs the word “killer” in the subhead.
The framing got a boost from timing. Four days before launch, Anthropic’s Chief Product Officer Mike Krieger resigned from Figma’s board. That’s not a coincidence. That’s a decision to ship.
So the Figma-vs-Anthropic story is real. It’s also, I think, the less interesting half of what happened yesterday.
Why everyone is framing this wrong
Figma is the incumbent, so Figma is the story. That’s how tech press works, and it’s not wrong exactly. Claude Design does draw rectangles. It does output artboards. If you squint, it’s a new entrant in a canvas category that Figma has owned for a decade.
But Figma’s moat was never the canvas. Honestly, every vector editor can draw rectangles. Figma’s moat was the artifact it produces: a file that sits between a designer and a developer, holds the current source of truth for how the product should look, and gets poked at in a review meeting before anyone writes production code. That file is the core unit of the design job. It’s what you get paid to ship.
Claude Design, on its own, is a faster way to produce that file. Faster matters, but faster-at-a-thing is never the same kind of disruption as not-needing-the-thing. And the actual bet Anthropic made yesterday is not-needing-the-thing. The real feature, buried three paragraphs into the announcement, is the closed loop to Claude Code. You explore in Claude Design, you hand the exploration to Claude Code with a single instruction, and production code comes out the other side against your real component library.
I want to be careful here, because demos always look better than the daily reality. I haven’t used this in anger yet. Nobody has. But the architecture of the thing is worth reading closely, and the architecture says: the comp is no longer the deliverable. The comp is a midpoint. The deliverable is the running software.
That’s the part to sit with.
Design has been bottlenecked at handoff for twenty years. Every designer I know has a story about a meticulously spec’d component that shipped eight pixels off and a shade too blue. The whole apparatus of Tokens Studio, Zeroheight, Storybook, Chromatic, and every “design ops” hire of the last five years exists to narrow that gap between what was designed and what got built. If the gap can be closed by a model that reads your code and your Figma in the same context window, then most of that apparatus stops being load-bearing. The comp stops being a contract. It becomes a sketch.
When the artifact becomes unnecessary, the moat around the artifact evaporates. Figma’s real risk isn’t that Claude Design is prettier. It’s that the thing Figma files are for starts to disappear underneath it.
What actually changes about the design job
Here’s the part I’ve been chewing on since yesterday morning.
If comps get cheap, the skill in demand shifts. Execution against a known design language becomes something a model can do competently in thirty seconds. What a model still can’t do, at least not yet, is decide what the design language should be in the first place. It can’t sit in a cross-functional meeting and argue that the empty state is more important than the happy path. It can’t watch a user try and fail to book an appointment and know, in their gut, that the fix is to cut a field rather than add a tooltip.
That’s the dividing line, I think, the next two years will run along. Design taste, which used to be invisible because it was bundled with execution, gets unbundled and becomes legible as a skill on its own. Designers who define design languages will compound. Designers who execute against languages other people defined will commoditize.
Three specific predictions I’ll stake this issue on.
First, the design system practitioner becomes the senior role on most product teams. Not the manager. Not the design lead with the Dribbble portfolio. The person who can write a button spec so precise that a model three months from now still generates the right button. This is already happening at the large companies that invested early in design tokens (Adobe’s Spectrum, Shopify’s Polaris, GitHub’s Primer). The dividend those teams are about to collect is enormous. They taught a generation of designers to document every decision. It turns out they were also teaching an LLM.
Second, junior designers will spend less time producing comps and more time evaluating generated ones. This is actually good news if you’re a junior, and I say that as someone who remembers how much of his first two years in this industry was spent nudging pixels in a screen I’d already nudged nine times. The bad news is that the evaluation skill is harder to teach than the execution skill. You get good at evaluation by producing enough bad work that you can recognize bad work on sight. If the first three years of your career are spent reviewing AI output, you may never develop the reflex. That’s a real problem, and I don’t have a clean answer for it.
Third, “design taste” becomes a measurable, trainable, hireable skill for the first time. Right now, hiring a designer is mostly vibes. You look at their portfolio, you feel a thing, you make an offer. In a world where anyone can produce a slick-looking comp, the portfolio stops being evidence of taste. What becomes evidence is the edit trail: which of the fifty alternatives the model produced did you pick, and why, and can you defend it. I expect at least one design interview tool to ship a “taste eval” in the next twelve months. I might build one myself.
The cost of a bad draft has collapsed. The reward for better taste has compounded.
There’s a version of this story where designers panic, and another where they shrug it off. I think both are wrong. The correct response is that this job is about to get considerably more interesting for the people who are good at the interesting part of it, and considerably more precarious for the people who were getting by on craft alone. That’s a real shift. It’s worth taking seriously without doomposting about it.
So what do you do?
What to do Monday morning
If you’re a working designer, here’s what I’d actually do this week.
Document your design system in a format a model can read. This is the single highest-yield thing you can do right now. If your tokens live in a Figma variables panel and nowhere else, export them. Get them into a JSON file, into your Storybook, into your codebase. A model that can ingest your tokens generates work that ships. A model that can’t, doesn’t.
Practice evaluating generated alternatives faster. This is a muscle. Give yourself a prompt, generate ten versions of a screen, and pick one in under two minutes. Then defend the pick in writing in under three. Repeat until the evaluation is quicker than you’d previously have produced a single option. The skill you’re training isn’t “spot the best comp.” It’s “know what good looks like so viscerally that you can see it immediately.”
Stop treating your comp output as the work. Your work is the decisions the comp represents. The comp is the receipt. If you’ve been in this industry long enough to have a polished Figma hygiene setup, it’s worth sitting with the fact that all that hygiene is about to matter less. What will matter more is the written argument underneath the comp. Start writing those arguments down. Not for the review meeting. For yourself.
None of this requires a new tool, a new subscription, or a bootcamp. It requires a slightly different posture toward the job. The designers who shift that posture in the next six months will be in a very different position in eighteen than the designers who don’t.
What I’m watching next
A few threads I’m pulling on for the next issue.
One: what happens to design agencies, which are an even purer execution-arbitrage business than in-house design. If a small team can produce four rounds of brand direction in a morning, the billable-hour model starts to wobble. I want to talk to some founders about that. If you run an agency and have an honest take, please let me know.
Two: the quieter story about the closed loop going the other direction. If Claude Code can generate a working app from a spec, can Claude Design then reverse-engineer a design system from that app? Because if so, the starter-kit category for new companies is about to look very different.
Three: what the next generation of design education should teach. I’ve been asked to guest-lecture a few programs this year and I genuinely no longer know what to say. If you have thoughts, I want them.
I’ll see you here in two weeks.
Jameson