Design handoff used to be a file transfer. You drew a screen, exported its assets by hand at every screen density the platform supported, zipped them, emailed the zip to a developer, and waited days to find out whether the design worked. In 2026 the same loop can close in an afternoon. This is what actually changed, and what did not.
What did design handoff look like before Figma?
In 2013 I was drawing interfaces in Photoshop. There was no shared file, no inspect panel, no auto-generated spec. Handoff was a manual export job, and it went roughly like this.
You finished the screen. You hid every layer that was not the icon you needed, trimmed the canvas, and saved it out. Then you did it again at the next density. iOS at the time wanted 1× and 2×; the third rung, @3x, arrived with the iPhone 6 Plus in 2014. Android wanted its own ladder entirely — mdpi, hdpi, xhdpi, xxhdpi and eventually xxxhdpi — so the same button could leave your machine as eight files with eight names, and one wrong suffix meant a blurry asset in production.
Then you wrote a spacing spec in a separate document, because the file itself could not tell anybody that the gap was 24 and not 20. You zipped the folder. You attached it to an email. And then you waited, usually two or three days, to see the screen running.
Why was design handoff so expensive?
The obvious answer is labour, and the obvious answer is wrong. Exporting assets was tedious, but tedium is cheap. The real cost was latency: the distance between making a decision and finding out whether it was any good.
When that distance is three days, it changes how you behave. You stop testing directions and start defending them, because testing is expensive and being wrong in public is expensive twice. You over-specify, because a question costs another round trip. You pick the safe layout, because the adventurous one might cost the sprint. Every habit that made mid-2010s design process feel heavy — the long specs, the sign-off meetings, the pixel-perfect redlines — was a rational response to a slow feedback loop.
What changed between 2013 and 2026?
Not one thing. Four, and each one removed a different part of the wait.
- Sketch made exportable slices a property of the layer instead of a manual job, and moved interface design off a photo editor.
- Zeplin, from 2015, killed the spec document. Measurements and assets became something a developer could pull rather than something a designer had to push.
- Figma, from 2016, put the file in the browser and made it multiplayer. Handoff stopped being an event with a date on it and became a link that was always current. Dev Mode later made that explicit.
- Design tokens turned decisions like colour and spacing into named values shared by design and code, so the two stopped drifting apart between releases.
By 2023 the export step was essentially gone. What remained was the last and largest gap: a design was still a picture of a product, and turning the picture into a running product still took a development cycle.
What can prompt-to-app tools actually do in 2026?
That last gap is the one currently collapsing, and it is worth being precise about what these tools do, because they are not interchangeable.
- Rork describes itself as a way to create mobile apps by chatting with AI and ship them to the App Store. It targets mobile, iOS first, and the output is an installable app rather than a picture of one.
- Lovable generates production web applications from a prompt, and is aimed at people who do not write the code themselves.
- v0, from Vercel, generates React components using shadcn/ui. It fits teams already inside that ecosystem and assumes somebody can read React.
- Figma Make turns a prompt or an existing design into a clickable, functional prototype. The important boundary: the output lives inside Figma. It is not production code you own, and it is not a native mobile app.
Put plainly: some of these produce a convincing prototype, and some produce software you can ship. Choosing the wrong one for the job is the most common way teams lose a week to this category.
Slicing assets was never the job. It was the tax we paid to find out whether the job had been done well.
What still does not work?
Generated products are strongest where the problem is conventional and weakest where it is not. A sign-up flow, a settings screen, a list with filters — these arrive close to right. A workflow with real domain rules, an interface that must degrade gracefully on bad data, a state machine somebody will have to maintain in two years: these arrive plausible and wrong, which is more dangerous than arriving obviously broken.
Accessibility, empty and error states, and anything that depends on knowing your users rather than knowing patterns still need a designer to ask for them by name.
What does this mean for product designers?
The change is not that we produce faster. It is that the number of decisions you can afford to be wrong about has gone up. When a direction took two weeks to see, you picked one and argued for it. When it takes an afternoon, you can put three genuinely different structures in front of a team and let the comparison end the argument. That is less advocacy and more evidence, and it is a better job.
It also relocates the bottleneck. Producing options is now cheap. Knowing which option deserves to exist is not, and nothing in this generation of tools has made that part faster.
I exported assets by hand for years and I do not miss it. But the part of that work I was proud of is exactly the part that survived — and it was never the export dialog.
Read next
