Manual steps in a design system are where it slowly dies. Anything a person has to remember to do, they will eventually forget under deadline. Automation is how a system keeps its promises without depending on anyone's memory.

Automate the boundary, not the taste

You do not automate the design decisions; those are human judgement. You automate the boundary around them: turning the decided values into code, propagating them to every platform, and catching anything that violates them.

That distinction keeps automation useful. It removes toil and enforcement, and leaves the actual design to people.

Source

Figma variables

Collections and modes hold every decision once.

Build

Token transform

Export on publish, generate the platform files.

Output

Platform tokens

WebiOSAndroid

Source to platforms, on publish. The transform is code, versioned like any other.

The pipeline, end to end

It has a small number of stages. Export the source of truth on publish. Transform it into platform tokens for web, iOS, and Android. Open a pull request automatically so changes are reviewed like code. Lint component styles so a raw hex or pixel fails the build. Version and release on a cadence teams can plan around.

Each stage removes a manual step that used to be a place for drift to enter.

Make drift a build failureThe highest-leverage automation is the humble lint. When a hardcoded value fails a pull request instead of surfacing in an audit two quarters later, drift stops being a cleanup project and becomes a five-minute fix.

AI is the newest stage, not a replacement

Generation belongs in the pipeline, not outside it. An agent that reads your tokens and components can scaffold on-system code quickly, and the same lint that guards human commits guards its output too. Speed at the front, guardrails at the back.

The goal never changes: the system keeps itself true, so people can spend their attention on the product rather than on policing consistency.

A design system that maintains itself

Export the source of truth on publish.
Generate platform tokens automatically.
Open a pull request for every change, reviewed like code.
Lint for raw values so drift fails the build.
Version and release on a predictable cadence.

Start with one stage, not the whole pipeline

The pipeline sounds like a large project, which is how it never gets started. It should not be built all at once. Ship one stage that removes real pain, usually the lint that fails a raw value in review, and let it prove itself. Each stage you add earns the next by removing a manual step people were tired of.

Automation is most trustworthy when it grows this way, one honest improvement at a time, rather than arriving as a big framework everyone has to adopt on faith.

The parts of a system that last are the parts a machine maintains. Everything manual is borrowed time.On automation