Design to code

Removing the translation layer between design and code

  • Design systems
  • AI operations
  • Process design
  • Team enablement
  • 2026
A line of code, <Button variant="brand" />, on a light grid above the purple Make a video button it renders, selected with handles and labelled Button. In the loop the code line switches to other components, each rendered below it. A prompt then rounds a project card’s corners to 16px, the design canvas and web app copies of the card change together, and the card moves into its place on the Catalyst home page.

Product updates, new features and UX improvements at Socialive used to take months to get from design to production. I rebuilt how we design and ship software around a single source of truth in production code. Designers, product managers and engineers now build within shared guardrails, and the same work takes days.

Role
Led the system design, workflow and rollout
Team
8 people across design, product and engineering use the workflow daily
Timeline
2026 to present
Outcome
Production code is the source of truth for design, with automated checks for UI, UX and copy

The bottleneck was translation

Our designs lived as static mockups. Engineers rebuilt each one by hand, and every rebuild introduced small differences that led to another review. Most of our time went to handoffs, review cycles and revisiting decisions made months earlier. Even small UX improvements could take months to ship.

A timeline of the old process on dark navy: Idea, then days to a static mockup, then weeks to a stakeholder decision reviewed as static screens, then weeks to shipped code rebuilt by hand. Three handoffs are labelled along the line, and a dashed arc from shipped code back to the mockup is marked one to three rounds of rework.
The old path from idea to shipped code: Three handoffs, weeks between decisions, and rework looping back to the mockup.

Removing the translation layer took three steps

Step 1: Prototypes in code

I moved prototyping out of static mockups and into code with Claude, starting with the Catalyst prototype. Stakeholders could click through real flows instead of reacting to pictures of them. Prototype creation went from days to minutes, iterations per feature went from 1 to 3 up to 10 or more, and design decisions that took weeks now take a day.

The Catalyst prototype: A dashboard with a prompt box, recent videos and a sidebar, inside a browser-like frame.
The live Catalyst prototype, built in code. Click around: On a phone it shows the mobile layout.

Step 2: Connecting the canvas

We adopted Paper, a design tool built on HTML and CSS, and connected it to Claude through its MCP server. Design and code shared tokens and components, which brought the canvas and the product much closer together. It still left us with two places to maintain.

The Catalyst 2.0 design file in Paper: A Buttons page showing six variants in every state, with the primary button selected. The property panel on the right shows its height of 40, padding of 16, gap of 8, a radius of 999, and a fill bound to the token dark-action-primary with text bound to dark-text-inverse.
The primary button selected on the Paper canvas. Its fill and text are tokens, and the panel shows the rest of its values.

Step 3: Code becomes the source of truth

We moved the source of truth into our React components in GitHub, because that is the layer closest to where AI writes code. An agent helps write components from our code tokens and primitives. Paper is still where we try quick visual ideas to work out what’s worth building. Once the code is written, the Paper file is regenerated from it and organizes itself: Approved design sections update, and earlier iterations move to an archive. Nobody spends time keeping design files up to date, and nothing is left to translate.

Button.astro in a dark code editor: The primary variant's background and color use the tokens color-dark-action-primary-default and color-dark-text-inverse, and the base button sets a height of 40px, padding set by the spacing-16 token, gap set by spacing-8, a full radius and body text size, with each matching line labelled fill, text, height, padding, gap, radius and label. A preview pane shows the rendered button.
The same button in Button.astro: The same tokens and values, and the button they render.

Design standards now run as part of the build

Designers still define the standards. Instead of enforcing them through review, we built them into the workflow:

  • Shared design rules guide every component and screen the agent builds.
  • A drift check flags anywhere design and code fall out of alignment.
  • A copy check tests interface text against Socialive’s writing guidelines.
  • A UX review catches usability and accessibility issues, like a button with no label for screen readers.
A terminal session on dark navy. The prompt reads run the quality checks on CatalystBanner.tsx before I open a PR. The drift check finds 2 issues: a hardcoded background colour where the library token is color-action-primary, and a 12px radius that isn't in the scale, where buttons use radius-full. The copy check flags a button label, Book A Demo Today, written in title case and ending in an exclamation mark. The UX review finds a dismiss button with no accessible label for screen readers. An update to CatalystBanner.tsx fixes all 4 issues, shown as a diff, and the session ends with All checks pass. Ready for review.
The checks run before a pull request opens. Each issue names the rule it breaks, and the agent fixes all four before review.

Designers, product managers and engineers all ship interface work directly

Engineering was hesitant at first, so adoption came from results rather than a mandate. Today 8 people across design, product and engineering use the workflow daily, and all of them prototype and implement interfaces with confidence. Designers ship their own UI changes instead of handing them off, and product managers and engineers no longer wait on design approval for every decision.

The design role has changed too. Our designers spend less time policing consistency and more time building it into the process. Instead of reviewing and refining every decision myself, I build systems that make good decisions easier for everyone.

The same timeline as the old process, now on a gradient from cyan to violet: Idea, then minutes to a working prototype built in code by designers, PMs and engineers, then a day to a decision tested as a real experience, then days to shipping, built from the same component library. The steps are labelled anyone on the team builds, click through and decide, and drift and copy checks run, with ticked Drift check and Copy check badges above the last step. A dashed arc back to the prototype is marked ten or more rounds of iteration.
The path today: A working prototype in minutes, a decision in a day, and shipped work in days, with drift and copy checks on the way.

Each tool has a defined role

  • Claude: Builds flows, components and features
  • GitHub: Holds the React component library, the source of truth
  • Paper: Quick visual iteration before code, then a canvas regenerated from the code once it’s written
  • Automated checks: Drift and copy checks against our standards
Three tools on dark navy, each an icon above its role. Claude Code for building, writing flows, components and features in code. GitHub, highlighted, as the source of truth, the repositories that hold the React component library, with an arrow to Paper. Paper as the visual reference, for visual iteration before code and a canvas generated from it. A bracket joins all three to a panel reading Guardrails set by design, checked on every build: UX copy, brand drift, UX review and code quality.
Claude Code builds, GitHub holds the source of truth and Paper is the visual reference. The guardrails design sets are checked on every build.

Impact

  • Product updates, new features and UX improvements: Months → days
  • Prototype creation: Days → minutes
  • Iterations per feature: 1 to 3 → 10+
  • Design to decision: Weeks → 1 day
  • People using the workflow daily: 8 across design, product and engineering
  • Design files updated by hand: None. The canvas is generated from code.

Larger initiatives still take longer, and complexity and nuance haven’t gone away. What’s gone is most of the friction between design and code.

Part of a wider AI operations system

This workflow is one of several AI operations systems I’ve built at Socialive to help a small team work at a larger team’s scale. A case study on the wider AI operations work is coming soon.