Key takeaways
- A design system is a decision engine, not a component inventory—intent is the layer that matters.
- Maturity isn't the number of components; it's how reliably your team reaches the same decision without a meeting.
- AI can copy your components but not your reasoning—document intent as explicit, machine-readable rules.
- Sync code and design into one source of truth so neither drifts and tools can reason against it.
- Intent-first systems ship faster, onboard quicker, and safely delegate work to AI.
Most teams think a design system is a Figma library plus a tidy set of coded components. That's the artefact, not the system. The real system is the set of decisions, constraints and reasoning that explains why a button looks the way it does, when to use it, and what tradeoffs were accepted along the way. Strip that away and you're left with a styling kit that drifts the moment your team scales or an AI tool starts generating screens on your behalf.
This distinction has gone from philosophical to urgent. Google, Atlassian and Figma are now shipping files that capture the intent behind a design—not just the tokens and specs. The reason is simple: components tell you what exists, but only intent tells a human or a machine what to do next.
Why components were never the point
A component is a frozen answer to a question that was already asked. The question—"how should users confirm a destructive action?"—is where the value lives. When the question is undocumented, every new designer, developer and now every LLM re-answers it from scratch, often inconsistently.
We see this constantly in audits. A client has 1,200 components and zero governance. Four variations of the same card exist because nobody recorded the rationale for the first one. The library looks mature; the system is effectively dead. Maturity is not the size of your component inventory—it's how reliably your team reaches the same decision without a meeting.
The three layers of a system that actually holds
- Foundations: tokens, spacing, type, colour—the raw grammar.
- Components: the reusable sentences built from that grammar.
- Intent: the rules, principles and tradeoffs that decide which sentence to speak and when.
Almost everyone invests in the first two and neglects the third. That third layer is what makes a system defensible, teachable and—critically—machine-readable.
The AI shift: machines need your reasoning, not your pixels
Here's the uncomfortable truth about AI-assisted design and development: a model can copy your components flawlessly and still produce something off-brand, because it has no access to your reasoning. It knows what your primary button looks like. It doesn't know you reserve it for the single most important action per screen.
This is why the emerging practice of making systems "AI-ready" matters. Protocols like MCP (Model Context Protocol) are starting to connect code, Figma and documentation so that tools can query not just assets but constraints. A well-structured system becomes a source of truth an AI can reason against—turning "generate a checkout page" into something that respects your actual rules rather than a plausible-looking guess.
The same logic applies to building brand foundations with tools like Claude. AI accelerates the grunt work—naming scales, drafting usage docs, generating variants—but only if you supply guardrails. Without documented intent, AI simply industrialises your inconsistency.
How to rebuild your system around intent
You don't need to burn everything down. You need to layer meaning onto what you already have.
- Document decisions, not just specs. For every core component, record the problem it solves, when to use it, when not to, and the tradeoff you accepted. One paragraph beats a 40-page PDF nobody reads.
- Make rules machine-consumable. Structure usage guidelines as explicit constraints ("primary button: max one per view") rather than prose. Both junior designers and LLMs parse rules better than vibes.
- Connect code and design as one source. If your Figma and your codebase disagree, neither is trustworthy. Sync them—manually or via MCP-style tooling—so there's a single canonical state.
- Treat governance as a product. Assign ownership, version the system, and measure adoption. A system without a maintainer is a liability with a deadline.
The business case for intent-first systems
This isn't aesthetic hygiene—it's operational leverage. Teams that document intent ship faster because fewer decisions get relitigated. They onboard designers and developers in days, not months. And they're positioned to hand real work to AI without quality collapse, because their system can actually explain itself to a machine.
The agencies and product teams that win the next few years won't be the ones with the prettiest component libraries. They'll be the ones whose systems encode judgement—so that whether the next screen is built by a senior designer, a new hire, or a model, it comes out right. Rethink your system as a decision engine, and the components will finally do what they were always supposed to: follow the rules.
Sources
- How to build a brand foundation with AI without losing your craft — UX Collective
- Building an AI-ready design system library: Code → Figma with MCP. — UX Collective
- Your design system was never about components — UX Collective
- State of a system — UX Collective
