The Rise of Claude Code. The Death of Figma.

I have not opened Figma, Sketch, Adobe Creative Suite, or any design tool in months.

Not because I lost interest. Because I no longer need them.

Every design decision I make now happens inside Claude Code. Layout. Typography. Spacing. Color. Component structure. Interaction patterns. All of it. No mockups. No handoff. No translation layer between what I design and what ships.

The design tool is the codebase. The design language is built on the fly.

If that makes the design tool industry uncomfortable, good. It should.

The old workflow is dead. Stop defending it.

For fifteen years I followed the same loop. Discover. Wireframe. Mock. Prototype. Test. Handoff. Watch engineering interpret it. Fix the interpretation. Ship something close to what was intended.

That loop was never good. We just accepted it because there was no alternative. We built entire careers, entire companies, entire conference circuits around a process that existed only because our tools were not smart enough to skip it.

Jenny Wen, Head of Design at Anthropic, left a director role at Figma to return to individual contributor work building Claude. Read that again. She walked away from Figma. On Lenny's Podcast she said it plainly: the design process that designers have been taught, that we treat as gospel, is basically dead. She is not being provocative. She is being honest. Sixty to seventy percent of design work used to be mocking and prototyping. Now that number is collapsing because an engineer can spin up AI agents and ship a working version before a designer finishes exploring options.

The discover, expand, narrow framework does not make sense anymore. And everyone clinging to it knows it. They are just too afraid to say it out loud.

Design systems were a bandage. Not a breakthrough.

Design systems exist because teams needed consistency at scale. When forty engineers interpret forty mockups differently, you need a system to constrain the variance.

But what if there is no interpretation gap?

When I describe a component to Claude Code, it does not interpret. It builds exactly what I describe. If the spacing is wrong, I say so. It fixes it in seconds. There is no Jira ticket. No sprint. No design review meeting to align on a 4px padding change.

Design systems were guardrails for teams that could not move fast enough. Claude Code is fast enough.

I am not maintaining a design system for Orbyt. I am building a design language in real time, directly in code, adjusting it as the product evolves. The language lives in the components themselves. Not in a Figma library that drifts out of sync the moment it is published.

The design system industry will tell you this is irresponsible. They have to. Their entire business depends on the problem continuing to exist.

I burned the toolkit. I am not going back.

Figma. Gone. Sketch. Gone. Adobe Creative Suite. Gone. Whimsical. Gone. Every prototyping tool, every wireframing tool, every design-to-code translation layer that made someone a comfortable living selling overhead to teams who did not know better.

All of it replaced by a single workflow: describe what I want, review what ships, refine in real time.

People hear this and think it is a downgrade. That tells me they have not tried it. The fidelity is higher because there is no translation loss. The speed is faster because there are no handoff delays. The iteration cycle is tighter because feedback becomes implementation in the same moment.

I did not trim my toolkit. I torched it. And the work got better. Significantly better.

What Jenny Wen understood before the rest of the industry

When Jenny Wen left Figma for Anthropic, it was not a career pivot. It was a verdict on the entire category. She saw where design is going and walked toward it while the rest of the industry was still debating whether AI would affect their precious workflow.

Watch her conversation on Lenny's Podcast. She talks about how AI will not replace taste and judgment. I agree completely. What it replaces is the infrastructure we built around the absence of speed. The meetings, the systems, the handoff documents, the pixel-perfect specs that nobody followed anyway.

Taste still matters. Judgment still matters. The forty layers of process between a design decision and a shipped product never mattered. We just could not see that until now.

This is not about one tool replacing another

This is about a category collapse. And most people are not ready for what that means.

Figma is a design tool. Claude Code is not a design tool. It is a building tool that happens to make design tools unnecessary for people who have taste.

That distinction is everything. If you need Figma to know what good looks like, you will still need Figma. If you already know what good looks like, Claude Code lets you build it directly without the intermediate representation.

The intermediate representation was the entire business model of design tooling. The entire industry was a translation layer between intent and artifact. And translation layers get eliminated. Every single time.

This is not just design. Product and engineering are already dead too.

Design is not the exception. It is the canary.

Product managers built their discipline around a coordination problem. Translate business intent into requirements. Write tickets. Prioritize backlogs. Align engineering with design with stakeholders. Manage the gap between what was requested and what was delivered.

When that gap disappears, the coordination layer is exposed for what it always was: overhead. The PM who spends three weeks writing a PRD for something that can be built, tested, and shipped in an afternoon is not adding value. They are protecting their own relevance.

Engineering is going through the same reckoning. The engineer who writes boilerplate, maintains build configs, and manually wires components is being replaced by the engineer who describes systems, evaluates output, and makes architectural judgment calls. The craft moves up the stack. The mechanical work evaporates.

Every discipline built on the assumption that building is slow is being destroyed by the reality that building is now fast.

The org charts. The sprint rituals. The cross-functional ceremonies. The two-week sprints to ship what could be built before lunch. All of it was designed for a world where translating intent into artifact took weeks. That world is gone. It is not coming back. And no amount of Agile certification is going to resurrect it.

The teams that win will not be the ones with the best process. They will be the ones brave enough to abandon process entirely and trust taste instead.

The future belongs to the unreasonable ones

The designers who thrive will be the ones who can articulate intent clearly, evaluate output ruthlessly, and iterate at the speed of conversation. Same for PMs. Same for engineers.

The people who need a pixel grid, a component library, a backlog, and a sprint ceremony to think will struggle. Not because those tools were bad. Because the constraint they solved no longer exists. And clinging to dead constraints is not professionalism. It is fear.

I built Orbyt from zero to production in thirty days. No design tool touched. No design system maintained. No PRD written. Every screen, every interaction, every micro-animation built through Claude Code. The product looks and feels like something that took a team of fifteen, one to one and a half years, and a $5M capital raise to build.

That is not a productivity improvement. That is a category shift. And it is available to anyone willing to let go of the old way.

The design process is dead. The product process is dead. The engineering process as we knew it is dead. What replaces them is faster, higher fidelity, and built by people with taste and conviction instead of process and permission.

Stop mourning the old tools. Stop defending the old process. Start building.

See this approach in practice: Orbyt, built in 30 days and AI-native product design.