The handoff is dead

Let me just say it plainly. The design-to-engineering handoff is dead, and I don’t mean that as a prediction for some panel a few years out. I mean I’m building a design function right now, from scratch, and I’m building one that never has a handoff in it.

Here’s the thing about the handoff. For my whole career it has been the center of gravity in how products get made. Design decides how something should look and feel, wraps that up in redlines and specs and a Figma file with a hundred named layers, and tosses it over the wall to engineering. Engineering rebuilds it from the spec. Design checks the build against the mockup. Both drifts apart. Somebody reconciles them. We call this collaboration. It isn’t. It’s translation, and we’ve been paying for it so long we stopped seeing it as a cost.

I want to be fair to it, though, because the handoff was not stupid. Two crafts that can’t check each other’s work need a contract, and the spec was that contract. It let a designer hand off without knowing how to code, and an engineer build without knowing typography, composition, and heuristics. Clean lines. If the build didn’t match the redline, that was on engineering. If the redline was wrong, that was on me. The wall held weight. So when I say I’m not building one, I’m not calling the people who built that process fools. I’m saying the one thing that made the wall necessary just disappeared.

So what changed?

For years, the most a technically minded designer could do was argue well inside the medium. I could reason about state and components and hold my own in a room full of engineers, but I still couldn’t produce the actual thing. So the handoff stayed, because it had to.

That’s the part that broke. With AI in the loop, a designer can author the production front end directly. Not a prototype. Not a “dev-ready” file. The actual shipping code. I remember the first time an idea of mine became real, on-system UI in a single afternoon, and my honest first reaction wasn’t excitement. It was suspicion. It felt like a trick, so I kept poking at it, waiting to find the catch, the hidden place where the old cost was still being paid. I’m still poking. The catch keeps not being where I expect it. And once a designer can produce the actual thing, the contract has nothing left to enforce. There’s no translation step anymore, because the person who decided how it should feel can be the person building how it feels.

I am building the function, not inheriting it

Let me get concrete, because this is easy to nod along to and easy to not believe.

The company I joined is more than a decade old, and I’m the first designer it has ever employed. Sit with that for a second. Ten-plus years of enterprise product built without a single designer, and now, a couple hundred screens of it now mid-migration onto a modern stack. I have approved headcount, a set of open roles, and the rare luck of building a design function in 2026 instead of inheriting one shaped in 2015. Which means I get to decide what goes into it before the habits set.

So here’s the decision: no handoff. Not “let’s streamline the handoff.” No handoff. The bridge artifacts never get created in the first place, because the people doing the deciding are the people doing the building.

And I’ve already run the loop on myself. The first real artifact of this function wasn’t a strategy deck. It was a component library: the tokens, the primitives, the screen templates the rebuilt product gets assembled from. I authored it, pushed it to the org’s repo, and the engineering manager who owns the front end reviewed it the way he’d review anyone’s code. The review came back with real flags. I fixed them, and it merged. Nobody rebuilt anything from a spec, because there was no spec. There was the thing itself, and a second craft checking it.

I’ve been chewing on why that exchange felt so different from every design review I’ve ever sat in, and I think it’s this: nothing was being translated. We weren’t comparing a build to a mockup and negotiating over whose version wins. We were both looking at the same real thing. I didn’t expect that to change the texture of the conversation as much as it did.

But me proving the loop works proves almost nothing. I can code. The real job is making this work for a team, safely, at scale, without the whole thing falling apart the first time someone ships something broken. That’s the part I’m in the middle of right now.

And the day a designer on my team merges production code for the first time? It’s coming, and I’m dreading it a little. Running the loop on myself was one thing. It’s another thing entirely when the person merging isn’t me, shipping real code to real users on my say-so. Not because I don’t believe in this. Because I do, and that’s exactly what makes it real. Belief is cheap while it lives in a doc. And yet part of me is impatient for that day anyway, because whatever it turns out to teach me, I’ll learn more from it than from another month of preparing for it. So I’m doing both: preparing, and watching for what I can’t predict.

The guardrails

Here’s the big one, and it’s the part the keynote version of this idea always skips: killing the handoff is not killing engineering, and it is not killing review.

Every line of front-end code a designer commits gets reviewed by an engineering counterpart. Wait, isn’t that just the handoff sneaking back in through the side door? No, and the difference matters. The old handoff said “rebuild this from my spec.” The new review says “this is already built, is it correct, is it safe, does it sit right on the system underneath.” One is a wall between two crafts. The other is a craft checking a craft. From far away they look the same. Up close they’re opposites, and if you can’t tell your team which one you’re running, you’ll get the worst of both.

None of this is me sneaking something past engineering, either. My CTO’s framing for the whole org, his words before mine, is that everyone is a builder: designers ship the front end with oversight, and engineers get reserved for the genuinely hard things, the architecture, the data, the systems the front end runs on. The model arrived with engineering’s endorsement, not around it. If you’re trying to install this against your engineering org instead of with it, you’re building a different, worse thing.

The other guardrail is who I hire. This only works with designers who can reason about the medium and aren’t precious about who’s holding the keyboard, so that’s what I’m hiring for, on purpose, ahead of the need. Does it fit every designer? No. It doesn’t. Some of the best visual designers I know aren’t wired for it, and I haven’t figured out what I owe them as this shifts under their feet. That’s an open bill, not a solved problem.

So what is the job now?

If the handoff was the tax, and I’m not installing it, the obvious question is what the work is even made of once it’s gone.

My read is that the lowest-value parts of the job go away and the highest-value parts get more of the designer. The week that used to go into bridge artifacts goes into research, into deciding what’s actually worth building, into tuning the feel of the live thing. That’s my bet. But a bet is not a result, and I’m writing this partly to keep myself honest about the difference. And here’s the what I am most curious about. Not whether a designer can ship production code; I’ve settled that one on myself. It’s where the freed hours actually go. Maybe they really do flow into research. Maybe they quietly get eaten by more meetings. The team’s calendars will tell the truth, and when they do, I’ll tell you. Right now I know where I’m steering. I just don’t get to know yet where it lands.

What I am sure of is small, and I’ll say it twice because I mean it: I am not installing the translation layer between deciding and building. I am not building it in, and I am not going to. I think the teams still paying the translation tax are going to feel slow in a way they can’t fix by hiring more people to run the handoff better.

The thing that makes all of this possible is that the front end suddenly got cheap to build. And that changes a lot more than the handoff. It changes what a first version is even for. That’s what I want to pull apart next, because once building is cheap, what counts as expensive moves, and I know of teams that haven’t noticed yet. They’re still standing guard over the finished screens, the asset that just got cheap, while the thing that was always expensive, knowing what’s worth building at all, sits unguarded.