Act 1 · Seeing · Course 03

The System

Fifty screens that agree with each other are never a coincidence – they're tokens, components and patterns referencing one source of truth. This course hands you the machinery, the vocabulary to direct it, and the seven steps that build one from nothing.

A design system is the "how we build it" layer underneath a brand's "what it should look like" layer – a coded, governed toolkit of tokens, components and patterns that lets a product stay coherent at scale. The mechanism running through all of it is reference-not-copy – one decision, made once, followed everywhere – and the skill this course builds is speaking that machinery precisely enough to review it, request it, or have an agent build it under your direction.

Walk away able to

  • Catch the copy-paste definition of composable in the wild, and explain the reference model that replaces it
  • Read a token file and name the layer any decision lives in – primitive, semantic, or component
  • Critique one component precisely – part, variant or state – down to the cell of the grid that's broken
  • Ask for a screen's four data conditions by name, and notice when only the happy path was designed
  • Sequence a from-scratch build, scope its minimum honestly, and supply the judgement anchors when an agent does the building
  • Judge any system – including the famous ones – by the problem it answers and the trust it earns, never by component count
The tests you leave with – five questions that size up any component conversation

Five questions that size up any component conversation – ask them in order, stop at the first honest no:

  1. Is it composed, or copied? Will a change to the base piece propagate everywhere it’s used – or will someone re-edit duplicates by hand until they drift? Reference-not-copy is the whole difference between a system and a pile (lesson 1).
  2. Which layer does this decision live in? A primitive value, a semantic alias, or a component override – and is anyone bypassing the layers with a hex code in a component? (lesson 2).
  3. Variant, or state? Is the problem the authored version chosen for this screen, or the live condition’s treatment – and does the variant × state grid have all its cells designed? (lesson 3).
  4. Where are the other three moods? Loading, empty, error – or was only the populated screen designed? Ask by pattern name and the fix scopes itself (lesson 4).
  5. Would the build survive scrutiny? Audit before palette, governance before contributor two, adoption measured as trust rather than installation – and if an agent built it, who supplied the judgement? (lesson 5, lesson 6).

The six lessons build these in order. The quiz at the end checks the judgement, not the definitions.

The lessons

Already seeing it? Take the quiz first – a pass marks the course done, no lessons required.

  1. 01Lego, not photocopies – What composable actually meansComposable means pieces combine and nest into things neither could be alone – through references, not copies. Portability is a side-effect, not the definition.
  2. 02Decisions with names – Tokens and the three-layer trickA token is a named variable for one design decision, stored once and referenced everywhere – the same reference-not-copy mechanism, applied to values.
  3. 03One component, precisely – Anatomy, variants, statesAnatomy names the parts, variants name the authored versions, states name the live conditions – and variants multiply by states into a grid, not a list.
  4. 04Solved problems – Patterns you'll meet everywhereA component is a thing; a pattern is a solution to a recurring problem, one level up – and four of them (disclosure, empty, skeleton, confirmation) cover most screens you'll ever review.
  5. 05Build one – Seven steps in the right orderAudit, principles, tokens, components, patterns, documentation, governance – the order isn't arbitrary, minimum viable isn't incomplete, and with an agent building, judgement becomes the bottleneck.
  6. 06The field – Real systems, and who owns the codeFive systems with genuinely different philosophies, one that isn't a system at all – and the lifecycle honesty check that stops you misreading any of them.
  7. 07Case study – AesopThis course's ideas, working in production: A brand so distinct that competitors read as derivatives – held together by bottles, stores and voice, with barely a component library in sight.

Check your understanding

6 questions with distractors built from real misconceptions – each answer explains itself immediately. Nothing unlocks and nothing is gated; passing just marks the course done.

Take the quiz