Book a call

WritingBuilding a systemPart 3 of 4 in Tools and twins

Design system tools by stage: what you need, and what to automate first

Tools don't make a design system, but the right ones make it much cheaper to run. The six areas of a toolchain, the minimum tool set for each stage, and the seven automations that pay for themselves.

On this pageTools serve the process
  1. Tools serve the process
  2. The toolchain, mapped
  3. The right tools for your stage
  4. Automation that pays for itself
  5. Where AI fits
  6. Questions to ask before adopting any tool
  7. The short version
  8. Frequently asked questions
  9. Further reading

The short answer

A design system uses tools in six areas: design (Figma libraries and variables), tokens (files in the DTCG format plus a build tool such as Style Dictionary), code (your package and a workshop such as Storybook), documentation, quality (lint, visual regression and accessibility tests) and insight (usage data). Match the tool set to your stage: a startup needs one Figma library and a shared file of values; a platform needs multi-brand tokens, a docs site with search and a health dashboard. If you automate only two things, automate the token pipeline and lint rules for raw values: they're cheap and prevent the most common problems.

  • Decide how the system works first, then pick tools that make that easier.
  • Keep tokens in a vendor-neutral format and components in your own repository, so tools stay replaceable.
  • Every tool needs an owner. An unowned tool becomes an out-of-date mirror.

Tools serve the process

It's tempting to start a design system by choosing tools: a documentation platform, a token manager, a component workshop. Tools feel like progress. But a tool without an owner and a process quickly becomes an expensive, out-of-date mirror of what's really happening.

An illustration: the documentation site nobody updated

The situation

A company buys a polished documentation platform and spends a month filling it with beautiful pages for every component.

What goes wrong

Nobody's job includes keeping it current. Within six months half the pages describe old versions. Teams stop trusting it and ask in chat instead.

What would have worked

Docs in the definition of done, with props tables and examples generated from code, so updating them is part of shipping rather than a separate chore.

So the order matters: decide how the system will work, then pick tools that make that way of working easier. And build where the system lives: put it into the files, repositories and tools teams already use every day, rather than asking them to visit somewhere new.

The toolchain, mapped

AreaWhat it doesTypical toolsConnects to
DesignShared components and variables for designersFigma libraries and variablesTokens (variables), docs (links)
TokensOne source of decisions, translated for every platformToken files in the DTCG format; a build tool such as Style DictionaryDesign variables, code packages
CodeThe components, packaged and versionedYour framework, a package registry, a workshop such as StorybookTokens, tests, docs
DocumentationHow and when to use everythingA docs platform, or a docs site generated from the codeCode (live examples), design (links)
QualityCatch problems before they shipLint rules, visual regression tests, automated accessibility checksCode, pull requests
InsightKnow what's used and whereFigma library analytics; scripts that scan product codeThe health scorecard
TokensOne source of decisions
→
Design + codeFigma variables and coded components, generated from the same values
→
QualityLint, visual and accessibility tests on every change
→
DocsGenerated from code, linked to Figma
→
InsightUsage data feeds the roadmap
How the areas connect. The connection that matters most runs from the token source into both design and code; that one link keeps the twins in step.

The right tools for your stage

A startup doesn't need an enterprise toolchain, and an enterprise can't run on a shared spreadsheet. Here's the minimum tool set we'd suggest at each stage of the maturity model. Add more only when a real problem calls for it. Practitioner view

StageDesignTokensCodeDocsQuality and insight
1 · Shared stylesOne Figma libraryA shared file of valuesA themed off-the-shelf libraryA single pageDesign reviews
2 · Basics in codeLibrary + variablesToken files + build toolYour package + workshopWorkshop pagesLint for raw values
3 · Looked afterLibraries split by purposeLight and dark modesVersioned releasesA docs siteVisual and accessibility tests; usage scripts
4 · PlatformBrand and platform librariesMulti-brand, multi-platformSeveral packages and platformsDocs platform with searchHealth dashboard; automated migrations
Minimum tools by stage. Each row adds to the one before it rather than replacing it.

Automation that pays for itself

Every hour the system team spends on repetitive upkeep is an hour not spent helping product teams. These automations, roughly in the order we'd build them, give the best return.

#AutomationWhat it savesEffort
1Token pipelineHand-copying values into code and design, and the mismatches that followDays
2Lint rules for raw valuesHard-coded colours and spacing slipping in; reviewers policing by handDays
3Visual regression testsAccidental visual changes; nervousness about every release1–2 weeks
4Automated accessibility checksCommon accessibility mistakes reaching products (a person still tests keyboard and screen reader use)Days
5Release notes from changesWriting release notes from memory at the last minuteDays
6Usage dashboardGuessing which components and versions are used where1–2 weeks
7Codemods for migrationsTeams rewriting code by hand for breaking changesPer change
Seven automations in build order, with rough effort. Practitioner view The first two are cheap and prevent the most common problems: values drifting between design and code, and hard-coded values bypassing the foundations.

A lint rule for raw values can be as simple as this, in a stylesheet linter:

/* stylelint: colours must come from tokens */
"declaration-property-value-disallowed-list": {
  "/color|background|border/": ["/#[0-9a-f]{3,8}/i", "/rgb\\(/"]
}

Where AI fits

AI tools are good at drafting and checking, and only as good as the information they're given: drafting documentation from props and examples, summarising changes into release notes, flagging off-system colours in designs and code, answering "which component?" questions from your docs, and helping write codemods. A well-structured system (named tokens, consistent props, documented components) turns out to be excellent input for them. We cover this in detail, with the cautions that matter, in AI in design systems.

In practice

At JPMorgan Chase, two tools point out where a design file or a piece of code doesn't match the design system, so problems are fixed before review. See the project.

Questions to ask before adopting any tool

  • What problem does it solve that we actually have today?
  • Who will own it and keep it current?
  • Does it work with our files, repositories and formats, or does it lock our decisions in?
  • How will we know in three months whether it was worth it?
  • What happens to our work if we stop using it? If the answer is "we lose it", keep looking.

The short version

  • Six areas: design, tokens, code, docs, quality, insight.
  • Decide how the system works first; tools make that easier.
  • Match the tool set to your stage. More tools aren't better.
  • Automate the token pipeline and lint rules first.
  • Keep decisions portable: tokens in DTCG, components in your repository.

Frequently asked questions

What tools do you need for a design system?

At minimum, a shared Figma library and a place for shared values. As the system grows: token files with a build tool, a coded component package with a workshop such as Storybook, a documentation site, automated tests and usage data.

Do we need a dedicated documentation platform?

Not at first. Workshop pages or a simple docs site generated from the code are enough for most teams until stage 3 or 4. What matters most is that updating docs is part of shipping.

What should we automate first?

The token pipeline and lint rules for raw values. Both take days and prevent the most common design system problems.

How do we avoid tool lock-in?

Keep tokens in the vendor-neutral DTCG format and components in your own repository, and check before adopting a tool what happens to your work if you stop using it.

Further reading