Marcus Andrey Study
Ler em português Library

UX Foundations · Step 6 · 6 min read

What a design system is

A design system is more than a component library: it's tokens, components, guidelines and the people who look after them. What each part does, Brad Frost's atomic design, design tokens and the 2025 standard, and why governance decides whether a system lives or dies.

A design system is the visual decisions of this step, written down once and shared. Hierarchy, grouping, type, colour and spacing don't stay consistent by luck. When a product has ten designers and fifty developers, someone has to decide what a button looks like, give that decision a name, build it once and explain when to use it. That's a design system: shared parts, shared rules, and the people who keep them alive.

What you'll be able to do after reading:

  • Define a design system and tell it apart from a UI kit
  • Name its four parts: tokens, components, guidelines and governance
  • Explain Brad Frost's atomic design
  • Use a design system well as a new designer, and know when to ask for changes

1. A definition

NN/g defines it as "a complete set of standards intended to manage design at scale using reusable components and patterns", and notes that a design system has "two important parts": the design repository "and the people who manage it" (NN/g, Fessenden, Design Systems 101, 2021). The second part is the one beginners miss. A Figma file full of components with nobody responsible for it is a UI kit, not a system.

The same article lists the main benefits: work "can be created and replicated quickly and at scale", designers have more time for harder problems, teams share "a unified language", and products look consistent.

A wooden type case full of small metal letters, with a composing stick holding a few set lines of type.
Movable type was an early design system: a fixed set of reusable pieces, kept in agreed places, combined into endless pages. A modern design system does the same with tokens and components. Photo: Willi Heidelbach, Wikimedia Commons, CC BY 2.5.

2. Four parts

TokensNamed decisions

Colours, sizes and spaces with names, like "color-error".

One change updates every product
PartsComponents

Reusable pieces: buttons, fields, cards, dialogs.

Designed and coded once
RulesGuidelines

When to use each piece, and when not to.

With do and don't examples
PeopleGovernance

Who decides, who maintains, how others contribute.

Without it, the system decays
Four parts of a design system. The first three are things; the fourth is people. Diagram: Marcus Andrey, CC BY 4.0.
Part What it is Example
Tokens Named design decisions: colours, type sizes, spaces, radii color-error = a specific red; space-200 = 16 px
Components Reusable interface pieces, designed and coded once Button, text field, card, dialog
Guidelines When and how to use each piece, with do's and don'ts "Use one primary button per screen"
Governance Who decides, maintains and approves changes; how others contribute A core team, a request process, release notes

NN/g describes the repository as often containing "a style guide, a component library, and a pattern library", and says a component library entry should include a name, a description, attributes, states and code snippets.


3. Design tokens

A token gives a decision a name, so design and code can refer to the same thing. Instead of "#B3261E" in forty places, everyone uses color-error. Change the token, and every product that uses it changes.

The term was coined at Salesforce by Jina Anne and Jon Levine, as the W3C Design Tokens Community Group recalls (DTCG, 2026). That group published the first stable version of the Design Tokens specification (2025.10) on 28 October 2025, a shared JSON format that design tools and code tools can exchange (designtokens.org). For a deeper look, see Design tokens.

Tokens usually come in layers: a base value ("red-600") and a role that points to it ("color-error"). Components use roles, which is how the colour roles from Colour and contrast and the spacing scale from Layout, grids and spacing end up in code.


4. Atomic design

Brad Frost's atomic design is "a methodology composed of five distinct stages working together to create interface design systems in a more deliberate and hierarchical manner" (Frost, Atomic Design, chapter 2). He first described it in a 2013 blog post and later wrote a book, free to read online.

  1. 1Atoms

    A label, an input, a button.

  2. 2Molecules

    Label + input + button = a search form.

  3. 3Organisms

    Logo + navigation + search = a header.

  4. 4Templates

    The page structure, without real content.

  5. 5Pages

    The template with real content, to test it.

Brad Frost's atomic design: five stages from the smallest piece to a real page. Diagram: Marcus Andrey, CC BY 4.0.

His own example: a label, an input and a button (atoms) form a search form (a molecule). The search form, a logo and navigation form a header (an organism). Templates place organisms in a layout; pages fill templates with real content to test the system. Frost stresses that the stages work "concurrently": it's a way of thinking about parts and wholes, not a step-by-step process.


5. Governance: why systems live or die

A design system is a product with users (designers and developers) and needs care like any product. Common questions governance answers:

  • Who decides? A central team, a group of contributors from product teams, or a mix.
  • How do changes happen? Someone needs a new component: do they request it, build it themselves, or create a local version?
  • How is it released? Versions, release notes, what happens to old components.

There's no single right model; it depends on the organisation's size and culture. See Design system governance models and Contribution process.

As a new designer, use the system before you change it. Learn its components and rules first. When something truly doesn't fit (see Patterns and when to break them), bring the case to the system's team with the problem, the context and an example, instead of quietly detaching a component.


6. Common mistakes

  • Calling a component file a design system, with no guidelines or owners.
  • Hard-coding colours and sizes instead of using tokens.
  • Detaching components to "just change one thing", until nothing matches.
  • Building a big system before any product needs it.
  • Treating the system as finished; NN/g notes systems "are not a one-and-done solution".

7. Vocabulary

Term Meaning
Design system Shared tokens, components, guidelines and the people who manage them
UI kit / component library A set of reusable components, without the rest of the system
Design token A named design decision (colour, size, space) shared by design and code
Component A reusable interface piece, such as a button or field
Pattern A reusable solution to a common problem, often made of components
Governance How decisions, maintenance and contributions are organised
Atomic design Brad Frost's model: atoms, molecules, organisms, templates, pages

8. Try it (no tools needed)

  1. Pick an app you use and take five screens. Draw every button style you can find. How many are there? Which ones do the same job?
  2. List the colours you see and give each one a role name (surface, primary, error...). Which colours have no clear role?
  3. Write one guideline the app seems to follow, and one place where it breaks it.

Reflection questions: Did the app feel like one product or several? Which missing rule would you write first?


9. If you already practise

  • Document the why next to each component: the problem it solves and when not to use it.
  • Measure adoption (how many screens use system components) and listen to the system's users; see Design system metrics.
  • Prepare the system for AI tools, which work best with clear names, tokens and written rules; see AI-ready design systems.

Checklist

Learn more

Books, courses and videos to go deeper

Book links go to Amazon. As an Amazon Associate I earn from qualifying purchases, at no extra cost to you.

Layout, grids and spacing · Patterns and when to break them · Design tokens · Design system governance models · Contribution process · Design system metrics · AI-ready design systems · Accessibility fundamentals

Saved only on this device.

↑ ↓ to move · Enter to open · Esc to close