So, is Figma dead yet?
I spent a few days with Anthropic’s new tool, Claude Design, to figure out that answer.
And the thing is, Claude Design isn’t really trying to be Figma. Or Lovable, for that matter. It's more just… a design workspace, where iteration feels more like whiteboarding than prompt engineering.
I’m pleasantly surprised. The good stuff is genuinely good: a canvas that asks you questions, generates multiple design options, gives you sliders to tweak instead of re-prompting, lets you annotate directly, and bundles everything up for your coding agent of choice when you're ready to build.
But it’s also an early product, with a lot of cruft. Claude Design is best at helping you figure out what a product could look like. It's much less useful once your designs need to live inside real, changing applications. (But no worries, I'll cover how to work through that at the end.)
Claude Design is a browser-based tool from Anthropic Labs for generating and iterating on visual work with Claude. They position it for prototypes, product concepts, decks, one-pagers, and marketing assets rather than app generation alone.
You can start from a prompt, upload assets, bring in documents, capture an existing website, or feed it codebase context. Claude then generates a visual project you can refine through chat, annotations, comments, direct edits, and even generated controls. Then, you export it or hand it off to your actual coding agent.
Claude Design is completely different from Claude Code.
- Claude Code is the agentic coding system that reads your local codebases, makes cross-file changes, runs tests, and delivers committed code.
- Claude Design is a separate visual surface that produces a handoff bundle when you're ready to implement. (Design is actually a separate app that’s not bundled the Claude desktop app, which I found a bit disappointing for workflow.)
Put simply, Claude Code is focused on devs, and Claude Design is focused on designers.
My favorite thing about Claude Design is that it doesn't make every interaction feel like prompt engineering.
In my testing, I told it things as simple as “make me a new homepage” or “redesign the blog hero” and that was enough for it to get going.
Because after your simple prompt, it asks you questions. A lot of questions. This is more than just a quick question tool in the prompt window. Claude Design uses the entire canvas to give you a taste exam.
It’s a little thing, but I find the expanded interface, and the knowledge that there will always be lots of clarifications, where I have space to doodle my thoughts or select multiple answers to the same questions, to be very freeing.
And I found that the questions were very relevant to what we were designing, too.
This fits my design workflow. I don’t always know what I want when I’m starting at a text-heavy chat thread and a blank canvas. Instead of trying to describe the perfect result and know about all my context beforehand, I get to lean on the AI to do what it does best: go figure out the mundane things for me and just ask me about questions of taste.
And sometimes you just need the tool to show you a few directions, ask what feels right, and help you narrow the space. It’s less “type prompt, receive UI” and more like a guided creative process.
Another really interesting idea in Claude Design is the Tweaks panel.
When Claude generates a design, it also generates custom controls for that design: sliders, toggles, and adjustable parameters that let you change parts of the result without asking the model to regenerate everything. (If you’ve ever worked on video games, it’s a lot like building your own custom tooling to make assets.)
I found this to be a genuinely cool interaction model. Most AI design tools make every refinement conversational. Want more spacing? Prompt the model. Want a darker background? Prompt the model. Want the hero to feel more editorial and less SaaS-y?
Design, and especially design with AI, is about taste and restraint. Usually AI models go overboard (or don’t do enough) of whatever it is you tell them to do. So, being able to play with a slider that tweaks spacing or intensity in realtime if super helpful.
That said, the feature as it is today is still pretty buggy. Nobody has figured out how to do great generative UI yet, and Anthropic is no exception. Sometimes tweaks are mutually exclusive, and not all permutations actually react to your intent. And I often wanted more tuning parameters and less drastically different options.
But the product idea is strong: AI design tools should give designers tweakable ranges instead of hard answers.
Another thing AI design tools should let designers do is communicate visually with the model.
Claude Design’s scratchpad feature is a nice example here. It's a lightweight drawing surface available to you even when the agent is working (thanks to Claude Design’s tabbed workflow), then send your doodles to the agent as context.
Sometimes you don't want to describe a layout in paragraphs. You want to draw an arrow, circle an area, sketch a rough shape, and say, "more like this." For that, Design also lets you annotate and comment directly on the project.
In these ways, Claude Design feels genuinely designer-oriented. Instead of focusing on ways to type, it gives you ways to point.
Now, for the big one. As designers, we want to get our hands dirty and move things around ourselves on the page.
Here, I have to say, I’m both pleased and pretty disappointed.
On the one hand, Claude Design’s edit mode feels way more designer-oriented than most AI coding tools, using language like “tracking” instead of arbitrary CSS values that only devs know.
Plus, it limits what you can do by the element selected. If you select a simple sentence, you get font-related options. If you select a grid, you get layout options. Just because all options are available in code all the time doesn’t mean Claude Design shows you a massive panel of unrelated controls, like other tools. It shows the ones that you actually need.
All that said, what you can actually edit on the page is pretty limited. You can’t just grab elements and freely move them around like you would in Figma or Builder. For anything bigger than borders, colors, font options, and margins, you’re back to talking to the AI.
There’s a tension here. Claude Design has this great visual surface, but it’s not a flexible design canvas in the way you’d expect. You get *some *direct control, but not enough to get real design work done without resorting to a game of AI telephone.
The last really cool thing I appreciated about Claude Design is that it can generate multiple options per prompt turn and then lay them out on the same canvas for you to compare.
Sure, it takes the AI much longer to do (and uses way more tokens), but often, designing is about thinking outside the box, and I found it super helpful to tell the model to generate 4 vastly different-looking things for me to bounce ideas around.
That said, the feature is currently buggy. When you get multiple design options generated, the canvas mode changes to a more traditional “pan around the page” design mode, and you can’t scroll or easily interact with the static-ish mocks it presents. (The tweak option in the bottom right of my screenshot was not working.)
Hopefully, this gets fixed soon, because as it is, the feature isn’t super usable.
There’s several other rough edges in Claude Design, especially given it’s such a new product.
Figma support is one of the biggest examples. In my testing, I couldn’t work with the Figma MCP or individual Figma frames. I had to upload and entire .fig file, which is really awkward when I just wanted to bring over one flow, frame, or component state and then had to create a whole new file instead.
History and branching is another gap. There’s no way to go back in the AI chat history, which means that if the AI messes up your design, you’re stuck with it. Plus, I found that sometimes switching between commenting, annotating, editing, and other modes sometimes auto-sent things to the model before I was ready.
Overall, I felt a big lack of fine-grained control. It’s a frustrating tool once you’re ready to refine the design. **And, crucially, there’s no export to Figma. **This means you’re stuck with whatever you make.
Claude Design is a fast tool for design exploration and a genuinely innovative way for designers to work with AI. Other than the actual AI generations, which take minutes, clicking around the interface lets you hop between ideas quickly and narrow down the sometimes overwhelming space of design.
But it starts to fall apart is when you use it as part of a team working on an ongoing application.
Let me explain what I mean.
Claude Design feels so lightweight because no part of it is your real app. Even though it can reference your code, it can’t run it. It doesn’t sync your latest production code. It doesn’t preserve any relationship with your app as it changes.
If you’re doing a one-off concept, that’s not a problem. But it breaks over time.
Imagine you use Claude Design to explore a new marketing page, hand it off to your engineers, and then the site changes a bit over the next few months.
When you next come back to that same part of the product, you can’t just open up your old Claude Design project, because it won’t be a real representation of your app. You have to start fresh: new project, re-add context, generate from scratch again.
The problem here is that most product design isn’t net-new ideation. It’s returning to a surface that already exists, understanding what changed, making another iteration, and getting that change reviewed.
The “start from scratch” wouldn’t be such a big problem if there were reliable ways to get your current application state into Claude Design in the first place.
For this, Claude Design has several options, in addition to screenshots and your own prompt engineering:
- Figma import.
- Custom design system.
- Code import.
We already talked about some of the frustrations of the Figma import not being fine-grained enough and not having roundtrip back to Figma. But a bigger point is just… you’re adding another tool to a workflow that ideally wouldn’t need it.
Because if Claude Design *knew *your codebase and design system perfectly, you could use its AI to start from scratch without messing around in Figma.
So, let’s look at the design system features, which a lot of designers are really hyped about.
The setup flow is really straightforward, and Claude generates a basic design system references your brand’s typography, colors, and even spacing values. This part was easy to do.
And in my testing, its generations produced something that looked directionally related to the product I gave it as context.
But there's a big difference between approximating a design system and working from the real one. The output doesn’t use our real code components. It has no 1:1 relationship with the existing implementation our team already worked hard on.
The fidelity was maybe 50%-75% at best: close enough to feel relevant at a glance, but not close enough to trust as a production representation.
And unfortunately, it’s the same with importing your code repository. Claude uses the code as context, but it doesn’t actually work inside your repo or run your app to look at the rendered state. It’s just glancing through the files to get the vibe.
Because the code Claude Design generates doesn’t use your team’s stack, design tokens, or real components, it’s just a prototype.
And that’s fine. Anthropic has said that Claude Design is meant to export to Claude Code, which can read a codebase, work in a real repo, make changes across files, run tests, and deliver code.
But realistically, Claude Code is hard for designers to use. It’s powerful, but it’s a developer-oriented tool. It asks you to deal with local repos, dependency installation, environment variables, app preview servers, Git branches, commits, pull requests, syncing, and merge conflicts.
And if all that doesn’t scare you, then it makes way more sense just to start there anyway. Claude Design is an extra step that, frankly, sits in a really awkward middle spot between Figma and Claude Code.
You might as well stick to Figma.
Of course, most designers on a bigger team would want to use Claude Design and then hand off to engineers, much like you would from Figma.
This is fine, in theory, but no one really saved any time. Your engineers now have to recreate your implementation from scratch, which may divert from the existing design system in subtle ways. You’re back to all the existing problems with design handoffs.
We’ve thought about designers, AI, and handoffs and awful lot, and we’ve designed common workflows right into our product.
Claude Design is strong when you want to explore what should exist. Builder is stronger when you need to safely change what already exists.
Builder connects to your team’s repo one time (devs can set this up), and then anyone on your team can access their own branches with a live preview, a visual editor, and AI (Claude, GPT, whatever you like) that can see and manipulate your real app inside a safe sandbox.
Any changes you make use your real design tokens and real code components. And you can test them out against real data in your application.
When you’re done, you can tag in the proper team for review, and they can continue work on the same branch, making sure that you’re prototyping effort—the tokens, time, and taste you put in—don’t go to waste. No more design fidelity loss.
This also makes it far easier to make small design tweaks that would otherwise be backlogged for eternity. You might be browsing your team’s marketing site and notice a button that needs to move 2px to the left. Great. Just open the editor, move the button, and hit submit.
Your engineers always get final say, so you’ll never break production. You’re free to play around without worrying about jumping between a bunch of different tools. And if you do still want to roundtrip with Figma, that’s completely supported.
If you still want to use Claude Design, but you’re interested in Builder, we also support importing your Claude Design projects at any phase of your workflow.
| If you want to... | Use... |
|---|---|
Explore visual directions quickly | Claude Design |
Create a prototype, concept, or deck | Claude Design |
Implement locally with a coding agent | Claude Code |
Keep iterating on the current app without local setup | Builder |
Work from real components and design-system code | Builder |
Turn a Claude Design concept into ongoing app work | Claude Design to Builder |
Claude Design is genuinely innovative. It makes AI feel less like a blank chat box and more like a creative partner: one that can ask questions, generate options, expose sliders, accept annotations, and turn rough intent into something visual.
But the closer you get to production, the more the workflow depends on handoff: to a coding agent, to the repo, and to the team's review process.
Builder takes a different path. Instead of making a better artifact to hand off, it gives designers a visual way to work in the existing app, with the repo, preview, branch, and PR flow already handled.
Claude Design is for exploring what should exist. Builder is for safely changing what already exists.