Synthesis

Similarities, differences, and what actually works

Nineteen records read together: what nearly every team now ships, and what the leading systems do that the rest haven’t started.

Two years ago the question was whether design systems should care about AI consumption at all. That debate is over: of the nineteen systems here, all but one ship official machine-facing affordances, and thirteen treat AI consumption as a core design goal. What’s still contested, and what this study set out to map, is how you make a probabilistic text generator reliably use your components and your tokens rather than a statistically plausible imitation of them.

The answers cluster into three generations. The first is documentation reshaped for machines: llms.txt, markdown twins of docs pages, condensed component indexes. Nearly everyone does this now, and the state of the art is no longer writing these files but compiling them from the same sources as the human docs so they can’t drift. The second is instruction: rules files and skills that tell the model what to do and, mostly, what never to do. The best instruction writing reads like policy rather than documentation: numbered never-violate rules, allow-lists of exported components written to stop models hallucinating Box/Stack/Container (Ant Design), Incorrect/Correct exemplar pairs (shadcn).

The third generation, and the clearest line between the leaders and the pack, is structural coercion: redesigning the task so the model can’t go off-system even if it wants to. Tool-gating makes the agent call an MCP tool or CLI to get component source; Primer writes “CRITICAL: CALL THIS FIRST” straight into its tool descriptions. Scaffolding has the CLI generate canonical code while the agent merely orchestrates (shadcn). Registries resolve real artifacts instead of imagined ones. Validation loops make the agent run linters and audits until they pass (SLDS, Fluent, Polaris). Instruction hopes the model complies. Structure checks.

The design-system team’s own repo is a different battlefield from the consumer’s repo, and investment on the two sides barely correlates. Some of the most consumer-invested systems (React Spectrum, shadcn, SLDS) show no public builder-side agent files at all, while Fluent UI runs the deepest contributor stack in the study behind a thin consumer surface. A quieter trend connects the leaders: they have started treating agent files as versioned, evaluated software. shadcn ships evals for its skill. Mantine version-locks its MCP server to each release. Atlassian published benchmark numbers. Carbon’s AGENTS.md opens by telling maintainers to keep it short because it’s loaded into every agent’s context. Give the machine interface the care you already give the component API. That is the part of this worth copying.

Convergent patterns

  1. llms.txt plus markdown twins of every docs page

    The near-universal baseline: 14 of 19 systems publish llms.txt. The refinement war is over context budgets. Chakra slices llms.txt six ways by concern, HeroUI four ways by platform, Atlassian six ways by topic, Nuxt UI serves section-scoped variants, and Cloudscape regenerates daily with typed JSON API definitions per component.

  2. Official MCP servers, converging on read-only retrieval

    Sixteen of nineteen systems have an official MCP channel, and nearly all expose the same core shape: search docs, get component docs and examples, list tokens. The variance is in delivery. Bundled in the CLI (shadcn), npm stdio (MUI, Chakra, Mantine, HeroUI, Spectrum, Primer, PatternFly, daisyUI), hosted remote with auth (Carbon, Nuxt UI, Atlassian), or owned by the platform org rather than the DS team (SLDS via @salesforce/mcp, Polaris via Shopify’s dev MCP).

  3. Agent skills with progressive disclosure

    The dominant skill architecture is a compact SKILL.md router plus lazy-loaded reference files. Carbon: a 24KB SKILL.md with 12 reference files. Nuxt UI: a routing table with 15. Chakra: a decision tree over its ~114 components. Everyone landed on the same trick independently: keep the always-loaded surface small and gate the detail behind explicit reads.

  4. Prohibition language that names the hallucination

    The most effective negative rules name the exact failure. Ant Design’s allow-list exists to stop models hallucinating Box/Stack/Container. shadcn bans raw divs with space-y-* and manual dark: overrides. Carbon and SLDS both enumerate the components that exist, so anything else is provably invented.

  5. Design-to-code grounding via Figma Code Connect

    248 public repos carry @figma/code-connect in package.json. For the systems that invest (Carbon, Primer, Fluent and Spectrum among them), it is the only mechanism in the stack that grounds design-to-code generation in real component imports rather than pixel reconstruction.

Divergent bets

  1. Open discovery vs. walled garden

    Nuxt UI publishes an RFC 9727 api-catalog, Link headers and markdown content negotiation so any agent can find everything. Polaris blocks AI crawlers outright and routes all consumption through Shopify’s own toolkit, where it enforces the strictest ruleset in the study. The industry hasn’t decided whether the machine interface is a public good or a controlled channel.

  2. Where the affordances live

    In the DS repo itself, with skills and MCP developed in-tree (shadcn, HeroUI, Chakra). In the platform tooling layer, invisible from the DS repo (SLDS inside @salesforce/mcp, Polaris inside shopify-ai-toolkit). Or in the docs-site infrastructure (Cloudscape, Nord). Where it lives predicts who maintains it and how fast it ships.

  3. Vendor-neutral vs. harness-specific

    USWDS wrote one deliberately vendor-neutral AGENTS.md. Primer went all-in on GitHub-native formats: copilot-instructions.md plus path-scoped *.instructions.md. HeroUI ships system prompts tuned per vendor (v0.dev, bolt.new, universal). Most hedge by shipping the same content through every channel at once.

  4. Builder-side philosophy: rulebook vs. router

    Fluent UI’s contributor stack is a rulebook: numbered never-violate rules and nine operational skills. Carbon and Cloudscape bet on routers, keeping AGENTS.md deliberately tiny (Carbon’s opens by telling maintainers to keep it short; Cloudscape’s ~20 lines point into a 12-file docs index) and trusting retrieval over resident context.

  5. Paid AI surfaces are appearing inside open systems

    MUI’s MCP includes generateReactCode, a paid service that can ground generation in a Figma frame. Chakra’s MCP unlocks Pro templates with an API key. daisyUI sells Dashboard and Charts skills. The open-source design system with a commercial AI tier is now a live business model, and it changes the incentives around how good the free machine interface is allowed to be.