Why I think design tokens are a management tool

A row of green, red, and yellow houses along a canal on Burano near Venice

A design token looks like a small thing, a named value for a color, a spacing step, a font size, a shadow. Most of the writing about tokens is about the tooling. I think the value is the least interesting part of a token. The interesting part is that it is a decision with a name.

Naming a decision changes who makes it

Before a team has tokens, every spacing choice is made by whoever is writing the component. The decision is remade hundreds of times by people with different taste. Review threads fill up with opinions about eight pixels versus twelve.

Once the spacing scale has names, that decision is made once, by the people whose job it is, and the engineer's job becomes choosing from it. The question in review is no longer whether twelve pixels looks right but whether this gap is small or medium. I think that one change removes a surprising share of the friction between design and engineering, because it moves an argument about taste to a question of categories.

Exceptions announce themselves

The second thing tokens do is make exceptions visible. When every value in a codebase is a raw number, an exception looks like everything else. When every value is a token, a raw number stands out, and a linter can flag it.

I think this is the real accessibility and consistency win, not that tokens make the interface consistent but that they make inconsistency cost something, a comment, a justification, a visible choice to go around the system. Usually the engineer uses the token. Otherwise the team learns that the scale has a gap, which is information the scale's owners need.

A contract that survives distance

The third thing is that a token set is a contract between design and engineering that does not depend on the two being in the same room. It survives turnover, too. A new engineer learns the scale in an afternoon and inherits years of decisions without being told them.

That matters most on distributed teams, where the informal channel that keeps design and engineering aligned, the walk to someone's desk, does not exist. The token file is the desk.

What goes wrong

Tokens fail in two ways I have seen. The first is too many, where the scale has forty spacing steps and choosing from it is no easier than choosing a number. The second is tokens without an owner. A scale nobody can change becomes a thing people go around, and the exceptions stop announcing themselves.

So my view is that a token set needs the same two things any standard needs, a surface small enough to learn, and a named owner who can change it when the team finds a gap. Given those, I think tokens do more for how a team works together than for how its interface looks, and I would adopt them for the first reason alone.

Photo source: https://photos.robertstowe.com/venice