Marcel, Carrefour's design system, had two ways in: designers opened the Figma library, developers installed the package. AI tools had none, so they invented. I gave Marcel a third way in — an API that any AI assistant queries before it draws — and the same rules now reach everyone who builds: designers, developers and product teams.
1
Pass, not 3–4
÷2
Figma Make credits
35
Tools
3
Audiences
01 — AI, the third user
By 2026, vibe design was everywhere. Figma Make, Cursor, Lovable, v0: anyone could generate a plausible screen in minutes. Working alongside Carrefour product teams, I saw the other side of it — fast, plausible and off-brand. A random blue, an 8px radius, a "Submit" button, a table full of "John Smith".
A human fills the gaps in a design system with taste. A model fills them with invention. Every invention is a correction, every correction a paid round trip, and user tests end up reacting to the mockup instead of the journey.
Guess, or query the source
Without a source of truth, the correction loop stays with the designer. With one, the model asks before it draws.
02 — What API-izing a design system means
An API is a contract: ask a precise question, get a precise answer, in a format any program can read. API-izing Marcel did not change its content. It changed how you reach it. The designer reads it, the developer installs it, the machine queries it — through the same door, under the same rules.
The Model Context Protocol is the standard plug between an AI and a source of truth. Plug the design system into the standard rather than into one tool, and every assistant that speaks MCP speaks Marcel.
Same door, three users
The thick line is the whole point: where a person fills the gaps with years of craft, a model needs everything written down.
The contract, concretely
Each question the model would otherwise answer from memory maps to a tool that returns the real value.
An LLM that invents is guessing. Marcel knows.
What the API serves
Form is not enough: the right component says the wrong thing if it speaks badly. Voice and content is the layer generic AI tools never have.
Who it serves
The same investment, served to more people each time. The MCP doesn't add a channel, it unifies them.
03 — For designers
Prototypes that look like the product, from the first prompt. In Figma Make there is nothing to install: Marcel is deployed as a connector for the whole organisation. Type @Marcel in the chat and the model picks among 35 tools on its own — the designer never drives a tool.
What changes: one pass instead of three or four corrective iterations, user tests that test the journey again, half of all revisions sent back to the canvas at zero credits, and the whole system — catalogue, tokens, icons — explorable without opening the nine Figma libraries.
One sentence, orchestrated
build_screen turns one sentence into a locked plan, and the model fetches structure, exact specs and wording before drawing anything.
build_screen in production: "@Marcel I want a drive order tracking screen, mobile, light mode" — Marcel components, resolved tokens and approved copy, on the first pass.
Then one question — "what is missing from this order tracking screen?" — and the model calls get_components, get_ux_writing_rules, get_page_patterns and get_glossary on its own, and returns a compliance audit: components to swap, wording to fix, critical gaps.
Same screen, before and after the audit: a Functional Notice in the Info tone, a driver section with Avatar and call buttons, an Accordion of products with substitutions and totals, and wording that follows Marcel's Constructive principle — "Votre commande arrive dans environ 45 min." Two prompts, zero specs written by hand.
An assistant that says "do it yourself"
Most AI tools encourage you to re-prompt, and every turn is billed. Marcel classifies the request first, and half the time sends you back to the canvas.
Marcel also answers with interfaces, not paragraphs: the component catalogue, the token explorer and the 501 icons open inside the conversation as MCP Apps. Search, filter, click — without leaving the chat.
04 — For developers
The same facts, compiled to your stack. Clone the repository and the server runs in Claude Code, Cursor, Cline, Windsurf or Zed. The coding assistant stops guessing paddings: it asks get_component_specs and gets 4px, 56px, #0970e6 — resolved values, not token names a framework would ignore.
For tables, get_table_recipe ships MarcelDataTable: React on TanStack Table v9 — the library on Carrefour's TechRadar — with CSS variables generated from the tokens. What Marcel generates rests on the same foundation as what the developers build.
Facts, not code
The server serves neutral data and never presumes the stack. The client decides what a token becomes.
One server, every assistant
Plugged into a standard, not a tool: the next AI assistant ships already speaking Marcel, with no integration project — and the choice of model stays reversible.
01
Scraped from Figma, not from documentation
Specs come from the components themselves in the 9 Marcel libraries. The first scrape already corrected a belief: Marcel's default radius is 4px, not 8px.
02
Static JSON, zero runtime calls
Data is bundled with a stateless server on Vercel and read in milliseconds: no live Figma call, no rate limit, no API token in production. Metrics are written after the response, so monitoring adds no latency.
03
Kept in sync
A drift check runs in CI against the Figma REST API, and a sync skill re-extracts what changed while preserving 249 hand-written passages.
04
Next: a design gate in CI
Today the specs plate Marcel onto any stack to prototype. Tomorrow the same specs drive Carrefour's own web components and lint every front-end pull request before merge.
05 — For product teams
Anyone who can write a sentence. A product manager mocks up a need without waiting for a designer, and the screen already follows the rules. clarify_design_brief asks the right questions in a single card — goal, key elements, constraints, definition of done — and the decision frameworks settle Modal-or-Drawer without a review meeting.
Stakeholders react to content that looks real: get_sample_data fills screens with credible, seeded Carrefour data — store formats, real house brands, delivery slots — and zero real data. And for teams building chat agents, Marcel themes OpenAI ChatKit widgets from its own tokens and audits them.
The right questions, before the first pixel
An incomplete brief costs three to four iterations. Step 0 refuses to generate until a single question card has collected everything.
Same rules, without the brand
PMs on Lovable get the same Marcel — components, radius, icons, typography, writing, data — without the brand colour. A screen a designer can pick up downstream, that never passes for a finished deliverable. Feedback colours stay, so an error still reads as one.
06 — Measured, shipped
AI costs money, and framing is what limits the investment. Three levers cut calls without losing quality: a complete brief from the first prompt, rules attached once per session as memory, and gradient deduplication — a repeated call returns the full answer, then a reminder, then a simple reference. Efficiency is observed, not assumed: a dashboard tracks calls, latency, errors and who calls what.
The teams' first reflex was exact values, not exploration: get_component_specs leads production usage, ahead of get_design_rules and the system overview. First-prompt compliance halves Figma Make credits, with a 0% tool error rate.
March → September 2026
242 commits in six months. Each release is named after the problem it removes, not the feature it adds.
07 — What's next
Reading is only half the way. Today Marcel answers "the radius is 4px". Next it generates the compliant component, detects the drift and pushes the fix — audits of a franchisee's live site, a design gate on every pull request, accessibility checked continuously ahead of RGAA 2026, and onboarding where the design system answers for itself. No more evangelism: a design system plugged into the pipeline proves its value by running, not by explaining.
From a read API to an operating layer — generate(), lint(), deploy(), orchestrate() — with agents orbiting the design system the way components once orbited the library.
The design system is no longer documentation you read. It is a service you plug in.