I Used to Send Red Arrows. Now I Fix What They're Pointing At.
For most of my career, developers finished my designs.
Now I'm in the code with them.
Slightly wrong, every time
Every design I handed over came back slightly wrong. The spacing drifted. The easing got swapped for a default. The hover state got cut to save a day.
None of it was malice, and most of it wasn't even carelessness. It's what happens when the person finishing the work is optimising for a different thing than the person who started it. A developer under deadline pressure makes a hundred small calls a day, and "close enough to the Figma" is a perfectly rational standard when the sprint ends Friday. The last ten percent of a design, the part that makes it feel considered instead of assembled, belonged to nobody.
The red arrow economy
My feedback was always the same. A screenshot. A red arrow. What was wrong, what it should be, and a reference to the original design.
Most pages had 20 to 30 issues.
Do the working out on that. Twenty to thirty annotated screenshots per page, each one written up, ticketed, prioritised, then argued about, because every red arrow was me asking someone to reopen finished work. Half of them got fixed. The other half got labelled polish and died in the backlog. Whole days of my working life went into producing documentation about pixels I could see but not touch, a QA theatre where the details that make design invisible were exactly the ones cheapest to cut.
The red arrow was never really feedback. It was a permission slip, from someone who could see the problem to someone who could reach it.
Where the handoff moved
AI moved the handoff.
On websites, I now build the whole thing myself. What goes live is what I designed. This site is that workflow, and so was the app I shipped without a dev team. The spacing is mine. The easing is mine. If a hover state is missing, there's exactly one person to blame.
On apps, where real engineering is involved, the line moved somewhere more interesting. I've gone from handing over specs to maintaining and adding components directly in Storybook. Developers lead the engineering. I own how each component looks and behaves.
That split matters. I'm not pretending to be an engineer, and nobody wants a designer refactoring their data layer. But the component library is where design lives or dies in production, and it's now territory I can work in rather than write letters to. The excuse that designers can't build didn't just die for side projects. It died inside client codebases.
The contract changed
The old contract was: designers describe, developers interpret. Every handoff was a translation, and translation is where the drift lived. The new contract is an ownership boundary instead of a translation layer. Engineering owns how it works. I own how it looks and behaves, all the way into the merged branch.
It also changes what clients get from a design retainer. I used to watch systems I designed drift for years after project handoff, because the person who cared about the details left when the Figma file was delivered. Now staying engaged means the components stay true in the codebase itself, not in a reference document nobody opens.
The arrows were the ceiling
I've watched design die three times in my career, and every death was really a tooling shift that moved where designers could reach. This one moved us into the repo.
I used to send red arrows.
Now I fix what they're pointing at.
---
