Handoff Is Dead: What Replaced It in 2025

We canceled our Zeplin subscription this summer. That sentence is doing a lot of work, because the subscription wasn’t really the point. The point is we stopped treating handoff as a step in the process and started treating it as a surface that engineers read from continuously. It’s a small change in framing that reorganized how our whole team works.

01. Handoff as an event was the real problem

For years, our flow looked like this: design a screen, polish it, freeze it, “hand it off.” There was a ceremony. There was sometimes a meeting. There was, inevitably, a week later, a Slack message that started with “hey quick question about the spec.”

The quiet assumption under all of it was that design was a thing you finished and then passed, intact, to engineering. As if an interface could be done in one tool and then manufactured in another. That assumption was wrong in a hundred small ways that added up to the wrong shape of relationship between the two teams.

Treating handoff as an event meant every ambiguity became a negotiation. Every spec gap became a meeting. Every late-stage change became a delta someone had to track in a comment thread somewhere. It was friction dressed up as process.

02. What continuous collaboration actually looks like

With Dev Mode mature enough to trust, the wall disappeared. Engineers now pull what they need, when they need it, directly from the file: tokens, variables, spacing, typography, measurements, component references. The design file is no longer a picture of an interface, it’s a structured data source that happens to also be visually readable.

“Mark as ready for dev” became the designer’s equivalent of a Git commit push. It’s not a ceremony, it’s a signal. This slice is stable enough to pull from. If I rework it later, the signal flips, engineers see that, and the state of the world is always legible without a meeting.

“Handoff used to be a wall we threw designs over. Now it’s a shared sandbox.”

The other thing that changed, quietly, is that engineers stopped asking me questions that designs shouldn’t have to answer out loud. Margins, states, variant behavior, all of that is in the file, in the tokens, or in the component itself. The questions I do get are higher-level now, about intent and edge cases, which is, uncomfortably, where my attention should have been all along.

03. What this demanded of me

The catch, and there’s always a catch, is that I can’t design the way I used to.

I used to think in arbitrary groupings: a few rectangles, loosely aligned, vibes-driven. It looked fine in Figma. It fell apart in code, because code doesn’t do vibes. Now I have to design with implementation constraints from day one. Flexbox, grid, intrinsic sizing, token-bound spacing. If I group things in a way that no layout engine could reproduce, I’m just drawing a lie.

That was the hardest adjustment. It felt, at first, like giving up a kind of freedom. Then it stopped feeling like freedom lost and started feeling like pretending to have options I never really had. The production artifact was always going to be flexbox. I was just spending extra energy to pretend otherwise in Figma.

The result, a few months in, is that my files look more like component libraries than like mood boards. They’re boring to scroll through. They’re great to build from.

04. Closing

Canceling Zeplin was the cheap part. The real cost was mine: updating how I think about a design file and who it’s for. It’s not a gallery anymore. It’s a working surface that my engineering partners live in as much as I do.

If your team still has a dedicated handoff step, I’d at least sit with the question of what that step is actually protecting. In our case, the answer turned out to be “my old habits,” and those weren’t worth the friction.