Design systems were built for a world where humans made every pixel by hand. They kept teams consistent, reduced chaos, and allowed products to scale across many contributors.
That world is changing. And systems designed around human behavior don't transfer cleanly to machine behavior.
Then: Systems That Kept Humans Consistent
Design systems emerged to solve two human problems: inconsistency and scale.
Left alone, designers drift. They recreate patterns, bend rules, introduce variation. As teams grow, this compounds. Systems provided shared structure — a way to align decisions, reuse work, and move faster without losing coherence.
They worked because humans were the ones producing the interface. The system guided the work. The work was still manual.
Figma as Source of Truth
Over time, the design file became the place where this structure lived.
Figma evolved into the de facto source of truth — not because it was designed for it, but because it was convenient. Visual, flexible, accessible. Teams could point to it and say: this is what we're building.
But it was never a reliable reflection of the product. Files drift. States go missing. Explorations get mixed with production work. What lives in Figma is often a snapshot of intent, not the reality of the system.
It worked well enough when humans controlled the output.
Now: The Pipeline Collapses
The traditional pipeline looked something like: idea, mock, spec, code.
The mock existed as a translation layer. It bridged intent and implementation. With generative AI, that bridge starts to disappear. Models can generate layouts, flows, and production-ready code directly from intent. Design and build stop happening as separate steps.
Once artifacts stop being produced manually, the file loses its authority. Figma becomes a place to explore direction, not define the product.
Code becomes the single, verifiable source of what the product is.
Yet even code doesn't fully capture the system. It expresses behavior. It doesn't define the logic that produces it.
The Real Problem
Traditional systems rely on interpretation. They assume someone will read the guidelines, resolve ambiguity, apply judgment.
Models don't do that. They predict. And different models predict differently. The same input can produce different outputs depending on the model, its training, its biases. Ambiguity doesn't get resolved — it gets amplified.
This creates a tension that didn't exist before.
Too rigid, and the model can't produce useful solutions. Too loose, and it drifts. The system needs structure — but the right kind. Enough to guide generation without limiting it.
That's the design problem now.
The System Becomes a Grammar
To meet this, the design system evolves from a library into something closer to a grammar.
A grammar defines how things can be formed. It sets the rules, the relationships, the boundaries of variation. Instead of documenting what exists, it defines what can exist.
Components still matter — they remain stable, efficient building blocks. But they're no longer the foundation. The grammar is. It defines what a component means, how it behaves, how it can vary. The component becomes an expression of those rules, not the source of them.
Constraints, semantics, behavioral patterns, variation ranges, identity — these become the material. Together they form a system that is both structured and flexible. Capable of guiding generation without over-constraining it.
This grammar becomes the upstream source of truth. Not a file. Not a static library. A system of rules that both humans and machines rely on to stay aligned.
The Shift
As generation moves into the model, the designer's role moves upstream.
Less time assembling interfaces. More time defining the conditions under which they're created. Shaping constraints, encoding logic, calibrating how far the system can flex before it breaks.
It's still design. But it operates at a different level.
Design systems once scaled humans. Now they shape machines. The interface becomes downstream. The system becomes upstream. Quality, consistency, identity — they stop coming from how well screens are drawn and start coming from how well the system is defined.