I’m Manvi Singh

← All work

Case study · IPLM · AI workflow design

A design-to-code orchestrator, with people in the loop.

RoleLead designer on IPLM, one of 3 designers
WithEngineers, co-designing
Built withVS Code, Claude, Storybook
OutcomeLess rework, faster iterations, fewer tokens
Design-to-code orchestrator: our rules, do’s and don’ts and design system, built inUser storyfrom the PMSpecyou approveComponentsStorybook onlyWireframesyou refineSandboxreal componentschanges notify the PMcorrect, then go onflags anything new

Human checkpoint: a designer reads, corrects and approves before anything moves on.

IPLM is a set of connected Perforce products, so three of us design across it, and I’m the lead designer on IPLM. When we moved to AI-assisted design-to-code with VS Code and Claude, the AI kept ignoring our design system.

So, with our engineers, we built a design-to-code orchestrator. It turns a product manager’s user story into a spec, wireframes and a working design sandbox, using only our real components, with designers and product managers approving along the way.

The problem

The AI kept inventing components.

Even when we told it not to, it created new components and new wrappers instead of using what already existed in our Storybook.

An illustration, not our real code.

Fixing it by hand didn’t scale.

The environment was new, so at first we couldn’t even name the problem. We corrected the output, rewrote the spec again and again, and tried different methods to see what worked.

rewritten, again

Visuals didn’t help either.

Connecting Figma through MCP didn’t fix it: the AI still reached for different components. It did better when we described what we wanted in writing than when we gave it visuals.

An illustration of what we saw.

The workflow

One command. The spec first, then the build.

I brought the problems we kept hitting. Our engineers proposed a design-to-code orchestrator, and we designed its workflow together. It combines several agents, with our rules, do’s and don’ts and the design system built in, so nobody has to write them again each time.

An illustration: one command, then the user story.

  1. User story in. Paste the product manager’s story; it drafts a spec.
  2. Spec, approved. The designer reads, corrects and approves it. Spec changes notify the PM.
  3. Components, checked. It lists what it will use from Storybook and flags anything new.
  4. Wireframes, refined. We shape the flow and behaviour in the chat.
  5. Sandbox, built. A working design sandbox with our real components and behaviour.

Rules written once.

Our rules, do’s and don’ts and “use our Storybook” live inside the orchestrator, so nobody has to repeat them in every prompt, and nobody forgets them.

An illustration.

Where the human time goes.

We spent most of our time reading and approving the spec. That’s where the human in the loop sits: once the spec is right, the build needs far less rework.

Plan well, read the spec, approve it. Then build.

It shows what it will use, before it builds.

Once the spec is approved, it lists the components and UI it will use for the sandbox, all from Storybook, and flags anything new so a designer decides before it exists.

An illustration.

Wireframes first, changed in the chat.

Before any code, it sketches wireframes. We decide the flow and behaviour there, and make corrections right in the chat, while changes are still cheap.

An illustration.

Approvals that don’t wait for time zones.

If I change the spec, my product manager has to approve it, because his user stories need to match. The agent notifies him. We work in different time zones, so I log the pending approval and keep going; he reviews and comments when he’s online, and we follow up.

An illustration of how an approval moves.

Recommended isn’t always right.

When the orchestrator offers options or asks a question, we don’t just click the recommended one. We pick what’s best for the product and for what we want to achieve.

An illustration of the kind of choice we make.

What happened

Less rework.

Rules and components are built in, and anything new is flagged, so we stopped correcting the same things.

Fewer tokens.

We weren’t vibe coding anymore. A written, approved spec replaced trial-and-error prompting, so we spent far fewer tokens.

Faster iterations.

From a user story to a working sandbox, with changes made in the chat as we go.

Real components, real behaviour.

Sandboxes use the product’s own Storybook components and behaviour.

Part of our move to AI-assisted design-to-code, which took feature delivery from 4–5 weeks to 2–2.5 weeks.

More work

← Back to all workGet in touch →