For twenty years, every product I designed started in Figma. Or Sketch before that. Or Photoshop before that. And if I am honest about how far back this goes, a printout and a red pen.

The order of operations never changed. You design first. You build second.

That order is now broken. And I could not be happier about it.

The old way had a shape

Here is how product design worked for two decades.

You opened a blank canvas. You designed screens. You wired them into a clickable prototype. You ran it past stakeholders, tested it with users, and polished the flows. Then, and only then, you handed it to engineering to make it real.

Design was the source of truth. The build was the translation.

It was a good system. I built a career on it. I scaled design systems on it. I led UX at Trusted Shops on it, where a single misaligned button could ripple across millions of sessions.

But it always carried a quiet assumption: that the most expensive, most uncertain part of building software was the code. So you de-risked with pixels first, because pixels were cheap and code was not.

That assumption just collapsed.

Vibe coding flipped the order

Today I open Claude Code and describe what I want. Minutes later the thing exists. It runs. It has real data, real state, and real edge cases that no static Figma frame ever forced me to confront.

The functionality is suddenly the cheap part.

So the smart move is to let it go first.

You vibe-code the product until it works. Then you bring in design. Not as decoration on top of a mockup, but as craft applied to a living, breathing thing that already does its job.

This is the inversion. Design does not start in Figma. It does not start in a clickable prototype. It starts in the running product, after the functionality is already there.

Functionality first. Craft second. And the craft is where twenty years of taste finally pays off.

I know how that sounds to a lot of designers. Heretical. Backwards. Like letting the contractor pour the foundation before the architect shows up.

But I have been doing it for months now, every day, on real products. And the work is better for it.

Why designing last is actually designing better

When you design on top of a working product, three things change.

You design against reality, not assumptions. The empty states are real empty states. The error you forgot about is sitting right there on screen, daring you to ignore it. You cannot hand-wave the hard twenty percent that static mockups quietly skip.

You stop polishing screens nobody keeps. Half of what gets prototyped never ships. Designing after the build means every bit of craft lands on something that is actually staying.

And you get to the part designers are truly for. Hierarchy. Typography. Spacing. Motion that means something. The difference between a product that works and a product that feels world class. That layer is exactly where two decades of craft live, and it is the layer vibe coding cannot reach on its own.

Because here is the honest truth about a vibe-coded product: you can tell. The logic is solid and the screens scream that an AI made them. Generic components. A confetti of emojis and gradients. Spacing that drifts a little further with every prompt. It works, but it has no taste, because taste was never in the loop.

That is the gap I step into.

But redesigning screens is not the bold part

If all I did was repaint vibe-coded apps by hand, I would just be a very expensive coat of polish. The redesign would look great on Tuesday and erode by Friday, because the next prompt knows nothing about the system I just built.

So I do something else.

I teach the robots.

This is the part I find genuinely thrilling. When I bring design to a vibe-coded product, I am not only fixing today's screens. I am encoding the taste into the tools, so tomorrow's screens come out right on their own.

Design tokens for color, type, spacing, radius, and elevation, defined once and read by the agents on every task. A CLAUDE.md that knows your brand. Skills that turn vague taste into rules an agent can actually follow. Guardrails that block a hardcoded hex value before it ever reaches a user. Review gates that catch drift the way a senior designer would, except they never sleep and never get tired of saying no.

The deliverable is not a folder of mockups. The deliverable is a product that designs itself a little better every time someone prompts it.

That is twenty years of design judgment, compressed into a system an AI inherits and applies at three in the morning while I am asleep.

This is the new frontier

We spent a decade teaching designers to think like engineers. Design systems, components, tokens, handoff. The new frontier is the opposite move: teaching the engineers, and now the agents, to think like designers.

Not by hiring a designer for every team. By encoding design taste into the place the work actually happens. The repo. The agent. The prompt.

I have lived both sides of this. I have the twenty years of craft, the design systems built and run at scale, the UX leadership. And I ship real products end to end with Claude Code every single day, so I know exactly how to make these tools produce craft instead of fighting them for it. If you want the longer version of that journey, I wrote about going from designer to full-stack builder and becoming an app developer.

Most people pick one side. The pure designer who will not touch the terminal. The pure builder who treats taste as a nice-to-have. The whole point is standing in the middle, fluent in both, and using each to lift the other.

If your product works but does not feel like it

You vibe-coded something real. It functions. And you can feel that the design has not caught up.

That is not a failure. That is exactly the right moment for me to come in.

I bring highest-class UX and UI on top of what you built. I turn it into a real design system with tokens. And I wire Claude Code and Codex so every screen your team ships from here stays on brand by default, not by luck.

Functionality first. Design second. The robots, taught to keep it that way.

See how I turn vibe-coded products into something world class.