Writing & talks

AI in the design process

A practical path from a Figma library to working code, built together with developers. I gave this as a workshop to the product design team at Roomex, a Corpay company, in November 2026. Here is the short version, with the slides that matter.

Format
Workshop for the product design team at Roomex (Corpay), November 2026
For
Teams with a design system in Figma and a component library in code
Deck
20 interactive slides with live examples

Where most teams are today

Designers have one system, developers have another, and nothing keeps the two in sync. The design system lives in Figma: components, styles, years of screens. The component library lives in code, often in Storybook. AI already sits on both sides: Claude reads and draws in Figma through MCP, and Claude Code reads and writes the codebase through GitHub. But there is no shared source, so every new screen is drawn once and built twice.

Slide: designers have a design system in Figma and Claude connected to Figma; developers have a component library in code and Claude Code in the repository; between them, no shared source.
Two systems, two AI assistants, no shared source.

What I already do

AI is part of my daily work, not an experiment.

  • 11 → 3.5 days from brief to clickable prototype on ASI Central, built in code and pushed to GitHub as a starting point for developers.
  • 6 shared agents for the design team at Valor Software, with agents and skills documented in Notion.
  • 31% → 64% completed driver registrations on Uride, where AI and OCR fill in document data inside the product.
  • This site is built and run in code with Claude: 141 commits in the first 16 days of November, 115 of them co-written with Claude.

The goal: one system for people and agents

Figma and code connect through two things. Tokens: colours, type, spacing and corner radius in one JSON file, where every change is a reviewed pull request. Components: the same buttons, cards and tables in Figma and in code, linked by Code Connect. Designers and developers change the same values, and Claude reads the same source.

Slide: Figma with variables, components, frames and flows on the left; code with CSS variables, components, flows and pages on the right; in the middle, tokens in one JSON file and components linked by Code Connect.
Designers explore and review in Figma, developers build and ship in code, both from the same tokens and components.

Six steps from Figma to code

  1. Audit what you already have · 1–2 daysClaude reads the library through the Figma MCP and writes a report: raw colour and spacing values, detached or edited instances, duplicate components, and a proposed token set based on what is really used. People decide what to fix and which tokens to keep.
  2. Turn styles into variables · 3–5 daysThree layers of names for one colour: a primitive (green-400), a semantic role (accent) and a component place (button-primary-bg). Components never use a raw colour. A rebrand changes one link; dark mode switches the semantic layer, and components don’t change.
  3. Export one JSON file to the repository · 1–2 daysEvery change to the file is a pull request reviewed by the other side. A developer can propose a token change too, and a CODEOWNERS rule asks for both approvals.
  4. Developers generate code from the same file · 2–3 daysA build tool such as Style Dictionary turns the JSON into CSS variables, iOS and Android values on every merge. Change a value once, and Figma and the product move together.
  5. Connect Figma components to real code · 1 weekCode Connect tells Claude: don’t draw a new button, use ours. Start with 10–15 components: button, input, select, date picker, card, modal, table.
  6. Write the rules once · 2 days, then it growsA rules file in the repository: only components from the library, only tokens, every state designed, AA contrast, visible focus, the product’s own words. Plus shared skills for briefs, UX copy, design QA and spec notes. See an example rules doc for a button.
Slide: a colour goes from #52E0A1 to green-400 to accent to button-primary-bg to a button; a table explains primitive, semantic and component layers.
Step 2, using my site’s own tokens as the example.

How work with developers changes

Handoff becomes a pull request. Instead of a Figma link and specs in a ticket, developers get a pull request with a preview link and real components already in place. The prototype is a starting point, not production code.

A designer builds two ideas with Claude, each on its own branch with its own preview link. The whole team comments on both live previews, picks one, a developer approves the pull request, and it becomes the new main.

Slide: main splits into branch A and branch B built with Claude, each with a Vercel preview; the whole team comments, picks A, a developer approves the pull request and A becomes the new main.
A feature end to end. Example: a manager approves or declines a booking request.

Feedback moves from screenshots to the live page. PMs, developers and managers pin comments right on the preview, even on a call without the designer. The PR owner gets notified, tells Claude to check the comments, and Claude commits the fixes to the same pull request, replies and resolves each thread. The preview updates on the same link until nothing is open.

Slide: a feedback loop from pull request to comments on the preview, notification, Claude fixing and replying, and the preview updating.
Comment on the prototype, not the picture.

Six weeks, one real feature

The plan I proposed needs no budget and no reorganisation: one design-system designer and one front-end developer, part-time. The audit and variables come first, then the JSON export and Code Connect for the top components, then a prototypes repository with previews and the rules file, and finally a pilot on one real feature, a retro and a playbook.

Slide: a six-week Gantt chart with audit, styles to variables, JSON export and code tokens, Code Connect, prototypes repository, rules file, a pilot feature, and a retro.
Design, developers and work done together, week by week.

AI does the making. People decide.

AI draws variants and states, writes prototype code, checks contrast, tokens and states, and summarises research notes. People choose the direction, review and merge the code, judge the experience and talk to users. Speed comes from AI; quality and accountability stay with the team. The time AI saves goes into craft, product metrics and strategy.

What you can start tomorrow

  1. Run the audit promptOn your main library, through the Figma MCP you already have.
  2. Pick one componentThe button: variables, JSON, CSS and Code Connect, end to end.
  3. Choose the pilot featureSmall, real and visible, with one developer who is curious.

Start small: one component, one feature, measured.

Open the interactive deck

Live examples from the deck

Read nextLeading design at Valor SoftwareHow I hired and grew the team, gave feedback, led people through layoffs, and built a Claude system for the designers.

Need someone to lead
your
design team?

I’m looking for a Head of Design role, remote from Spain. English, Ukrainian and Russian, intermediate Spanish.