The handoff is dead. Now what?

The gap we normalized

On one project, I spent a week on a transition. The timing, the easing, the way an image fades as you scroll past it. I had it exactly right in prototype. Then it went through handoff. The developer was careful and talented. It still came out wrong. Not broken. Just flat.

The problem wasn't the developer. The problem was that you cannot write down feel. Redlines don't capture timing. Figma annotations can't explain why 200ms matters and 250ms doesn't. The spec sheet was always a lossy format, and we built an entire industry ritual around pretending otherwise.

How much survives the translation

Every stage of a handoff compresses something. The intent you had in your head becomes a frame. The frame becomes annotations. The annotations become code. The code goes through QA. By production, a remarkable amount of what you originally meant has evaporated, and nobody did anything wrong.

The numbers are an estimate, obviously. But the shape is right. And the shape should be alarming. Nearly three quarters of the original intent, gone. Through a process everyone treats as standard practice.

What AI actually did

AI didn't break the design handoff. It exposed how broken it always was.

It's the 70/30 rule scaled up, something I wrote about recently. AI handles the first 70% of any design task brilliantly; the last 30% is where craft lives. The handoff is what happens when an industry tries to make the 30% travel through spec sheets and redlines. Specs can carry the first 70% fine. They have no language for the rest.

When design-to-code tools arrived, a lot of people expected them to fix the handoff. They made it faster. The output is syntactically correct and emotionally empty, which was already true of most handoff outcomes, just slower.

If a machine can produce a mediocre translation of your design file in seconds, why is a team of careful humans spending three days producing the same mediocre translation by hand? The question answers itself. The handoff was never doing the thing we told ourselves it was doing. AI just made the ritual impossible to keep performing with a straight face.

What the loop looks like instead

The projects I've been happiest with were the ones where I designed and built from end to end. Not because I'm a better developer than the developers I work with. I'm not. But because the person making design decisions was also the person feeling their consequences in code, in real-time.

A recent project: I was adjusting an empty state animation in the browser when I realised the chart sitting next to it had to go. It only became visible once I saw how the empty state breathed without competition. That decision could not have happened in Figma. The empty state was a 200ms transition, not a static frame. It also could not have happened across a handoff: by the time the chart's removal made it back through specs, redlines and tickets, the animation would have been frozen.

Understanding happens in the real environment, with real data. Not in screenshots and assumptions. Designing happens in motion, which means you can feel a transition before you ship it instead of hoping the developer reproduces it. You wrote it, you own it. Nothing gets lost in translation because there is no translation.

This is already happening

A growing number of companies have stopped trying to fix the handoff and started hiring around it. Linear has been explicit about "design engineers" for years. Vercel and Raycast built their hiring around the same role. Different products, same pattern: one person owns a precise scope of the product from intent to shipped code. The handoff between design and development doesn't get fixed. It gets absorbed into a single role.

This isn't a future scenario. It was already true for senior ICs at the right kind of company. What's changing is that it's becoming the explicit hire instead of a happy accident of someone's career path. It's also, for what it's worth, the role I've been deliberately building toward, which is partly why I'm writing about it.

The part nobody wants to say out loud

This requires designers to be comfortable with code that isn't perfect. With prototypes that look rough. With owning outcomes rather than deliverables. That's uncomfortable in a profession that has spent decades building identity around the quality of its artefacts.

The standard objection is that most designers don't want to code, and most companies aren't structured for designers who do. Both are true. Neither changes the underlying problem: the handoff doesn't work because no spec sheet can carry feel. Restructuring teams is one answer. Pretending the gap isn't there is the only answer we've been trying for twenty years.

It also requires developers to include designers earlier: in their tools, in their pull requests, in their reviews. Both sides have to give something up.

The handoff isn't dead because AI killed it. It's dead because we finally have an excuse to stop pretending it ever worked.