← Index

Point of view · Design systems

The ground layer

A design system should help teams make consistent decisions—in Figma, in code, and as the product changes. A shared foundation, with room for the product to evolve.

One foundation, many product decisions An illustrated design-system workbench connects named color, spacing, and type tokens to a reusable component and a product screen. 01 / FOUNDATION02 / COMPONENT03 / SURFACE Shared decisions AaType & hierarchy Space · color · motion space.3 → 12px A reusable pattern View details → Default / focus / disabled Rules + behavior Product overview View details → REVIEW · REFINE · KEEP ALIGNED
Shared values become reusable patterns—and consistent product surfaces.
For
Product teams working to keep design and implementation aligned
Focus
Shared tokens, component behavior, and practical checks
Method
Compare one surface, define the shared rules, and maintain them
Read
~4 minutes, or walk it with Oslo

A foundation is useful when the next person can understand it, work with it, and keep it up to date.

The principle behind this approach

My approach starts with one product surface. Identify where design and implementation disagree, define the shared tokens and component behavior, and establish checks that help the team maintain them.

The goal is a foundation that designers, developers, and AI tools can work from—with clear rules and room for the product to evolve. That means documenting component states, making shared values easy to find, and deciding which requirements can be checked automatically and which still need review.

Three things the system needs

Shared decisions, a maintained connection to code, and a way to catch inconsistencies.

Shared values

Define the tokens

Give color, typography, spacing, and motion meaningful names. Map those names between design variables and code so the team can see which values belong together.

A maintained connection

Connect design and code

Agree where changes originate, how they reach the other environment, and who reviews them. MCP can be part of that workflow; the integration and ownership need to be defined for the project.

Practical checks

Catch inconsistencies early

Choose checks for the requirements that can be tested, such as token usage or defined component states. Keep human review for interaction quality and decisions that need context.

How the layers fit together

Tokens define shared values. Components give those values behavior and structure. Patterns combine components for recurring tasks, and product screens use them to meet a specific need. The terrain diagram shows how those layers depend on one another.

Sky Products Screens for specific tasks Weather Patterns Recurring task flows Paths Primitives States, access, contents Bedrock Tokens Shared values and names Survey drill Review each layer
Read from the foundation up: tokens, components, patterns, and product screens.

Make the decisions explicit

This illustrative comparison shows the same kinds of interface decisions described in two ways. On the left, values and component boundaries are ambiguous. On the right, shared names make them easier to discuss, implement, and check.

Example A · unspecified

The visual may look complete, but several implementation decisions are still unclear.

Example B · defined

Named values and component rules give design and engineering a shared reference.

Keep design and code connected

Shared token definitions provide a reference between Figma and production code. The team also needs an agreed process for publishing changes, reviewing differences, and resolving conflicts. Where automation is useful, the integration should make those responsibilities explicit.

Drift values without a shared name Studio Figma variables and components Shared reference tokens.json Publish and review changes Ship Code CSS · Tailwind · checks
An illustrative workflow: shared definitions, reviewed changes, and a clear connection between design and code.

Start with one surface

A focused engagement makes the work easier to assess. Start with a surface the team uses, agree on what needs to become shared, and document how the team will maintain it. These four steps describe my proposed approach.

Steps in the approach 01 Compare 02 Tokens 03 Components 04 Maintain
Four steps for one surface, with clear definitions and ownership for the team.

Step 01

Compare design and implementation

Choose one surface and identify the differences that matter to its users and the team.

  • Compare Figma variables with the values used in production.
  • Identify one-off colors, spacing, and typography.
  • Agree which differences to address first.

Step 02

Define shared tokens

Start with the values this surface needs and give them names the team understands.

  • Name color, typography, spacing, and radius by purpose.
  • Map design variables to the project’s code conventions.
  • Test how a change is published, reviewed, and applied.

Step 03

Define components and their states

Specify how the components behave, what they contain, and which access requirements they need to meet.

  • Prioritize the components used on the selected surface.
  • Document states and identify suitable automated checks.
  • Review interactions and edge cases with design and engineering.

Step 04

Make maintenance part of the work

Define how the system will change as the product grows, including ownership and review.

  • Document where changes start and how they reach design and code.
  • Choose useful measures, such as unresolved differences or update time.
  • Leave the team with documentation and a process it can maintain.

Related work

These case studies show the product contexts behind this point of view: incident investigation, operational planning, and fleet monitoring. Each describes the interface work; the approach above describes how I would structure a design-systems engagement.

Talk about your system

Where are design and implementation becoming harder to keep aligned?

Email me →