In a typical handoff, a designer sends a file and a developer rebuilds every screen by hand. They re-measure the spacing, guess the states and add accessibility at the end. The sprint goes on pixels, and the real work waits.
The idea
I deliver the screens as code in your stack. Your developers then spend their time wiring up the things only they can: data, state, validation and APIs. The visual layer is already done, and it was built from the design, not from memory.
In your stack
The code should look like your team wrote it. So I build in what you already use, Angular, React or React Native, and I follow your conventions for files, naming, styling and components. Code that fights your codebase costs more to adopt than it saves.
How I run it
- Claude Code reads the components, variables and layouts through the Figma MCP, instead of guessing from images.
- It reuses your existing components and tokens, and I only add new ones where nothing fits.
- I build the screens responsive, with every state and proper keyboard and screen reader behaviour.
- I review the code against the design before it goes anywhere.
- It arrives as a GitHub pull request, with a diff your team can read and comment on.
- I add handoff notes: what is built, what is left for logic, and what still needs a decision.
What good UI code looks like
- Components with clear props, so logic can be added without rewriting them.
- No hard-coded values. Spacing, colour and type come from tokens.
- Accessible from the start: real elements, labels, focus order and contrast.
- Realistic placeholder data, and clear places where the real data goes.
What you get
UI code in your stack, a GitHub pull request and handoff notes.
Where it goes wrong
Treating generated code as finished. I review it the way I would review a colleague's work. Another mistake is building a second set of components when you already have one, and skipping the handoff notes, because the next person needs to know what is done and what is not.
All writing