Letting Designers Ship Components Straight to Production with AI Agents
How a web team ended the build-it-twice cycle: designers write in the production library with agents, engineers review the contract, and a week of work becomes an hour.
This article is published in English.
Sources: Design engineering at Bolt: shipping components with AI agents
A ride-hailing company's public web platform reaches tens of millions of people a year across more than fifty markets. It rests on a shared design system with over a hundred and ten UI components. The front-end team changed how those components get made: designers now ship working code straight into the production library with the help of AI coding agents, and routine component delivery dropped from about a week to about an hour. The interesting part is not the speed. It is what the team removed to get there, and what it chose to keep.
The gap a design file cannot close
Auto layout, hover states, focus order and text direction all fit in a Figma file. Every situation a browser must cope with does not. Engineers traditionally filled in the remainder: the component API, the keyboard model, and what a screen reader announces. Nobody recorded which decisions had quietly passed from designer to engineer along the way.
Coding agents shrink most of that translation work. A designer working alongside an agent can now produce a component that actually runs, which leaves a different job for everyone else: reviewing the component instead of writing it a second time.
How the same component got built twice
Designers on the team never stopped at Figma, though they still begin there with exploration, tokens and the states a component needs. The next move was not a handoff. They opened a coding agent and built the component inside an internal Storybook, where each state renders in isolation. The agent produced a version, the designers inspected it across themes, widths and text directions, described what looked wrong, and the agent revised it.
The result was a real component and not a picture of one. It compiled, it reacted to a real browser, and its states could be clicked through.
Then the work stopped. The component lived in that internal Storybook with its own conventions, while the production site was assembled from a completely different library. The outcome was a pair of Storybooks, each a source of truth, joined only by a ticket.
Two sources of truth drift apart. A spacing token changes in one place and not the other. A dark-mode or right-to-left state exists on one side only. The designers have already decided how hover differs from keyboard focus, or how a long German label should wrap, while engineers work from a ticket drafted before those checks happened. Two honest copies of one component slowly turn into two different things.
So engineers picked up the ticket and built the component again inside the production library, working from a written description of something that already existed and ran. On a project board both builds look like ordinary work, and nothing seems off.
That second build felt like due diligence, but it was not. The designers already held a running version, and the engineers retyped it so it could live in the library the production site actually uses. Drift was the predictable outcome of keeping two Storybooks. It was a structural property of the setup and not a failure of discipline.
Adopting a job title or a new tool was never the motive. The pipeline was still designed around a handed-over picture, and designers had long left that world. Retyping wasted effort, two Storybooks guaranteed drift, and the whole lifecycle presumed that implementation was the slow step. With agents, typing got quick, so the delay moved to the stages around it and to the rebuild in the middle.
In the new flow, the two amber stages from the old diagram, the same component written twice, collapse into one. Designers write it once, in the production library. Review becomes wider, with two engineers plus designers signing off on visuals, where before a single engineer read a diff by hand. Review grows by less than implementation shrinks, and that difference is the saving. For routine components that fit the design system, it comes to hours and not a sprint.
From reproducing to judging
A picture handed over by designers leaves engineers with one job: reproduce it. Working code leaves nothing to reproduce, so the open question is whether the component is right. Does its API sit well with the rest of the library? Do its semantics work for a screen reader? Does it hold up at every breakpoint and in both text directions? That question was always the one that mattered, but it used to come last, after the typing had been paid for. Now it comes first, and the same quality bar costs less because the review covers something that already exists.
What actually changed
Design engineering here means shared ownership of one artifact. Designers may ship components in the repository, and engineers own the API and the architecture. Rather than passing a description between teams, both groups work on the component itself.
The shift needed no new tool or title, only access to the correct codebase. Designers now work directly in the component library that powers the public pages, using the agent-and-Storybook loop they already knew. What they iterate on is exactly what goes live.
That only works if agent output is safe to review, so the team wrote its expectations into an AGENTS.md file. The instructions there set the library's quality bar:
- Reuse the existing tokens.
- Build on top of accessible primitives.
- Write stories for each meaningful variant.
- Do not touch unrelated code.
The file also marks boundaries, separating public pieces from internal ones and from anything that should live outside the component library.
The rules exist to protect the library as a product. Public APIs stay as they are unless a breaking change is deliberate, established conventions win over novel patterns, and every change is kept small enough for confident review. The aim is not merely code that works. It is code that stays predictable for every team that depends on it.
A companion skill supplies the order of work. Before starting from a Figma frame, an agent checks whether the component or interaction already exists, decides whether it should be public or internal, then builds the story and verifies the outcome. The frame acts as the visual specification. It is not a source of pixel values to copy or an excuse to invent an API.
With the instructions, the guardrails and the sequence together, agents get enough context and structure to produce components that belong in the library.
The review model
Designers open a pull request. CI and Chromatic run, and the designers accept the visual changes. Two engineers then review the API, accessibility and architecture, and the designers merge.
Review is divided by who can judge what:
- Designers own visual correctness, tokens, motion and states, all signed off in the visual review.
- The two engineers own the component API, accessibility semantics, architecture and test coverage.
Visual review sits with designers and not engineers for a practical reason. They accept a change in the very place it appears, with no diff to read and no engineer squinting at a screenshot on their behalf.
Before and after
The old pipeline produced a working component in an internal Storybook, a ticket, and then a second component in the shipping library. Visuals were approved from memory, or by engineers examining a screenshot.
In the new pipeline, designers work in the same library the live site is built from, approve the pixels in Chromatic, and leave two engineers to review the contract. When a component already fits the system, getting from a running prototype to a merged change takes hours, all of it review.
The costs the team accepted
The main risk is the plain one. Designers paired with an agent can turn out something that looks correct and is not: an API that clashes with the rest of the library, a control with no accessible name, or a story that only exercises the easy path. Write access means such a component can actually be merged. For that reason the contract belongs to two engineers and the visuals to the designer, so that nobody pretends to review everything.
The merge gate itself does not encode "two engineers". GitHub counts two approvals from anyone with write access, so the pairing is a convention of the review model. If the convention slips, the risk returns.
Review is now the bottleneck on purpose. If those two reviewers are slow, the waste has moved and not disappeared.
Designers must also run the repository locally. The setup friction is real, and the only remedy so far is a contribution guide and one paired session.
Finally, this route is meant for components that fit the system. A genuinely new pattern has to be added to the library by someone before an agent can imitate it. Components with dense state, interruptible motion or unusual semantics still need engineers writing them, not just checking them afterward.
What carries over to other teams
- Build each UI component once. When designers can generate working code that suits the system, what follows should be a review.
- Keep a single shared component library. Parallel Storybooks and ticket handoffs breed drift, so whatever designers build should be what ships.
- Put guardrails where agents can follow them. Written instructions and conventions steer agents toward components that belong, and away from accidental breaking changes or stray patterns.
- Save engineering judgment for where it matters. New patterns, intricate state and custom accessibility still call for engineering skill, while routine work gains more from checking a component's contract than from retyping a design.