We've watched the same mini-program ship three times at three merchants, and walk into each one looking like a different product. Different buttons, different spacing, a slightly different blue. None of it was planned. It just happened, because each team started from a blank repo and a design file they half-remembered, and nobody owns the visual language once it leaves the first repo.

The fix isn't another Figma library to gather dust. It's a component kit that owns the visual language and refuses to let anyone draw around it. Build the kit once, ship it everywhere, and the question of what the product looks like stops being a question every team re-answers badly.

Tokens are the only thing that actually scales

A design system lives or dies at the token layer. Color, type, spacing, radius, elevation — if those are values in a file that components read, you have a system. If they're copied into inline styles on a Tuesday afternoon because a merchant wanted the card a hair taller, you have a screenshot with a long half-life.

We're opinionated about the order: tokens first, components second, screens last. A button should never contain a hex code. It should ask the token layer for the brand surface, the hover state, the disabled state, and trust that those exist. That sounds obvious until you audit a real mini-program and find the same primary color defined nine different ways across twelve files, each one a small act of faith that nobody will ever need to change it.

The discipline isn't about purity or taste. It's about what happens the day the brand updates the blue, or the radius goes from eight to ten, or legal asks for a higher-contrast text color. In a token-disciplined kit, that's one edit and a recompile. In a drifted one, it's a grep-and-pray across every merchant repo, and you will miss one — the one on the page that matters most.

Drift is a tax you pay forever

Every team that forks the UI pays a small, invisible cost up front and a large, recurring one later. The up-front cost is an afternoon. The recurring one is a design-system team whose real job is chasing inconsistencies a single kit would have prevented.

Where the look driftsWho notices firstWhat it actually costs
Spacing scales per screenThe merchant comparing two pagesHours reconciling layouts that should match
One-off color patchesQA on a new hostRe-testing contrast the kit already passed
Custom button variantsThe next developer on the repoA fork nobody maintains, then a third fork
Hard-coded fontsLow-vision users on system scaleThe accessibility work the kit did, undone
Divergent motion rulesUsers with vestibular needsReduced-motion support silently dropped

The trap is that drift feels free. The first fork is a favor to a merchant. The hundredth fork is why your roadmap fills with cleanup tickets instead of features. Consistency isn't an aesthetic nicety; it's the thing that keeps your team working on the next merchant instead of re-teaching the last one.

Accessibility belongs in the kit, not in the audit

We wrote before about turning on a screen reader and watching the checkout disappear. The reason that keeps happening is that accessibility gets bolted on at the end, per screen, per team, usually under launch pressure. If the labelled component, the contrast-checked palette and the scalable type live in the kit, they ride along for free on every screen a merchant builds.

This is the quiet argument for a shared kit: it's the only place accessibility can become a default instead of a phase. A merchant doesn't decide whether their buttons have labels or whether the text scales. The kit decided that once, for everyone. That's the whole point of shipping one visual language instead of rebuilding it per team — the hard decisions get made where they can't be quietly undone.

A runtime is what lets the kit travel

Here's the part people under-sell. A design system is only as portable as the thing that renders it. If your kit is a set of framework-specific components and the host runs something else, the kit doesn't travel — the drift starts again right at the runtime boundary, and you're back to per-host UI.

A universal runtime changes that. When the same kit compiles down to one runtime every host understands, the blue stays the blue and the button stays the button whether the mini-program lands in a messaging app, a payments app or a merchant's own storefront. The visual language doesn't re-negotiate itself per host; it renders once, consistently, and the merchant's brand survives the trip.

That's the real promise behind one component kit: not that it looks identical everywhere, but that it never silently becomes a different product. One kit, one set of tokens, many merchants, many hosts — instead of a fresh rebuild every time someone opens a repo.

Sources