Magic · Case study
Three AI tools, three different looks, one design system.
A guest-services team on a cruise line gets three AI tools: a chat assistant for crew, a gateway that meters every request, and a tracing tool that records every answer. Each is good at its job. Each looks like a different company made it, because a different company did. And none of them tells a team lead the one thing that matters: is the assistant telling crew the truth?
Magic is my answer, built end to end as concept work. One token file themes all three tools from the outside, without forking any of them. The view nobody shipped, AI Health, I designed in Figma and then built in React, wired to live evaluation data.

The brief I set myself
No forks, no budget, and a real stack underneath.
- Role
- Product design, design system and front end
- Timeline
- Two days, November 2026
- Stack
- Figma variables, React and TypeScript, Open WebUI, LiteLLM, Arize Phoenix, Ollama
- Brand
- Magic, a fictional cruise line made for this concept
- 01Theme the tools, don’t fork themeach of the three ships its own releases, and a fork is a second product to maintain. So every change had to live outside the tool, in CSS and configuration, and survive the next upgrade.
- 02One source of trutha single tokens file feeds the Figma variables and generates the CSS for all three tools and the React app. Changing a colour is one edit, not four.
- 03Real answers at zero costtwo small Llama models run locally behind the gateway, with simulated per-token pricing so the spend screens have something honest to show.
- 04Accessible in both modesWCAG AA contrast in light and dark, keyboard paths through every control, and charts with a text alternative.
The product
Three screens, one system.
Screen 01
Guest Services Assistant
Open WebUI, themed with Magic tokens. Crew ask in plain language and get an answer drawn from the Guest Services Handbook, with the policy it came from attached.

- Every answer cites its source documents, so crew can check before they promise a guest anything
- Suggested follow-ups for the next likely question: draft a reply, show the waitlist, what if they miss all-aboard
- Navy sidebar and cyan actions from the same tokens as every other screen
- A standing reminder to check important details against the handbook
Screen 02
Usage and budgets
The LiteLLM Admin UI, redesigned around the question a team lead actually asks: are we inside budget, and who is about to go over?

- Each team gets its own monthly budget and its own virtual key
- A banner names the team that is over budget before anyone has to read a chart
- Daily spend split by model, so the cost of the larger model stays visible
- Status badges carry a word as well as a colour: Healthy, Near limit, Over budget
Screen 03
AI Health
Phoenix records every trace, but a trace is an engineer’s view. AI Health is the view I designed on top of it: is the assistant telling crew the truth, and which answers need a person to look?

- Four KPIs: answer quality, hallucination rate, thumbs-down and cost per answer
- Eval checks scored against a 95% threshold, with each badge computed from the data
- A needs-review queue that links every flagged answer to its real trace
- Filters by team and by model
Screen 03, in code
The React build
AI Health runs as a React and TypeScript app built from the Figma frame, one component per Figma component, styled only with the generated tokens. Here it is reading live evaluation results from Phoenix, and they are not flattering.

- No UI library: Sidebar, Chip, KpiCard, QualityChart and ReviewTable map one to one to Figma
- Live numbers carry a Live tag, so fixtures are never mistaken for data
- Dark mode comes free from the Dark values of the tokens
- Semantic landmarks, a skip link, and a hidden data table behind the chart
The system
Light and Dark from one switch
Components only ever read semantic tokens, so switching the Semantic collection from Light to Dark recolours every screen without touching a single component.

- Primitives hold raw values; semantic tokens name intent
- Each variable carries its CSS name, like var(--magic-action-primary), which is the hand-off to code
- Inter for the interface, Roboto Mono for trace IDs and keys
- Composite text styles only, never a loose size or weight
How it was built
Six steps from tokens to running code.
Chapter 01
Start from the token file
Before a single screen, one tokens file: primitives for raw values, semantic tokens for intent, Light and Dark modes. It became the Figma variables, and the brand cyan failed its first test there: 2.9:1 with white text, so primary actions moved to a darker cyan.

Chapter 02
Components that only read tokens
Core controls and the chat and data pieces, every one bound to semantic tokens and nothing else. That rule is what lets three different products look like one, and what makes dark mode a switch rather than a project.

Chapter 03
Theme Open WebUI from the outside
Open WebUI reads its grays from CSS variables, so remapping those variables to Magic neutrals recolours the whole app in both modes. The sidebar turns navy by re-scoping the same variables, the way an explicit variable mode works on a Figma frame. The few targeted rules hang off stable ids, not class names, which change between releases.

Chapter 04
Theme LiteLLM without touching it
LiteLLM has no setting for custom CSS. So a small proxy adds one stylesheet link to its dashboard pages and nothing inside the image changes. The stylesheet points the dashboard’s component variables at Magic tokens and swaps its hard-coded chart colours for Magic series colours.

Chapter 05
Build the view nobody shipped
AI Health went from Figma frame to React screen with no UI library in between. The same build script that themes the tools writes the app’s token CSS and one class per Figma text style, so design and code cannot drift apart quietly.

Chapter 06
Make the numbers real
A dashboard of invented numbers proves nothing, so the evals run for real. Every traced answer is scored on the four checks from the AI Health screen, written back to Phoenix, and shown with a Live tag. Thumbs from chat sync in too, so human ratings sit next to the judge’s.

Evidence
Data that changed the decisions.
What I learned, and what’s next
Designing for tools you don’t own means designing the adapters.
Every surface here belongs to someone else’s release schedule. So the design system is more than a Figma library: it is a token file, a build script and a small adapter per tool that maps that tool’s own variables onto Magic. When a release renames a class, the theme survives, because it targets variables and stable ids instead.
The fragile part is known and named. LiteLLM’s chart colours are hard-coded in its JavaScript, so the theme matches each value. If a release changes that list, the charts fall back to stock colours without breaking anything else.
Next: a larger golden set built from real human reviews in Phoenix, where every thumbs-down with a reason becomes a ready-made calibration case for the judge. Evals on a schedule, so new answers are scored as they arrive. And dark-mode screens in Figma, to match the dark mode already running in code.