All Case Files
01 / PROJECT OVERVIEW◆ ARCHIVED

The design system that replaced Figma.

One unified system across 4 enterprise pharma products. I built it in 5 days, designing in code with Claude Code. The handoff loop disappeared, the design team consolidated from 5 to 1, and a new product's MVP frontend now ships in 4 days — not weeks.

The design system that replaced Figma.
FIG · COVER · MONEYTORVIEW DEMO ↗

ROLE

Head of Design

TIMELINE

5 days (Aug 2025)

TEAM

1 designer + 3 engineers

SCOPE

Design Systems, AI Methodology

Leucine is a digital twin of the pharma manufacturing shop floor — an AI-powered, FDA-regulated compliance platform, Series A backed by Ecolab, deployed across 300+ facilities in 10 countries. Four products: MES (Manufacturing Execution), CLEEN (Cleaning Validation), Leucine OS (Quality Management), and FDA Tracker (Compliance Intelligence).

I joined in 2020 as the second designer and grew over six years from IC to Design Lead managing five designers to Head of Design. In August 2025 I rebuilt how all four products get designed: one system, in code, in five days.

Scope, stated plainly: I built the system solo; three frontend engineers handled integration across the four product codebases.

Industry

Regulated pharma manufacturing

FDA-regulated compliance, Series A, backed by Ecolab.

Footprint

300+ facilities, 10 countries

50+ companies running the platform in production.

Products

MES · CLEEN · OS · FDA Tracker

Four enterprise products, one design language.

Tenure

6 years (2020 → 2026)

Second designer → Head of Design.

02 / THE CHALLENGE

Two component libraries. Every screen built twice.

DWI/MES was built on Material UI. CLEEN was built on Ant Design — two products from the same company that looked like they came from different companies. Every new component was built from scratch, twice; every design update was double the work. A customer using both CLEEN and MES experienced two different-looking products from one vendor.

Five designers, forty engineers. The bottleneck wasn't talent — it was the gap between Figma and code. Every design decision lost fidelity in translation.

The handoff loop

PM writes specDesigner opens FigmaHandoff to engineerEngineer interprets3–5 rounds of review“close enough” ships

03 / THE PROBLEM

The problem wasn't the libraries. It was that the design lived somewhere the code couldn't read.

The obvious read was a visual-consistency problem: two libraries, two look-and-feels, unify them. That's the symptom. The actual gap was structural — the design existed as Figma artifacts engineers had to interpret into code, and every interpretation leaked fidelity. Five designers spent most of their time on handoff, review, and rework instead of user problems. The brand inconsistency was unsolvable inside that architecture, because the architecture itself was the inefficiency: a translation layer between intent and implementation.

So the decision wasn't “pick a better library.” It was: remove the translation layer entirely. Ditch Figma, ditch both libraries, build one system in code that engineers — and an AI — can read and build from directly. I evaluated five libraries on three questions most design leaders weren't asking:

Visual control

No opinions to fight

MUI/Ant fight you when you deeply customise. shadcn is headless primitives + Tailwind — full control.

No dependency hell

No shared npm dep

npm packages mean version conflicts across 4 codebases on different release cycles. shadcn copy-paste lives in each repo.

AI-readable

Plain React + Tailwind

Claude Code reads plain React + Tailwind. Proprietary theming APIs (sx prop, ConfigProvider) are barriers to AI composition.

Library

Visual control

No dep hell

AI-readable

MUI v5

Chakra UI

Mantine

Ant Design v5

shadcn/ui

The third criterion — AI-readability — is what almost no design leader was asking for in 2025. shadcn's plain React + Tailwind structure meant the design system could become a Claude Code skill file: a set of instructions an AI could read and build from.

04 / THE WORK

One unified design system. Tokens, components, blocks, and a skill file.

5 days
Build duration
14 × 11
Colour palettes × shades
46 + 16
Primitives + custom components
31
Documentation pages

Foundations — accessibility baked in, not audited after.

14 colour palettes with 11 shades each. Inter + IBM Plex Mono. WCAG contrast compliance built into the foundation at token level — so it can't be violated downstream.

Leucine DS — colour system: 14 palettes × 11 shades
COLOUR · 14 × 11
Leucine DS — type system: Inter + IBM Plex Mono, 11 scales
TYPE · INTER + IBM PLEX MONO

Components — engineers grab the code directly.

46 shadcn primitives + 16 custom components. Live preview and a code tab on every component. Engineers copy the code directly — no copy-paste from Figma-plugin output.

Leucine DS — component documentation with live preview and a code tab.
FIG · 01COMPONENTS · LIVE PREVIEW + CODE TAB

Blocks — the decisions, pre-composed.

Not primitives — pre-composed blocks for login, forms, dashboards, and data tables. Engineers and PMs don't think at the system level, so the blocks carry the decisions for them.

Leucine DS — data table block, pre-composed
BLOCK · DATA TABLE
Leucine DS — sidebar navigation block
BLOCK · SIDEBAR NAV

The skill file — the design system became the designer.

The system is encoded as Claude Code instructions. An engineer describes a requirement; Claude reads the system — tokens, components, blocks — and builds a branded, accessible page that follows every design decision I made, without me in the room.

Claude Code skill file

# Leucine Design System Skill

## Tokens
  primary:  #0052FE
  surface:  14 palettes × 11 shades
  type:     Inter + IBM Plex Mono
  spacing:  4 / 8 / 12 / 16 / 24 / 32

## Components
  46 shadcn primitives
  16 custom (sidebar, topbar, ...)

## Blocks
  login · signup · dashboard
  data-table · form · settings

## Accessibility
  WCAG AA contrast · focus rings
  semantic HTML · ARIA labels
→ reading skill file...
→ composing with shadcn primitives + Settings block
✓ Generated using Leucine DS tokens

They don't open Figma and they don't wait for a designer. They open Claude Code, describe the page, and the skill file builds it with the correct tokens, components, and blocks — branded, consistent, accessible.

05 / THE PROCESS

A 5-day build, because six years told me exactly what to build.

The calendar was realistic only because I knew exactly what to build. Six years inside the failure modes — handoff fidelity loss, double-build overhead, brand drift — meant I'd already designed the system mentally. The five days were execution, not discovery.

DAY 1 · FOUNDATIONS

Evaluated libraries → shadcn/ui. Next.js docs site. Leucine Blue (#0052FE), 14 palettes × 11 shades. Inter + IBM Plex Mono, 11 type scales. WCAG AA contrast baked in.

DAY 2 · COMPONENT PRIMITIVES

46 shadcn components installed + themed. ComponentPreview with live preview + code tab. Started 16 custom components (sidebar, topbar, swatches).

DAY 3 · APPLICATION BLOCKS

Login + signup flows. Data tables, stats cards, sidebar nav. Empty states, pricing pages, modal patterns.

DAY 4 · DOCUMENTATION

31 documentation pages — Getting Started, Foundations, Components, App UI, Examples. Live preview on every page.

DAY 5 · INTEGRATION + SKILL FILE

Integration with 3 frontend engineers. Dark theme via next-themes; final token propagation. The Claude Code skill file written — the design system as AI instructions.

The decisions a Figma-first design leader wouldn't have made:

Decision

What it reveals about how Janam thinks

Evaluated libraries on AI-readability, not docs or community size.

Designs for where the workflow is going, not where it is. In 2025, 'can an AI read and build from this?' was a criterion almost no design leader was applying.

Chose copy-paste shadcn over npm component packages.

Thinks like an engineer about dependency risk. Four products on different release cycles sharing one npm dep is a version-conflict trap; copy-paste removes the shared failure point.

Shipped blocks, not just primitives.

Knows the consumer isn't a designer. Engineers and PMs shouldn't make system-level decisions, so the blocks carry the decisions for them.

Encoded the system as a Claude Code skill file.

Treats the design system as a program, not a reference. A static library describes components; a skill file executes them. The system becomes the designer.

WCAG contrast baked into the foundation, not audited after.

Builds the constraint in at token level so it can't be violated downstream — accessibility as architecture, not QA.

Dark theme via token swap, propagated in one PR across 4 products.

Designs the token layer so a single change cascades everywhere. The leverage is in the system structure, not per-screen effort.

Engineers compose pages directly from the skill file.

Three frontend engineers worked alongside me on integration. Initial pushback — they liked Figma artifacts as visual specs. The breakthrough: composing a settings page from the skill file in 10 minutes, where the same page had taken three days through handoff. I now review at system level (token changes, new block patterns), not page level (button placement, copy). Course-corrections compound.

Leucine DS — a settings page composed directly from the skill file's blocks and tokens.
FIG · 02EXAMPLE · SETTINGS PAGE COMPOSED FROM THE SKILL FILE
06 / THE OUTCOME

The designer-as-bottleneck step disappeared.

4 days
MVP frontend (was weeks)
10 min
Page from blocks (was hours)
4 → 1
Products on one stack
0
Figma handoffs to engineers

The new flow: PM writes a requirement → engineer opens Claude Code → Claude reads the skill file → page built with tokens and blocks → review and ship. The system runs across four products and 300+ pharma facilities, and the brand inconsistency that had persisted since 2020 is gone.

5 → 1, honestly.The design team went from five to one — me. Three found higher-leverage roles inside Leucine (one to product management, two to demand generation), one left for an unrelated opportunity, and one role — producing static mockups for engineers to interpret — was eliminated because that step no longer existed. The system didn't replace people; it replaced the translation step that was consuming their time. Most of the team moved up into higher-leverage work.

One design system. Four products. 300+ facilities. 40+ engineers. And one designer operating at the leverage of five — because the system carries the decisions.

// end of case study

Need someone
who ships?

JANAM.WORKCASE STUDIES© 2026