I Design with Claude More Than Figma Now: The Quiet Revolution in Product Design Workflows

TL;DR

• Design tools are becoming conversation partners: Product builders are increasingly using Claude, ChatGPT, and similar LLMs to prototype interfaces through natural language rather than dragging rectangles in Figma—a shift that compresses iteration cycles from hours to minutes.
• The fidelity trade-off is disappearing: AI-generated code now produces production-ready components faster than high-fidelity mockups, making the traditional design→development handoff obsolete for many workflows.
• This isn't about replacing designers: It's about changing when and how design thinking happens—moving visual decisions closer to implementation and enabling non-designers to execute on design intent with unprecedented speed.
• The implications are structural: Teams that embrace AI-native design workflows are shipping 3-5x faster on certain feature types, fundamentally altering competitive dynamics in product development.

---

Something strange happened in my workflow over the past six months. I opened Figma exactly twice in January. Once to export a logo. Once to grab a hex code I'd forgotten.

For context: I used to live in Figma. Prototypes for every feature. Component libraries meticulously organized. That satisfying feeling of perfectly aligned grids. Now? I'm having design conversations with Claude, describing interfaces in plain English, and getting working code back in seconds.

This isn't a hot take about tools. It's an observation about a fundamental shift in how product work gets done—one that most teams are still processing in real-time.

The Jane Street Observation: Design as Dialogue

The folks at Jane Street recently documented this exact phenomenon, describing how their design process has migrated from traditional visual tools to conversational interfaces with Claude. Their core insight: when you can describe an interface and get functional code back immediately, the entire concept of "mockup" becomes vestigial.

They're not alone. This pattern is emerging across product teams that work close to code. The workflow looks like this:

1. Describe the interface need in natural language
2. Get working HTML/CSS/React back in 30-60 seconds
3. See it rendered in a browser
4. Iterate by describing changes
5. Refine until it's production-ready

Compare that to the traditional flow:

1. Sketch ideas
2. Create wireframes in Figma
3. Build high-fidelity mockups
4. Hand off to engineering
5. Engineer interprets the design
6. Designer reviews implementation
7. Iterate on mismatches

The first workflow collapses steps 1-7 into a single conversation. That's not incremental improvement. That's a different category of work.

Why This Matters for Product Builders

I think we're watching the decomposition of "design" as a discrete phase. Not the death of design thinking—the opposite, actually. Design decisions are getting made more frequently, but they're happening in a different medium.

Here's my take: The traditional design tool workflow optimized for a world where visual specification was cheaper than implementation. Figma lets you try 50 variations of a button in an hour. Building 50 variations in code used to take days. That economic reality shaped how teams worked.

LLMs inverted that equation. Now generating a working button variation takes 15 seconds. The constraint shifted from "expensive to implement" to "expensive to specify precisely in visual tools." When Claude can interpret "make it feel more premium" and adjust shadows, spacing, and typography accordingly, pixel-perfect mockups become overhead.

This has second-order effects:

Designers who code are suddenly 10x more productive. They can think in systems and see results immediately. No translation layer. No "that's not what I meant" conversations.

Non-designers can execute design intent. Product managers, engineers, even founders can describe interfaces and get 80% of the way to good design without specialized visual skills. The remaining 20% still requires taste, but the barrier to "good enough to ship" dropped dramatically.

Iteration speed becomes a competitive moat. Teams that can test interface ideas in minutes rather than days can explore more of the solution space. They find better answers faster.

What Actually Changes (and What Doesn't)

Let's be precise about what's shifting:

What's Changing:

The medium of design specification. Instead of rectangles and layers, it's conversational description. "A card component with subtle elevation, displaying a user's name, avatar, and last activity timestamp" becomes the artifact.

The timeline of visual decisions. Choices about spacing, color, typography increasingly happen during implementation rather than before it. The design emerges through dialogue with the code.

Who can participate in design. The skill floor dropped. You don't need to master Figma's pen tool to create a functional interface anymore. You need to describe what you want clearly.

Iteration density. Teams are running 5-10x more interface experiments because each one costs minutes instead of hours.

What's Not Changing:

The need for design thinking. Someone still needs to understand users, information architecture, interaction patterns, accessibility, visual hierarchy. AI doesn't make those decisions—it executes on them faster.

The value of design systems. If anything, they matter more. A well-articulated design system becomes the context you give Claude to maintain consistency.

The importance of taste. AI gives you speed, not judgment. Knowing when something feels right, when hierarchy is wrong, when an interaction is delightful—that's still human work.

Brand and identity work. Creating a visual language from scratch, establishing brand guidelines, crafting illustration styles—these remain firmly in traditional design tool territory.

The Practical Workflow Today

Here's how this actually works in my day-to-day:

I'm building a dashboard feature. I need a data visualization component. Instead of opening Figma:

Me: I need a line chart component for showing weekly active users over time. 
Should feel lightweight, use our existing color palette (blues and grays), 
include hover tooltips with exact values, and handle responsive sizing down 
to mobile. Match the visual weight of our existing card components.

Claude: [Returns 200 lines of React with Recharts, styled-components, 
responsive breakpoints, and tooltip logic]

I paste it into my codebase. It renders. It's 85% right. The tooltip positioning is off on mobile. The line weight feels too heavy.

Me: Tooltip should appear above the data point on mobile to avoid 
finger occlusion. Reduce line stroke-width to 2px.

Claude: [Returns updated component]

Total time: 3 minutes. It's in the browser, working with real data, responsive, accessible.

The traditional path would've been: sketch it, mock it up in Figma, export specs, write the code, discover the mockup didn't account for edge cases, iterate. 2-3 hours minimum.

The Skills That Matter Now

If you're a product builder adapting to this shift, here's what I'm seeing matter more:

Precision in natural language. The ability to describe interfaces clearly, including edge cases and interaction details, is becoming a core product skill. "Make it better" gets mediocre results. "Increase the contrast ratio to meet WCAG AA standards while maintaining the current color temperature" gets what you want.

Systems thinking. You need to articulate design systems, component relationships, and consistency rules in ways AI can apply. "Use our standard card elevation pattern" only works if you've defined what that pattern is.

Rapid evaluation. You're seeing more variations faster, which means you need better taste and faster judgment. Can you look at five different button treatments in 90 seconds and know which one is right?

Context management. Feeding Claude the right context—your design system, brand guidelines, accessibility requirements, technical constraints—becomes the setup work that determines output quality.

The Uncomfortable Questions

This shift raises questions teams are still figuring out:

What happens to design roles? My honest take: the role evolves, doesn't disappear. Design becomes more about establishing systems, making strategic decisions, and having taste—less about production of mockups. Junior designers who primarily pushed pixels face pressure. Senior designers who think in systems and can articulate principles become more valuable.

How do you maintain quality? When anyone can generate interfaces, quality control becomes crucial. Teams need stronger design systems, clearer principles, and more rigorous review processes. Speed without guardrails produces inconsistent experiences.

What about collaboration? Figma files were shared artifacts teams could comment on, iterate together, maintain history. AI conversations are more ephemeral. Teams are still figuring out how to collaborate on AI-generated work. (Version control helps, but it's not a complete answer.)

Where's the boundary? Not everything should be AI-designed. Complex user flows, novel interaction patterns, brand-defining moments—these still benefit from traditional design exploration. Knowing when to use which approach is an emerging skill.

What This Means for Your Team

If you're a product builder wondering whether to lean into this:

Start with high-iteration, low-stakes work. Internal tools, admin panels, CRUD interfaces—places where speed matters more than pixel perfection. Build comfort with the workflow.

Invest in your design system documentation. Make it something you can feed to an LLM. Clear component definitions, usage guidelines, code examples. This becomes your quality control mechanism.

Pair designers with AI. Don't replace design reviews with AI generation. Use AI to accelerate the explore phase, then apply design judgment to the results.

Measure iteration speed. Track how long it takes to go from idea to working interface. If you're not seeing 3-5x improvements on certain feature types, you're not leveraging the tools effectively.

Preserve space for deep design work. Not everything should be fast. Core user flows, brand expressions, novel patterns—these still deserve slow, thoughtful design process.

The Horizon

We're early in this shift. Claude and ChatGPT are first-generation tools. They'll get better at understanding design intent, maintaining consistency, handling complex interactions.

I expect we'll see:

• Design systems as AI context. Tools that ingest your design system and ensure every AI-generated component adheres to it automatically.
• Multimodal design conversations. Sketch something rough, describe what you want, get back refined code. The best of both worlds.
• AI design review. Systems that evaluate generated interfaces against accessibility standards, brand guidelines, and usability heuristics before you see them.
• Collaborative AI design. Multiple people describing different aspects of an interface, AI synthesizing it into coherent implementation.

But here's what won't change: the need for humans who understand users, who have taste, who can make judgment calls about what makes an experience great.

AI is making implementation cheap. That makes design thinking more valuable, not less. The question isn't whether to adopt these workflows—it's how quickly you can adapt while preserving what makes your product experiences distinctive.

I'm not abandoning Figma entirely. There are still moments when visual exploration in a canvas makes sense. But those moments are becoming rarer. Most days, my design work looks like conversation. And the products ship faster because of it.

The tools changed. The work changed. The question is whether your workflow will change with them.