The AI-Native Design Workflow
I've spent the last few months studying how Linear, Cursor, and Anthropic actually work. Not the marketing. The real workflows.
What I found surprised me. These are teams shipping some of the most polished products in the industry—and they've basically thrown out the traditional design process.
Linear's Figma files are intentionally "messy." Cursor's Head of Design ships features without creating specs. Anthropic's designers make "state management changes you typically wouldn't see a designer making."
This isn't chaos. It's a different way of working.
The shift
The old way:
Design → Spec → Handoff → Build → QA → ShipThe new way:
Idea → Build + Design + Test → ShipThe difference isn't just speed. Designing and building happen at the same time. You discover edge cases by building, not by trying to anticipate them in Figma.
Ryo Lu from Cursor describes it as sculpting. You get something, poke at it, rearrange parts, do it again. The process is generative, not sequential.
Code is the source of truth
Not Figma. Not documentation. Code. The actual running product is the ultimate reference, and everything else is temporary scaffolding to get there. Linear figured this out early. Karri Saarinen:
"The design is only a reference, never any kind of deliverable itself, so the way it's constructed doesn't really matter."
They screenshot the live product and design on top. No parallel systems to maintain. When there's a question about how something works, they look at the code.
I stopped trying to keep Figma in sync with production. It's a whiteboard for thinking, not a filing cabinet for specs.
Design through building
Start building sooner, even if the design isn't "complete." Use Cursor or Claude Code to prototype in real code, not Figma. Discover constraints by building and iterate in the actual medium.
This feels uncomfortable at first. You want to figure everything out before writing code. But the truth is, you'll learn more in 30 minutes of building than 2 hours of pushing pixels.
The Figma work becomes minimal—just enough to think through the problem. Most design work happens while building.
Fluid roles
At Cursor, the boundaries between disciplines have dissolved. Designers ship code, engineers make design decisions, and no one waits for someone else to "finish their part."
"Roles between designers, PMs, engineers are muddy."
This requires trust. You trust that engineers won't ship ugly UI because they respect craft. You trust that designers won't ship broken code because they test their work. Quality becomes cultural, not enforced through process.
If trust is low, start small. Let people build confidence through low-risk experiments.
AI-friendly documentation
If AI agents are your collaborators, put documentation where they can access it. Design decisions in markdown files in the repo, component behavior in code comments, design system rules in a DESIGN_RULES.md. Ryo Lu puts it simply:
"Keep design docs and checklists in .cursor/ so the agent has full context on what to do next."
When I start a Cursor session now, the AI already knows my system. It reads the rules and understands the constraints. This changes everything.
Figma as whiteboard
Use Figma to explore ideas quickly. Use it to communicate "what if?" scenarios. Use it to get alignment before building.
Don't use it as the authoritative record. That's what code is for.
Figma is like an architect's napkin sketch. The actual blueprints are the code.
Linear accepts that their Figma files will be messy and out of date. They archive old files, screenshot production for new work. This used to feel wrong to me. Now it feels liberating.
Quality through iteration
Linear's quality doesn't come from extensive planning—it comes from obsessive iteration on the actual product. As Karri Saarinen puts it:
"We started with quality."
Ship something good, then make it great. Polish in production, not in mocks.
Don't wait for perfect. Wait for "proud to ship."
The hard parts
I should be honest about what makes this difficult. This workflow demands real cultural shifts, and not every team is ready for them.
Figma files will be messy. If you care about pristine design systems, this will bother you. I've learned to let go.
Roles feel uncomfortable. Designers become responsible for code quality. Engineers make design decisions. The discomfort is growth, but it's real.
Trust is required. This workflow assumes everyone cares about quality. If trust is low, it won't work. You can't process your way to trust—you have to build it.
Some features still need upfront design. Complex flows with multiple stakeholders still need alignment before building. But most features aren't this complex. Don't over-plan the simple stuff.
The tradeoff
Here's the thing I keep coming back to: you can't have tight design control AND rapid AI-assisted iteration. You have to choose.
Traditional designers had authority through gatekeeping. AI-native designers have influence through collaboration.
That's not a downgrade—it's a different skill. But it requires letting go, trusting the team, and accepting that others can ship too.
If you want control over every design detail, this workflow will frustrate you. If you want speed, iteration, and collaborative quality, you have to embrace distributed authority.
The choice is yours. But you can't have both.