For a few weeks I have been running a small experiment on screens from my own app business: hand the same design system and the same PRD to Claude Design and to Figma Make, then put the outputs next to each other and read them. Around the same time, Toshihide Murata in Web Designing magazine described doing almost the same exercise inside a supply-chain SaaS called Resilire. Reading his account, I had the warm feeling of seeing my own results from a slightly different angle.
I have been close to UI work since around 2009. Once my app portfolio crossed 50 million downloads, maintenance alone outgrew what I could do by hand, and I started using UI generation tools seriously. From that practice, the personalities of the two products have become very legible. What follows is a side-by-side reading of their outputs, what happens when you place both on the same canvas, and where the designer's job actually moves once "drawing the screen" is no longer the work.
The setup matters: same materials on both sides
A fair comparison only works if you control three things: the design system, the PRD, and the opening prompt. Otherwise you are comparing prompts and not products.
- The same Figma library — tokens, colour, type, spacing
- The same PRD — user stories, edge cases, business flows
- The same opening prompt — "Using this DS and PRD, draft three first-pass screens"
When those three line up, the comparison stops being about which AI is better and starts being about what each model actually read from the inputs.
Claude Design's character: chatty and willing to ask back
When I run this with Claude Design, the consistent observation is that the AI starts asking me questions. Role separation that the PRD did not explicitly cover, edge cases that the PRD glossed over, ambiguous data granularity — the model surfaces these and offers to handle them in a couple of different ways before drawing.
The result is that the first-pass screens land at a high baseline. The tweak surface is smooth, the layout exposes several screens at once, and on first look you almost feel like you could hand it to an engineer as-is. Murata called this "talkative UI" in the magazine; that captures it perfectly.
But this chattiness is a double-edged thing. If you accept the output without enough domain knowledge of your own, you risk shipping screens that look polished but carry high cognitive cost. In my app business, a wallpaper-app category picker that takes the talkative output verbatim ends up with too many choices in view, and users drop off rather than pick. Removing things is harder than adding them, so I have come to treat Claude Design's chattiness as conversation material, not a finished proposal.
Figma Make's character: stripped-down, expecting you to talk
Figma Make's output for the same prompt is dramatically more austere. It arranges the default components in their minimum configuration and leaves you the negative space to express what is missing.
I do not read this as a weakness. Subtracting is harder than adding, and a quiet first output is easier for an experienced practitioner to push against. The seamless handoff into Figma proper means the AI's output continues straight into "implementation and discussion".
What it asks in return is your ability to articulate. Without the AI prompting you, the quality of your final output depends directly on how precisely you can describe what you want. Ever since I taught myself HTML in 1997, writing prose and assembling screens have felt like the same craft to me, and Figma Make sharpens that conviction further.
The interesting thing is when you put them next to each other
The real value shows up when you place both outputs on the same canvas.
Claude Design's "fully populated" version next to Figma Make's "minimal" version turns abstract design discussions into something specific. "Why is the second-row navigation here?" "Is this role separation actually needed at this granularity?" "Is this side panel really always-on?" — the questions are no longer abstract, they point at concrete pixels on the canvas.
For me as a solo developer, this is especially useful. When you are reviewing your own work, you are basically arguing with yourself; placing the two extreme outputs side by side puts a second "you" in the room. Both of my grandfathers were carpenters of shrine architecture, and they checked the layout multiple times during marking before any wood was cut. Reading the two AI outputs against each other feels like the same kind of layout check.
The "drawing the screen" cost has effectively gone to zero
After enough rounds of this, the thing I am now sure of: drawing screens by hand is, for practical purposes, over. Wireframes, component placement, responsive behaviour — the AI lands these in seconds to minutes, very reliably.
What is left is the 80% side of design work: discussion, alignment, decision-making. Murata wrote essentially the same thing, and my own time logs back it up.
| Before | Now |
|---|---|
| Drawing the screen (~80% of time) | AI output (seconds to minutes) |
| Discussion and alignment (~20%) | Discussion and alignment (~80%) |
The 80% side has become structurally more important. Design work has not shrunk; the territory being evaluated has shifted.
The design system has become the OS that runs the AI
Running both AIs seriously, the other thing I noticed is that the position of the design system has been promoted. The quality of the AI output is now a direct function of whether your DS is something you can hand to a model.
In my own apps — wallpaper and ambient/relaxation — I keep two small design systems, and I have started restructuring both with the assumption that an AI will read them.
- Beyond colour, type, and spacing, write the prioritisation rules out in prose
- For every pattern, write when this pattern is chosen alongside it
- Document the anti-patterns explicitly
Once a DS is at that level, Claude Design's chattiness comes back in your house voice, and Figma Make's minimal layout returns as your minimum, not a generic one. Murata's phrase — that a design system is "the compressed judgment of an organisation, an operating system the AI runs on" — landed cleanly for me.
Junior–lead collaboration concentrates on the Figma comments
I run my apps solo, so I do not have a team to coach. But the people I trust enough to share Figma files with have become close collaborators on UI critique and even on artwork production.
From those conversations, the differentiator in the AI era is the quality of comments and judgments left on Figma. Saying "the cognitive load is too high here" or "this disagrees with the actual business flow" against an AI output is, in itself, a teaching artefact. Comments stop being feedback and start being curriculum.
When I work on my visual art, the longest stretch of time is always the moment I am stood in front of the piece. Most of the quality is decided in that stillness. Design has moved closer to that structure: the time after the AI hands you the screen — the time you stop and look — is where the work is now.
My current split
To close, the honest version of how I use them today:
- First exploration on a new screen: three Claude Design drafts, one Figma Make draft, on the same canvas
- Refactoring an existing screen: start with Figma Make to expose what can be removed
- Preparing for design review: prompt Claude Design to ask questions back, intentionally
- Revising the DS itself: feed the same DS to both and read the differences
A month of this and the time I spend drawing screens is meaningfully down. The time I spend looking at screens has gone up. That does not feel like a regression — it feels like the work moving back into its right shape.
Ever since I saw that ring of light over Kichijoji Station in late 2019, I have committed to visual work, and the one constant for me is "stand in front of the piece until intuition becomes certainty." That standing-still part has gained, not lost, value in the AI era. I am quietly happy about that.
I will not pick a winner between Claude Design and Figma Make. Putting them next to each other is, for now, the most useful thing I can do.