Claude Design just dropped. Here's How it completes the Designer's AI Stack, and Why you still can't delegate Taste
Anthropic's new design tool fills the exploration gap in the Claude Code workflow. But if you think this means AI does the designing now, you're about to ship a lot of very expensive mediocrity.
Yesterday, Anthropic launched Claude Design: a new product from Anthropic Labs that lets you collaborate with Claude to create prototypes, wireframes, slides, marketing collateral, and full interactive experiences. It’s powered by Claude Opus 4.7, their most capable vision model, and it’s available now for Pro, Max, Team, and Enterprise subscribers.
When I saw the announcement, my first reaction wasn’t excitement. It was recognition. This is the piece I didn’t know was missing from the workflow I’ve been building for months.
Back in January, I published a guide on Claude Code for Designers. A step-by-step breakdown of how designers can go from Figma to deployed, production-ready prototypes using Claude Code and the Get Shit Done (GSD) meta-prompting system. That article walked through the full loop: design in Figma, extract tokens via MCP, build with spec-driven multi-agent orchestration, deploy to Vercel. No handoff queue. No sprint backlog. No waiting three weeks for a developer to interpret your Figma redlines.
The workflow worked. It still works. But it had an assumption baked in: you already know what you’re building.
Claude Design addresses the space before that certainty exists.
Where Claude Design Fits
Think about your actual design process. Not the one in the case study. The real one.
Before you commit to a direction, there’s a messy phase where you’re sketching, exploring, killing ideas, resurrecting them, pushing variations. This is where the real design thinking happens. And it’s also where time pressure kills the most potential. You don’t explore twelve directions because you don’t have the hours. You explore two or three, pick the least wrong one, and move forward.
Claude Design is built for that exploration phase. You describe what you need, Claude builds a first version. You refine through conversation, inline comments, direct edits, or custom sliders that Claude creates for you. When you give it access to your design system, it applies your brand automatically across everything it produces.
The key features that matter for the workflow I’ve been advocating:
Design system ingestion at onboarding. Claude Design reads your codebase and design files to build a token library automatically. This is the same extraction step I was doing manually through Figma MCP in my Claude Code workflow. Now it’s native, happening at the tool level rather than requiring a GSD phase to set up.
The handoff to Claude Code is real. Not a PDF spec. Not a Zeplin link. Not a screenshot with “make it like this.” Claude Design packages everything into a structured handoff bundle that you pass to Claude Code with a single instruction. This is what “no translation layer” actually looks like.
Frontier prototyping. Voice, video, shaders, 3D, built-in AI. This isn’t a wireframing tool that generates grey boxes. It’s a design environment that thinks in code from the start, which is exactly the mental model I’ve been pushing in my work on Agentic Experience Design.
So the updated workflow becomes:
Explore in Claude Design → Refine direction → Handoff to Claude Code + GSD → DeployThe exploration phase that used to happen in Figma (or worse, in your head, because who has time for ten Figma explorations?) now has a dedicated tool that moves at the speed of conversation.
What It Actually Feels Like to Use
I’ve been watching early adopters hit Claude Design within hours of launch. The first-use experience is revealing, both for what the tool gets right and for where it proves my point about not delegating taste.
The design system ingestion is impressive. You upload brand guidelines, fonts, logos, and assets. Claude Design processes everything and within about ten minutes it generates a full design system: CSS files, color palettes, typography scales, spacing tokens. If you’ve done this manually through Figma MCP and a GSD phase (as I described in my January article), you’ll immediately recognize the value. What used to be a deliberate extraction step is now an onboarding flow. It reads your brand PDF and pulls out the actual values. Colors, display fonts, body type, spacing scales, all mapped correctly from the source file.
Three interaction modes, each with a different purpose. Edit mode gives you direct manipulation: click an element, change its color, adjust line height, the things you’d expect in any design tool. Comment mode is conversational. You select something and say “make this bigger and center it,” and Claude applies the change. Draw mode lets you sketch annotations directly on the prototype and send them as visual instructions. This layered approach is smart. It means you’re not trapped in pure prompt-and-wait territory; you can be precise when you need precision and loose when you need exploration.
The research capability is unexpectedly deep. One early user built a mockup for a networking event app in Cornwall and asked Claude Design to populate location data. Without being given any specific venue information, it found real hotels nearby (with room rates), actual car parks, the local train station, walking distances between venues. Genuine location intelligence baked into a design prototype. This blurs the line between mockup and functional spec in ways that are genuinely useful for client pitches and stakeholder demos.
The Claude Code handoff works exactly as advertised. You export from Claude Design, copy a command, paste it into Claude Code, and it fetches the design file from an API endpoint and starts building. The bridge between “this is what it should look like” and “now make it real” is a single clipboard action. For my GSD workflow, this means the handoff bundle feeds directly into /gsd:new-project with the design intent already encoded.
But here’s the catch: the first output is often rough. And I mean noticeably rough. One of the first prototypes I saw come out of Claude Design was described by its creator, live on camera, as “pretty hideous.” Black text rendered on a dark forest-green background, completely unreadable. Brand colors applied with too much liberty, creating what the user himself called a “garish” palette that technically used the right hex values but combined them in ways no designer would choose. The tool had ingested the brand guidelines perfectly and then made aesthetic decisions that violated the spirit of those guidelines entirely.
This is not a bug. This is the core tension of AI design tools.
Claude Design extracted the colors correctly. It understood the typography. It built the spacing system faithfully. And then it composed all of those correct ingredients into a design that a trained eye would reject in two seconds. Because composition, hierarchy, and visual judgment aren’t in the tokens. They’re in the designer.
And a practical note on cost. That single session, one design system generation plus one prototype, consumed 65% of a Pro plan’s weekly credit limit. Claude Design is compute-heavy. If you’re on a Pro plan and planning to use this for anything substantial, you’ll hit your ceiling fast. Max or Team plans are probably the realistic entry point for production use.
Now Here’s the Part Nobody Wants to Hear
Claude Design is going to produce a tsunami of generic experiences.
Not because the tool is bad. It isn’t. It’s genuinely impressive. But because the moment you give people a tool that generates polished-looking design at conversational speed, a significant percentage of them will do the obvious thing: type a prompt, accept the first output, and ship it.
And what they’ll ship will look fine. Clean layout. Consistent spacing. Decent typography. Professional color palette. It will check every box on a surface-level design review.
It will also look exactly like every other AI-generated experience on the internet.
We already have proof. Within hours of Claude Design going live, I watched someone upload a complete brand system (guidelines, fonts, logos, color palettes) and generate a high-fidelity event app prototype. The tool ingested everything correctly. Every hex value was right. Every font was mapped. And the first output? His own words: “pretty hideous.” “Garish.” Black text invisible on dark backgrounds. Colors that were technically on-brand but composed in ways that made the interface feel like a fever dream of its own design system.
He could fix it. He did fix it, through edit mode and comment mode and iteration. But the point is: the default output of a perfectly configured AI design tool was something no designer would ship. And yet many non-designers will ship exactly this, because the tool told them it was ready.
Welcome to the age of AI-slop design.
You’ve already seen this in writing. The moment ChatGPT became widely accessible, the internet flooded with content that was grammatically correct, structurally sound, and utterly devoid of voice. Every blog post opened with “In today’s fast-paced world...” Every LinkedIn article used the same cadence, the same hedging, the same synthetic warmth. The content was fine. It was also completely interchangeable. You could swap the byline on any AI-generated blog post and nobody would notice.
The same thing is about to happen to design. At scale.
AI-generated interfaces default to a specific aesthetic: clean, round corners, generous padding, blue-to-purple gradients, card-based layouts, hero sections with centered headlines. It’s the design equivalent of business casual. Nothing is wrong with it. Nothing is memorable about it either.
When you prompt “create a SaaS dashboard,” you get the SaaS dashboard. The one that looks like every competitor’s dashboard. The one that follows every best practice without understanding any of the context that makes those practices relevant or irrelevant for this specific product, this specific user, this specific problem.
And here’s the trap: it will take you longer to fix the UX problems in an AI-generated design than it would have taken you to design it properly in the first place.
Why Delegating Design Produces Expensive Mediocrity
The cost isn’t in the first output. The first output is free, or close to it. The cost comes in the iteration cycle that follows.
Actually, let me correct that. The first output isn’t even cheap. A single design system plus one prototype burned 65% of a Pro plan’s weekly credit. So you’re spending real compute on an output that needs significant design intervention before it’s usable. The “free exploration” framing only holds if you know how to steer the tool fast, which means you need design skill to make the economics work, not just to make the output good.
When you delegate design to an AI and accept the output without deep design thinking, you’re importing a set of decisions you didn’t consciously make. Spacing choices based on generic patterns, not your content hierarchy. Navigation structures based on statistical averages, not your user’s mental model. Interaction patterns that are common rather than correct for your specific context.
These decisions compound. A slightly wrong information architecture means users can’t find what they need. A generic onboarding flow means drop-off rates climb. A cookie-cutter dashboard layout means the three metrics that actually matter are buried in a grid of sixteen cards that all look equally important.
You don’t notice these problems in a mockup. You notice them when real users hit the product and start abandoning it. And then you’re debugging UX issues that were baked in from the very first prompt, buried under layers of polished execution that made everything look right.
I’ve seen this pattern play out in client work. Teams generate a prototype fast, stakeholders love the polish, the project moves forward. And then three months later the conversion numbers are terrible and nobody can figure out why. The interface looks great. The experience is just... flat. Undifferentiated. Forgettable.
The fix isn’t more prompting. The fix is more designing.
The Designer’s Actual Job in the AI Stack
Here’s what I tell my team: AI is an extraordinary amplifier. But an amplifier is only as good as the signal you feed it.
If you feed Claude Design a prompt like “create a landing page for a fintech app,” you get a landing page that could belong to any fintech app on earth. It’s the mean average of every fintech landing page the model has ever processed. It’s omologated. Homogenized, standardized, made the same.
If instead you feed it: “The primary user is a first-time investor who’s intimidated by financial jargon. The emotional design goal is calm authority. They should feel like they’re talking to a knowledgeable friend, not reading a bank brochure. The key conversion action is starting a simulated portfolio, not creating an account. The hero should feel spacious and quiet, not busy and feature-dense.” Now you’re designing. You’re just using a different medium.
The designer’s job hasn’t changed. What’s changed is the bandwidth.
In the old workflow, you had one shot at exploration because each direction took hours to mock up. Now you can explore ten directions in the time it took to explore two. But you still need to know which direction is right. You still need to understand your user. You still need to have a point of view about what makes this experience different from every competitor’s.
AI gives you more exploration. It doesn’t give you more judgment.
And judgment, taste, instinct, the ability to look at ten options and know which one feels right for this specific context? That’s not a prompt-engineering skill. That’s a design skill. It’s built through years of studying interfaces, watching users struggle, shipping things that failed, understanding why they failed, and carrying those lessons forward.
How I Actually Use This Stack
Here’s the honest version of how these tools fit into my work at Accenture Song and my personal projects.
Phase 1: Explore with Claude Design and Figma
When I’m starting a new concept, whether it’s a client pitch, a prototype for the Agentic Experience Design practice, or a personal product like WatchVeritas, I use Claude Design to generate breadth fast.
But I don’t start with “make me a dashboard.” I start with the design intent. What’s the emotional register? What’s the information hierarchy? What are the three things the user absolutely must be able to do in the first ten seconds? What’s the one thing I want this experience to feel like that no competitor’s does?
Claude Design generates variations. I kill most of them. The ones that survive get refined through conversation. Not “make the button bigger” conversation, but “this layout implies equal importance across all cards, but the monitoring alert card needs to dominate the visual hierarchy because when something is wrong, it has to be unmissable.”
The collaboration layer matters here too. My team can jump into a Claude Design project and leave comments without editing directly. A designer can annotate “this hierarchy is wrong, the alert state needs to dominate” without touching the implementation. It’s a design review workflow, not just a generation tool. That distinction is important.
That’s the design direction. Now it has intent behind it.
Phase 2: Structure with Figma
The refined direction moves to Figma for systematic design. Component architecture. State management at the design level. Responsive behavior. Edge cases. Empty states. Error states. Loading states. All the things that separate a concept from a product.
Early reactions to Claude Design describe it as “Figma crossed with vibe coding.” That’s telling, and it’s exactly why Figma doesn’t leave the workflow. Claude Design generates compositions. Figma builds systems. A composition shows you what one screen looks like in one state. A system defines how every screen behaves across every state, every breakpoint, every data condition. Claude Design can’t give you that level of architectural rigor yet, and honestly, I’m not sure it should. The value is in the rapid exploration, not in replacing the tool where systematic design decisions live.
This is where design systems live and where the detailed craft happens. Claude Design is great at exploration, but the systematic work of building a design that handles every real-world scenario? That still needs the rigor of a proper design tool and a designer who thinks in systems.
Phase 3: Build with Claude Code + GSD
Once the direction is solid and the system is defined, everything flows to Claude Code through GSD’s spec-driven workflow. The handoff bundle from Claude Design or the Figma MCP tokens feed directly into the GSD pipeline:
/gsd:new-project → /gsd:discuss-phase → /gsd:plan-phase → /gsd:execute-phase → /gsd:verify-workThe handoff mechanism is elegant in its simplicity. Claude Design gives you a command to copy. You paste it into Claude Code. It fetches the design file from an API endpoint, all the CSS, the component structure, the layout intent, and starts building. You can also export as a zip file and send it to any coding agent, not just Claude Code. But within the Anthropic ecosystem, the flow is seamless: design system, prototype, copy, paste, build.
The key insight from my January article still holds: without GSD’s structure, Claude Code produces vibe-coded chaos. With it, you get spec-driven, verifiable, atomic-commit output that matches your design intent precisely.
Phase 4: Ship and Iterate
Deploy to Vercel. Share the link. Get real feedback from real users. Iterate.
The total cycle time from “I have an idea” to “here’s a working URL” has collapsed from weeks to days. Sometimes hours. But, and this is the critical point, the design thinking doesn’t compress. The conversations about user needs, the decisions about hierarchy, the debate about what to leave out, the taste calls that make one product feel considered and another feel generic. Those take exactly as long as they always did.
You can’t speed-run judgment.
The Omologation Problem
There’s an Italian word I keep coming back to: omologazione. It means homologation, standardization, making everything the same. It’s used in car culture to describe when every car starts looking identical because they’re all optimizing for the same wind tunnel metrics.
AI-generated design has an omologation problem.
When everyone uses the same models, trained on the same data, responding to the same types of prompts, the output converges. Every SaaS dashboard starts looking like every other SaaS dashboard. Every landing page follows the same hero-features-testimonials-CTA template. Every mobile app uses the same bottom navigation with the same icon set.
The experiences aren’t bad. They’re just undifferentiated. And in a market where every competitor can generate the same polished baseline in minutes, being undifferentiated is the same as being invisible.
Differentiation now lives in the design decisions that AI can’t make autonomously. The choice to break a convention because your specific users need something different. The decision to strip out a feature that every competitor has because your research shows it creates cognitive overload. The instinct to use silence, space, and restraint when the AI would fill every pixel with content.
These are acts of design. They require conviction. They require a point of view. They require having spent enough time with users to know when the best practice is wrong for your context.
No prompt will give you that.
What This Means Going Forward
Claude Design is a significant moment for the industry. Not because it replaces designers (it doesn’t) but because it democratizes the production layer of design so completely that production is no longer the differentiator.
Anyone can now generate a professional-looking interface. The barrier was skill and time. AI removed both.
What remains as the differentiator is the thinking underneath the interface. The research. The strategy. The user understanding. The taste. The willingness to say “this looks beautiful and it’s completely wrong for our users.” The craft of designing not just what’s on the screen, but what happens in the user’s mind when they interact with it.
My workflow has evolved: Claude Design for exploration, Figma for systems, Claude Code + GSD for production, Vercel for deployment. The tools keep getting better. The speed keeps increasing.
But the core truth hasn’t changed: if you delegate design to AI, you’re not saving time. You’re deferring the UX problems to a phase where they’re ten times more expensive to fix.
Use Claude Design to explore faster. Use it to generate variations you’d never have time to sketch. Use it to prototype ideas at the speed of conversation.
But bring your own taste. Bring your own judgment. Bring your understanding of users, context, and the specific problem you’re solving.
Because in a world where every product can look polished by default, the only remaining competitive advantage is designing something that’s actually good.
Resources:
Claude Code for Designers: A Practical Guide (my full step-by-step workflow)
Get Shit Done (GSD) (the meta-prompting system that makes Claude Code reliable)
Figma Model Context Protocol (design-to-code pipeline)
I am so happy to have this perspective from someone who works in design. Thank you for all of this great insight 🥳
DoW operations and AI integration is one of the least discussed but highest-stakes enterprise deployments happening right now. The standard procurement cycle is completely mismatched with the pace of capability change. How are you seeing acquisition frameworks adapt to evaluate AI systems that could be functionally different by the time the contract is signed?