Designers who ship

Anthropic published a case study about how their internal teams use Claude Code. It’s been making the rounds again recently, and for good reason. The headline that stuck with me: their Product Design team has Figma and Claude Code open about 80% of their time. Not Figma and Slack. Not Figma and a ticket board. Figma and a coding tool.

Their engineers reported that designers were making “large state management changes that you typically wouldn’t see a designer making.” And the team measured 2-3x faster execution on front-end work.

The report describes two distinct experiences: developers get an “augmented workflow” where they execute faster, while non-technical users get the “holy crap, I’m a developer” workflow, gaining entirely new capabilities that were previously impossible.

That’s not a minor improvement. That’s a fundamentally different way of working.

What stood out

The case study describes several use cases that hit close to home for me.

Direct front-end implementation. Designers aren’t handing off specs and waiting. They’re opening the codebase and making changes themselves. The traditional back-and-forth between design and engineering, where a designer explains spacing or animation timing through comments on a Figma file, just disappears.

Prototyping from mockups. They paste screenshots of their Figma designs directly into Claude Code to generate working prototypes. Not wireframe-to-code tools that produce generic output. Actual implementation in the real codebase.

Edge case discovery. When you’re working in real code instead of static mockups, you find problems you’d never catch in Figma. Empty states, error messages, overflow behavior. The kind of stuff that normally surfaces during QA and sends everyone back to the drawing board.

Automated ticketing. They’ve set up GitHub Actions so designers can simply file a ticket describing a needed change, and Claude automatically proposes code solutions. No need to even open Claude Code. Just describe what you want fixed and it gets done.

Complex copy changes. When they needed to remove “research preview” messaging across the entire codebase, a designer used Claude Code to find all instances, review surrounding copy, coordinate with legal in real-time, and ship the updates. A process that would have taken a week of back-and-forth took two 30-minute calls.

I already work like this

Reading Anthropic’s case study felt like reading about my own workflow. I’ve been doing this for a while now. But let me be specific about what “a while” looks like in practice.

Today, I updated the design of an iOS Swift app based on customer feedback. I reviewed the feedback, opened Claude Code, described the changes I wanted, and submitted a pull request with adjusted designs. While I was in there, I found and fixed a few bugs too. I never looked at the Swift code directly. I didn’t need to.

In the same day, I updated the colors of a cross-platform Flutter design system directly in code, previewed everything in Widgetbook, and created and adjusted several illustrations including animations. All through AI. All shipped.

That’s not a special day. That’s a Monday.

I built a complete Flutter design system in two days. Not a rough prototype. A production-ready system with components, tokens, and documentation. That used to take months with a team.

I migrated this site from WordPress to Astro using Claude Code. A full platform migration, handled largely through conversation with an AI tool.

I’ve been vibe coding my way through building Mira, an AI-powered customer research tool. As a designer, building a functional product that handles real user data.

And this isn’t limited to personal projects. I apply this workflow on client projects every day. When I spot something in a review that needs fixing, I fix it. No ticket. No handoff. No waiting for the next sprint.

Figma’s role is changing

Here’s where I’ll go further than what Anthropic’s team shared. I think this workflow will largely replace Figma as the source of truth for design. Not kill Figma entirely, but fundamentally change its role.

Figma becomes a sketch tool. A place to quickly test UI ideas, explore layouts, try compositions. But the moment you want to validate whether something actually works, you move to code. Because code is where the real constraints live. Code is where you discover that your beautiful design breaks with real data, or that the animation you imagined doesn’t feel right at 60fps.

I’m already finding it faster to mock things up directly in code than in Figma. When I can describe what I want and see a working implementation in seconds, why would I spend time pushing pixels in a design tool first? The code is the design. The running application is the mockup.

The source of truth should be the thing that ships. Not a static file that approximates it.

The real shift

The design-engineering gap isn’t just closing. It’s disappearing. And the implications are bigger than most designers realize.

This isn’t “designers who code” in the old sense, where you’d tell a designer to learn JavaScript and they’d spend a year getting comfortable with basic DOM manipulation. This is designers who can take their deep understanding of user experience and express it directly through AI. You handle the intent. The AI handles the syntax.

Designers who embrace this don’t hand off specs. They ship. They don’t wait for the next sprint to see if their design survived implementation. They verify it themselves, in real code, in real time. They find bugs. They fix them. They move on.

This changes the role fundamentally. A designer with AI tools isn’t a designer who does engineering on the side. They’re a new kind of practitioner who operates across the entire surface area of the product.

How to start

If you’re a designer and this sounds interesting, stop waiting.

• Get an engineer to help with repo setup. The hardest part is getting the development environment running. Once that’s done, the barrier drops dramatically.
• Use memory files. Claude Code lets you create files that persist context across sessions. Document your project’s patterns, component library, and conventions. This is your leverage.
• Paste screenshots directly. Show Claude Code what you want. A Figma screenshot, a sketch, a reference. Then let it figure out the implementation.
• Get the foundation right. Set up design tokens, reusable components, and a visual system like Storybook or Widgetbook to review and document your design system. This is what makes everything else scale. Without it, you’re just shipping one-offs.
• Skip Figma for small changes. Copy, colors, spacing, layout tweaks. Go straight to code. It’s faster and you’re working with the real thing.
• Don’t try to understand every line. You don’t need to become an engineer. Focus on the outcome. Does it look right? Does it behave correctly? That’s your domain.
• Stop thinking of code as someone else’s job. The entire reason designers couldn’t touch code was the learning curve. That barrier is gone. Act like it.

Ship your vision

For years, designers have been one step removed from the final product. We design in one tool and hope it gets built correctly in another. Every handoff introduces friction, interpretation, and compromise.

That era is over. Not ending. Over. The tools exist today to close the gap completely. Anthropic’s design team figured this out. I figured this out months ago.

The question isn’t whether designers should learn to code. The question is why you’re still handing off your work to someone else when you could ship it yourself.