20 November 2026
Design System UI: What Is Actually Inside One
Search "design system UI" and you get 28 pages explaining what a design system is. Almost none of them tell you what is in one.
Quick answer: a design system's UI layer is four stacked things, not one. Tokens (the raw values), primitives (the layout and text building blocks), components (the parts you assemble screens from), and patterns (the rules for when to use which). A UI kit is only the third layer, drawn in a design tool. A style guide is only the first. Everything below is grounded in the public systems that publish all four.
What people mean by "design system UI"
Three different questions arrive at this query, and the pages ranking on it answer none of them directly:
- "What is in the UI part of a design system?" The inventory question. Answered below in four layers.
- "Is a UI kit the same as a design system?" The disambiguation question. No, and Google's own AI Overview on this query builds a three way table (design system, UI kit, style guide) to say so, which means the ambiguity is the intent.
- "Where do I get one?" The acquisition question. Either you build it, you adopt a public one, or you extract it from a product that already ships.
Design system, UI kit, style guide, component library
Nielsen Norman Group's Design Systems 101, published April 2021 and last reviewed 27 August 2026, gives the cleanest split anyone has written. It defines a design system as "a set of standards for managing design at scale" and says there are two parts to it: the design repository, and the people who manage it. The repository, in turn, "often contain[s] a style guide, a component library, and a pattern library."
| Term | What it holds | What it cannot do |
|---|---|---|
| Design system | Tokens, components, patterns, written rules, and the governance around changing them | Nothing, if nobody maintains it. NN/g counts the people as part of the system for a reason |
| UI kit | Reusable visual components inside a design tool, usually a Figma file | Reach production. A component set stays in Figma until somebody rebuilds it in code |
| Style guide | Color, typography, logo, spacing and tone of voice rules | Tell you which component to use for a destructive action |
| Component library | Built, documented, reusable UI elements, in code or in design, with names, states and props | Hold the reasoning. NN/g notes this is the part "many people associate with design systems", which is why the other layers get skipped |
The practical test: if you can download it in one file, it is a kit. If it has a changelog, a version number and someone who says no, it is a system.
The four layers, as the real systems publish them
Open the navigation of any mature public system and the same stack appears. GitHub's Primer splits into Product UI, Brand UI and Octicons, and its Product UI sidebar runs Foundations, then Primitives (Color, Size, Typography, Token Names), then UI Patterns, then 62 public components from ActionBar to UnderlinePanels, with another 25 marked internal. Atlassian's design system publishes its own machine readable index, and the order there is identical: Design Tokens, Primitives, Components, UI Styling Standard, Accessibility.
Layer 1: tokens. Named values for color, spacing, type and radius, stored as data rather than hard coded. Primer calls its token set Primitives and describes it as "Primer's design tokens for color, spacing, and typography". Atlassian ships them as the @atlaskit/tokens package. This is the layer that travels: a token file compiles into web, iOS and Android. If you want the full version, see what design tokens are.
Layer 2: primitives. The unstyled structural pieces, usually a Stack, a Box, a Text and a layout grid. They carry no brand, only geometry and spacing taken from layer 1. Teams that skip this layer end up with 40 components that each reinvent padding.
Layer 3: design system components. The named, stateful, documented parts. Primer's list includes Banner, Blankslate, DataTable, SegmentedControl, SelectPanel, StateLabel and three Skeleton variants, which is a useful reminder that a real component inventory is mostly the unglamorous parts: empty states, loading states, and the table. NN/g's definition of what belongs in each entry is worth copying: a unique name, a description with do's and don'ts, and the attributes that can be customized.
Layer 4: patterns. When to use which component, which Primer publishes as UI Patterns (Empty states, Forms, Loading, Navigation, Progressive disclosure, Saving) and Scenario Patterns (Copy, Create, Delete, Edit, Filter, Search, View). This is the layer a UI kit can never contain, because it is prose, not geometry.
Can a machine read your design system UI?
In 2026 this is the layer that decides whether your system survives, because a coding agent writes a growing share of the UI and it cannot see a Figma canvas. We fetched six major systems with a plain HTTP request on 20 November 2026, no browser and no JavaScript, and measured how much text came back:
| System | Page fetched | Readable text | /llms.txt |
|---|---|---|---|
| IBM Carbon | Button guidelines | ~34,000 characters | Yes (200) |
| Atlassian | Components index | ~10,400 characters | Yes (200) |
| GitHub Primer | Components index | ~10,400 characters | No (404) |
| Shopify Polaris | Polaris reference | ~5,600 characters | No |
| Material Design 3 | Buttons overview | 63 characters | No (404) |
| Apple HIG | Buttons | 260 characters | No (404) |
The bottom two rows are the finding. Material 3's component documentation returns a 63 character shell that says the site requires JavaScript, and Apple's Human Interface Guidelines returns 260. The two most cited design systems in the world are close to invisible to anything that does not run a browser engine. Carbon and Atlassian sit at the other end: both publish an llms.txt, Carbon's opening line describes itself as "IBM's open-source design system for products and digital experiences", and both ship an MCP server (Carbon MCP, and the ADS MCP server listed in Atlassian's own index alongside an internal atlassian-design-system agent skill).
Two more things worth knowing if you link to these systems from anywhere: polaris.shopify.com now returns a 301 to shopify.dev/docs/api/polaris, and Carbon has restructured its component URLs, so /components/button/usage/ redirects to /building-blocks/core/components/button/guidelines. Most roundup pages still link the old paths.
What the ranking pages on this query get wrong
The top result for "design system UI" opens with "Welcome, fellow designers, to the exciting world of Design Systems!" and closes its tooling section with exactly two tools: Sketch and Figma. No token pipeline, no component library in code, nothing that reaches a browser. That is the dominant failure on this SERP: the UI in "design system UI" never leaves the design file.
NN/g, the source every one of those pages is paraphrasing, does not rank in the top 28 results at all. Neither does Material, Polaris, Primer or Carbon. The query is served almost entirely by agency blog posts restating a definition, which is also why the People Also Ask box has drifted off topic into "Which pays more, UI or UX?"
✅ Do this:
- Write the tokens down as data before drawing a single component
- Document the pattern, not just the part. "Destructive actions use a confirmation dialog" is the rule; a red button is not
- Keep the system's text fetchable. If a plain HTTP request returns a JavaScript shell, agents and LLMs read nothing
- Version it and name an owner, or it is a kit with aspirations
❌ Avoid this:
- Buying a 1,500 component Figma kit and calling it a system
- Starting with components and retrofitting tokens later
- Documenting only the happy path. The skeleton, the empty state and the error state are where consistency actually breaks
- Assuming your agent can see your Figma library. It cannot
The workflow that makes a design system UI usable by an agent
The gap between a published design system and an AI agent building in it is a file. DESIGN.md is a single markdown document holding the tokens, the component rules and the patterns in the order above, committed next to your code so the agent reads it with everything else.
- Pick a system whose UI you actually want. The duply library holds DESIGN.md files extracted from shipped products, for example Linear, Stripe and Vercel.
- Drop the file in the repository root and reference it in your agent's instructions.
- Ask for a screen. The output lands in the visual language you chose instead of the model's average of everything it has seen. The long version of this is in how to give your AI coding agent a real design system.
FAQ
What is a design system in UI design?
A set of standards for managing UI at scale, made of four layers: design tokens, layout primitives, documented components, and the patterns that say when to use each. NN/g adds a fifth thing that is not a layer at all: the people who maintain it.
What is the difference between a UI kit and a design system?
A UI kit is a file of reusable visual components, usually in Figma, and it covers one layer. A design system adds the token layer underneath, the pattern rules on top, documentation, versioning and governance. A kit speeds up a mockup; a system constrains a product.
What are the components of a design system?
Foundations (color, typography, spacing, icons), primitives (Stack, Box, Text, grid), and the component inventory itself, which in a mature system runs 50 to 80 named parts. GitHub's Primer publishes 62 public ones, including the parts teams forget: skeletons, blankslates, banners and data tables.
Is a design system the same as a style guide?
No. A style guide holds the brand rules: color, type, logo, tone of voice. It is one part of the repository a design system contains, and on its own it cannot tell a designer or an agent which component to reach for.
Do I need a design system for a small product?
You need the token layer and about ten components. You do not need governance, a docs site or a dedicated team. The cheapest version that works is a single file in the repository, which is the whole argument for DESIGN.md over a documentation platform.
Can an AI agent use my design system's UI?
Only the parts it can read as text. Tokens in a file, component rules in markdown and patterns in prose all work. A Figma library does not, unless you expose it through an MCP server. This is why Carbon and Atlassian now publish llms.txt files and MCP endpoints, and why Material 3's JavaScript only documentation is a real problem for anyone pointing an agent at it.
Summary
- A design system's UI is four layers: tokens, primitives, components, patterns.
- A UI kit is layer three in a design file. A style guide is layer one. Neither is a system.
- Real inventories are mostly unglamorous: empty states, skeletons, banners, tables.
- Machine readability now separates the serious systems. Carbon and Atlassian publish
llms.txtand MCP servers; Material 3 and Apple HIG return a JavaScript shell to a plain fetch. - The top results on this query stop at Figma and Sketch, and the canonical source they paraphrase does not rank at all.
Browse design systems that already ship, extracted into a format an agent can read: the duply library.