Point of view

Is the source of truth moving from design to code?

AI and the future of design systems

For years we treated the design file as the source of truth. In an AI-native workflow that no longer holds, and the shift is already underway in the tools we use. This lays out why the mock was never really the truth, what replaces it, and what changes for designers.

1 · The problem

The mock was never really the source of truth

We said the design file was the source of truth: Figma held the canonical screens, engineering implemented them, and if the build did not match the file, the build was wrong. But a picture under-specifies intent. It cannot fully express logic, states, data, or behavior, so every handoff is lossy and engineers end up reverse-engineering what we meant. The file drifts from the build, and the thing everyone trusts is never the thing the user actually experiences. The file was treated as the source of truth. It never quite was.

2 · Why it bites hardest for the design system

A design system trapped in Figma cannot enforce anything

A design system that lives only in Figma is a library of pictures. It is not typed, linted, or tested, engineers re-create it by hand, and parity quietly drifts. Worst of all, a generator can ignore it: a design system that exists only as a drawing is a suggestion, not a rule.

The pattern is already here. Ask today's AI tools to build a UI and they reach for a code-first component system by default, chosen by the tool, not by us. (shadcn is the current example, but the point is the pattern, not the project.) If our system is a Figma library, the machine now building most interfaces is already skipping it.

3 · The shift

The truth did not move. It untangled.

We say the source of truth is moving from design to code. That is close, but not quite it. The truth never lived in one place, we just kept it tangled inside a single file. Pull it apart and it becomes a relationship between two truths, held together by a contract. Each answers a different question:

Intent what & why
Lo-fi sketches, flows, and the conceptual model: goals and taste. The intended truth, what it should be. True by aim.
Code what ships
The running system people actually experience. The real truth, what exists. True by existence.
Design system contract what holds
Tokens, component specs, and rules, enforced in code. Intent made precise enough that code cannot quietly drift from it. The agents build from it, and it governs everything.

The work lives in the gap between intent and code, where AI agents build from the contract: they generate the code and render what we look at. Two things are never the truth: the visual layer (Figma or a quick HTML render) is how we see the gap, a surface to discuss, never the contract. The continuity layer (a shared git and branching system) keeps intent, contract, and code in sync over time and across teams. It is plumbing, not truth.

Truth is a relationship, not a place

Source of truth Built copy
Before: a design-led workflow One purple box labelled Intent and Figma file carries a star and is treated as the single source of truth, collapsing intent, the artifact and the truth into one. Code is a plain built copy made by hand from a lossy handoff. BEFORE · DESIGN-LED ★ Intent + Figma file Treated as the one source of truth Intent + artifact + 'truth', collapsed into one Handoff Code A built copy One file plays every role. That overload is the tangle we pull apart below.
Intent Code · the real truth Visual layer · we discuss
Now: truth as a relationship between intent and code A neutral design-system contract of tokens, specs and rules, enforced in code, governs production from the AI agents through the code, while intent stays free. The AI agents, a neutral engine, build from it. The two truths are intent on the left, a green box for what it should be, and code on the right, a purple box carrying the star for the real truth, what exists. A tinted gap zone, where the design work lives, wraps intent, the AI agents engine and the visual layer. The agents generate the code and, separately, render the visual layer; feedback from the visual layer loops back to intent. Code sits just outside the gap as the real artifact the work produces. NOW · CODE-LED, AI-NATIVE LOCKED Design system contract Tokens · component specs · rules · governs everything Intent Goals + taste Intended truth: what it should be AI agents Generate + render The engine ★ Code The real truth · what exists Figma / visual layer For discussion and feedback A lens, not the law Agents build from it Generates Renders Feedback · intent updates WHERE THE DESIGN WORK LIVES Truth didn't move from design to code. We untangled it from a file into what it always was: a relationship between intent and code.

4 · What this unlocks

Ambiguity out, leverage in

Putting the contract in code removes the lossiness from step 1 and the no-enforcement problem from step 2 in one move. The spec is the handoff, so nothing is reverse-engineered. Change one token and it cascades to every screen. The agents produce on-spec UI instead of guessing. And because the prototype is real code, we test actual logic with users from day one rather than testing a picture of it.

Rebuilding on a real contract also opens flexibility that was painful to maintain by hand. These stop being per-screen chores and become capabilities we define once and get everywhere:

Dark mode Theming Localization Responsiveness Density layouts Motion & animation

5 · What it means for designers

The function of design does not change. The medium does.

Product designer

WasDrew hi-fi mockups in Figma as the contract. Redrew every state, fought drift, and watched intent get lost in handoff.
NowExpresses intent (lo-fi, flows, conceptual model), then curates and tests the running product, debating hierarchy and motion on the real thing.

Design system designer

WasMaintained a Figma library engineers re-created by hand, with no way to enforce it.
NowAuthors the contract in code, tokens, specs, and rules that are enforced and that the agents actually build from. The system becomes infrastructure.

Judgment, advocacy for the user, exploration, and craft all stay. Only the medium changes. Still, this changes how most product designers work day to day, and it can feel threatening, so it needs care and empathy. The answer is a dual path: run the old and new models side by side and let people cross over when the new way earns their trust, rather than forcing the switch.

The cost

A strong default quietly narrows variety

The trade-off of a contract this strong is sameness. When everything is generated from one foundation, products drift toward looking alike and the long tail of variety gets quieter. The answer is not to weaken the contract but to be deliberate about where novelty lives: divergent, off-contract exploration (lo-fi, throwaway, where taste roams) matters more. The contract governs production, while intent exploration can still happen outside via lo-fi mocks.

Next steps

From point of view to pilot

This is a point of view, not a plan. The natural next step is a pilot, run as a dual path so the new model can prove itself next to the old one rather than replacing it overnight. After running a concrete experiment from code back to Figma, the early results are promising, since the visual layer is re-created with utmost fidelity to what exists in code, and allows for a discussion and deliberate rendering and correction of visual bugs.

My evolving AI posture V3 · Darío Fidanza