The setup: small fixes, a crowded backlog
Minor design fixes rarely fail for lack of value. They fail because they need a ticket, and a ticket drops them behind everything engineering has already committed to. A written description also tends to strip out the nuance—"tighten the spacing" or "the screen reader announces this wrong" becomes a screenshot thread, with the engineer translating decisions the designer could have made in the code.
The workflow follows a fictional example: the Museum of Speculative Futures (MOSF) is rebuilding its site architecture while trying to improve accessibility. The engineer stays on the rewrite; the designer takes the small, craft-level changes end to end using Figma Make with the production codebase, from canvas through review to a merged pull request, without filing a ticket. The team coordinates through Figma Design and Figma Make, with the Figma agent, the GitHub integration, Make with production code, and annotations. The cast is one designer, one engineer and one product manager.
Pressure-testing the live experience
Before building anything, the designer uses the agent in Figma Design to generate synthetic personas—a first-time visitor planning a trip, a returning member, someone navigating with a screen reader—and has each one move through the site. Synthetic personas are not a substitute for real research; the point is to surface obvious friction early so in-person sessions can go deeper.
The findings are mostly small: a confusing label on the exhibition page, an easy-to-miss call-to-action, a date picker that's hard to parse at a glance, and a search that dead-ends on a blank screen when a collection returns no results. Individually minor, together they decide how usable the site is.
The designer applies the changes and walks them back through the team, which signs off on the clearer visit-page label, the more visible call-to-action and the friendlier date picker as serving the shared goal.

Editing the codebase directly
Here the handoff flips. Rather than describing work for an engineer, the designer implements it and the engineer reviews, so engineering judgment lands at the review stage instead of during implementation. With the changes small and agreed, the designer asks for repository access, the engineer grants it, and the designer connects the project's GitHub repository to Make. The production code is then live inside Figma.
The designer branches off the current site and starts with the date picker, the apparent five-minute change. Working against code rather than a mock, Make reveals what the canvas can't: the picker is a shared component, used on the events calendar and in the membership sign-up flow as well as the exhibition page. A ticket scoped to the exhibition page would have updated one instance and left the other two on the old version.
The rest of the list follows: the clearer label, the more visible call-to-action, the improved empty states.
Accessibility decided during review, not after
The team's final review is where the accessibility goal becomes concrete. The visible fixes are in, and the team annotates how each one should behave for assistive technology in place. That covers the aria-label the shared date picker should announce, a screen reader label that matches what appears on screen, a focus order that reaches the call-to-action rather than skipping past it, and an empty state whose message a screen reader can announce so an empty result isn't a silent answer. Accessibility here is settled in the same review as the onscreen appearance.
The PM checks the work against the accessibility goal, the engineer flags what should be handled in code, and the designer folds in last tweaks.
From Make to a merged PR
Once the annotations are addressed, the designer pushes a pull request to the codebase straight from Make. The design intent, team comments and accessibility annotations travel with the same change, so the reviewing engineer sees them attached to the diff. The engineer approves and merges the branch—work that would otherwise have spent a quarter in the backlog ships in a day.
Unlike a ticket, which closes and carries its reasoning away with it, the merged change persists: comments, accessibility annotations and the rationale for the shared date picker all remain. Six months later, the history of the decision is still with the team.
Where this handoff fits
The traditional assembly-line model still suits large, well-defined features. Finishing work—the polish and accessibility improvements that shape the full experience—benefits from having the designer use code directly. Nobody has to change roles: engineers stay on the architecture, the designer owns the refinements, and the PM keeps the project pointed at its goal. The last 20% ends up shipped rather than cut.



