In the Expo design-system package inside OpenDesign's repository, the token `--bg` is not recorded as `#ffffff`. It's recorded as `#ffffff` — with a source: `tokens.css:8`.
That line number is the story. The value is the least interesting part of the record.
Last week this column covered DESIGN.md as a format: a prose spec you hand to a coding agent before it writes a component. This week the format grew a spine. The artifacts that matter are no longer the declarations. They're the receipts.
The artifacts that matter are no longer the declarations. They're the receipts.
Cristian Morales put the distinction plainly: the unit of thought in a design system isn't the component, it's the contract. Components are implementations. Documentation is a human-readable description. The contract is what stays constant when the tool, the framework, or the visual treatment changes.
Morales borrows Donella Meadows' definition — elements, interconnections, purpose — and maps it cleanly. Components and tokens are the elements. The contracts governing how they compose and propagate are the interconnections. Most teams build only the elements, because elements are tangible and interconnections are invisible until you go looking for them. That's why design systems feel like they're decaying even when the library is still sitting there, fully rendered.
What's new is that the interconnections now have to be machine-readable, because agents can't work from tacit knowledge.
The Expo package shows what a machine-auditable contract looks like in practice. It contains 56 tokens, and every one traces back to a specific declaration line in a single committed stylesheet. The summary report reads: 56 total, 56 declared, 56 source-backed, score 100, grade excellent, rebuild not recommended.
The distribution is described too: 8 tokens in the identity layer, 18 in structure, 26 in the semantic derivation layer, 4 in brand-replaceable slots. Zero alias tokens.
Each entry carries a reason field, and the reason is nearly identical across the file: the bundled stylesheet declares this, and no upstream recrawl was performed for this backfill. That repetition is the point. It is a refusal to overclaim, written into every row.
The package is explicit about its own boundaries. Evidence covers exactly three files: a DESIGN.md describing intent, a tokens.css holding the authoritative values, and a components.html fixture confirming selectors and states. Anything outside those three files is out of scope, by declaration. The manifest records the same provenance as a formal field — source type "bundled," origin "curated bundled fixture."
Then the maintenance rule, which is where this stops being documentation and starts being architecture. The JSON and the Tailwind CSS file are derived outputs. They must be regenerated from the report and the stylesheet rather than hand-edited. Editing a derived file breaks its binding to the declaration line, and a broken binding is a broken contract.
Now contrast that with the failing state it replaces.
Open Mercato's team audited 160 pages and 34 modules and found 372 hard-coded colors and 61 arbitrary text sizes. The same small text was expressed three ways: `text-[11px]`, `text-xs`, `text-[12px]`. Semantic colors failed completely in dark mode.
Their fix was structural, not cosmetic. One flat CSS variable per semantic role, with a full value for light and a full value for dark — no base color plus opacity. The reasoning is concrete: a 5% red reads as pale pink on white and nearly disappears on pure black, so transparency can't control contrast across modes.
The status hues aren't invented either. Error sits near 25 degrees, pulled from the existing destructive color; success near 160 from the chart emerald; warning near 80 from the chart amber; info near 260 from the chart blue. Every text-on-background pair was checked against the 4.5:1 contrast threshold. Enforcement runs through six structured lint rules, and Figma components are mapped to real code components across 11 high-frequency primitives.
That's the shape of the change: a value you can look up becomes a value you can challenge.
The enterprise rollouts are messier and more instructive. HarmonyOS's "细胞工坊" project consolidated its dark theme into three files — color semantics, font sizes and weights, and constants for page margins, card spacing, radii, and tab indices. Bottom-nav selection became a name, `TAB_SELECTED`, rather than a green. Pages consume the semantic role without knowing what color it resolves to.
The write-up then does something rare. It states the boundary. There is no light theme switching, no resource-qualified directory, no `WithTheme`, no runtime `setColorMode`. It calls the current state an ArkTS-layer dark-theme token table rather than a complete system-theme solution — because overstating it would be worse than the gap.
That honesty is the feature. An auditable contract includes its own limits.
Priceline's design system, covered in a write-up that flags AI-assisted composition, reports numbers worth treating as claims rather than measurements: component reuse up more than 60%, duplicate work down 40%, new-feature shipping time down 30%, bug-fix time down 50%, NPS up 15 points. The mechanism is more credible than the figures — semantic versioning, visual regression tests, accessibility checks against WCAG, and a single command to upgrade dependencies across packages.
And the Uber package shows semantics constraining use, not just defining it. Fifty-six tokens. Black is the primary CTA color, and the file says so. It also defines success, warning, and danger — then specifies that those three should not appear in interface chrome.
Uber's system also carries its own substitution instructions: UberMove is proprietary, so use system-ui or Inter as the nearest approximation. A contract that tells the agent where it's allowed to improvise is a better contract than one that pretends no improvisation will occur.
Which brings the thread back to where it started. At Numeric, the team moved away from Figma entirely and depends on a code-based design system for design and prototyping. Designers work in code, in interactive browser prototypes deployed as part of the system's own documentation. Backend engineers ship design-compliant features. Non-engineers ship prototypes in real React components.
Their framing: a design system is not a component library, but the system of tools and practices that ensure continuity of thinking throughout the product.
The library was never the point. The library was one manifestation, in one tool, at one moment. When the agent shows up and asks what to build, nobody wants the manifest of the library. They want `tokens.css:8`.