Vocabulary stack

A mental model that builds interfaces from small composable parts, atoms to molecules to organisms, up to pages.

The model under the primitive, semantic, and component token tiers.

A lightweight, language-neutral data format of key-value pairs and arrays. The substrate design tokens and MCP both ride on.

The format the DTCG spec and most machine-readable layers use.

Writing a program as one document that interleaves the explanation, ordered for a human, with the code the compiler extracts. Programs treated as literature.

The deepest ancestor of spec-as-source and of pairing tokens with prose (DESIGN.md).

A plain-text formatting syntax meant to be readable as-is. The format current models read with the highest fidelity.

The substrate of every runtime context file: AGENTS.md, SKILL.md, llms.txt.

Grounding a model's output in documents retrieved at query time instead of relying only on what it memorized.

One flavor of context engineering; referenced on the machine-readable layer.

Keeping content separate from how it looks, so one structure can wear many styles and a value can change in one place.

The principle design tokens formalize.

The word means two things, and the site is named after the collision. A design token is a named design decision (Jina Anne with Jon Levine, Salesforce, 2014). An LLM token is a subword unit of text a model reads: byte-pair encoding came from Philip Gage in 1994 as compression, applied to language by Sennrich, Haddow, and Birch in 2016. The site is the journey from the first sense to a world run by the second.

Disambiguates the site's central word.

The neural network architecture, built on self-attention, under every large language model in the stack.

The architecture every agent in layers 02 to 04 runs on.

Representing a known or unknown quantity with a letter so you can compute with it as if it were the value. The 400-year-old ancestor of every token: a name that stands in for a value.

Ancestor of both the programming variable and the design token.

Native variables in the browser (--name: value) that made tokens practical on the web.

The browser primitive tokens compile down to.

A design decision stored as data instead of a hardcoded value. One named entry, like color.brand, holds the value once so every platform reads the same source instead of copies that drift.

Built on the variable; formalizes separation of structure and style.

The vendor-neutral W3C body that standardizes the token format.

Ended the per-tool token dialect fragmentation.

The open .tokens.json format with $value, $type, and $description. First stable version shipped October 28, 2025.

The standard Style Dictionary v4 and others now target.

Token-like variables native to Figma, with aliasing and modes.

Brought token thinking into the design tool itself.

One authoritative place a value lives, so every consumer reads it instead of keeping drifting copies.

The principle tokens operationalize.

A build tool that turns one set of tokens into platform-specific code (CSS, Swift, XML). This site compiles through it.

Made tokens usable outside Salesforce; now speaks DTCG.

Salesforce's original open-source tool to transform tokens into platform code. The predecessor to Style Dictionary.

The first real token build tool.

The layered naming model where raw values (primitives) are aliased to purpose (semantic) and then to component-level tokens. Originally framed as options and decisions.

The structure most token systems and the DTCG use.

A plugin and platform for managing tokens in Figma and syncing JSON to code.

Bridges design-tool tokens to the Style Dictionary pipeline.

The oldest proof in web design: the page and its construction are the same artifact, one keystroke apart. This site extends it a layer down. The rendered pages, the compiled custom properties, and the DTCG source they compile from are all public, so the claim and the artifact can be checked against each other.

Practiced on this site's own design token and DTCG format source, compiled with Style Dictionary.

The same input yields the same output. The property a machine-readable system buys over guessing.

The property the meaning layer is after.

Letting a model return a structured call to a defined function or tool. The mechanism MCP generalizes.

The predecessor mechanism to MCP.

A vocabulary for declaring the shape of JSON so it can be validated. The contract that makes JSON checkable.

Makes machine-readable contracts enforceable.

Encoding design decisions so an agent can query them like an API instead of guessing from a screenshot or prose.

The meaning layer; often runs over MCP.

The roles in an MCP connection: the host app, the client inside it, and the server exposing tools or data.

The architecture of an MCP integration.

An open protocol that gives agents a common way to connect to tools, data, and context.

The pipe the meaning layer usually runs over.

Structured JSON beat prose-heavy docs for feeding components to an agent. The lesson is structure, not size: JSON for MCP contracts, Markdown for natural-language rules.

Empirical support for the machine-readable layer.

The broader set of SDD tools beyond Kiro and Spec Kit.

The choosing-a-tool layer.

The Easy Approach to Requirements Syntax: five sentence patterns that make requirements testable and unambiguous.

Makes acceptance criteria machine-checkable inside SDD.

A spec-driven agentic IDE that turns prompts into requirements, design, and tasks. A product from Amazon, not an AWS service called AWS Kiro.

A commercial SDD tool. Its 40-hour-to-8-hour figure is its own claim.

An older approach making formal models the primary artifact and generating code from them.

The ancestor Böckeler warns spec-as-source could inherit the worst of.

GitHub's toolkit for the Specify, Plan, Tasks, Implement loop.

The reference implementation of SDD.

Making a written, version-controlled spec the source of truth and treating generated code as a regenerable artifact. You protect the intent, not the code.

Descends from model-driven development and literate programming.

Three maturity levels: write-then-discard the spec, keep it governing, or only ever edit the spec. Match the level to your cost of drift.

Böckeler's map. Attribute to her, not to Fowler.

The four-phase SDD loop with a human checkpoint at each boundary.

The operational shape of Spec Kit.

Spec-centric, AI-native development tooling oriented toward spec-as-source.

One of the tools Böckeler compares.

Prompting an agent ad hoc and shipping what comes back without reading it. Fine for prototypes, a liability in production. Collins word of the year 2025.

The anti-pattern SDD answers.

A neutral home for agentic standards. Founding projects: MCP, AGENTS.md, and goose.

Where MCP and AGENTS.md now live.

A simple Markdown file giving coding agents consistent project-specific guidance. 60,000-plus repos.

The most established runtime context standard.

Claude Code's project memory file. A predecessor pattern to the AGENTS.md convergence.

One of the vendor files AGENTS.md generalizes.

Deciding what goes into the model's working memory at each step and what stays out. Prompt engineering became a subset.

Supersedes prompt engineering; RAG is one flavor.

The maximum span of tokens a model can attend to at once. Its working memory.

Transformer lineage; the thing context engineering manages.

A file pairing machine-readable tokens with the prose that explains the visual identity.

The design-specific runtime context file. Same instinct as literate programming.

An open-source, local-first agent framework. An AAIF founding project.

A framework that consumes the standards above.

A Markdown file at a site root giving agents a curated map of what to read; llms-full.txt inlines the content. A proposal, not yet a committed standard.

Applies the runtime-context idea to whole websites.

Crafting the input to steer a model's output.

The predecessor context engineering superseded.

The open files that carry intent to an agent at the moment it works, written in Markdown for fidelity.

The delivery layer; AGENTS.md is the most established.

A packaging convention for portable agent capabilities, instructions plus the resources an agent loads when relevant. Anthropic calls these Agent Skills.

Pioneered by Anthropic; sits beside AGENTS.md.

Foundation drift is the documented failure mode of context-only governance: the components come out right while spacing, type, and color quietly break, because on-demand context gets skipped when nobody calls for it.

The canonical case is public. A team shipped 4,300 agent-built prototypes in four months and the audit still found rogue typography and an invented palette. The fix that held was always-on rules for foundations, with validation behind them.

Maker-checker is the four-eyes control banks have run for a century: the person who makes a transaction is never the person who approves it. Applied to agents, it reads: one agent builds, a different agent reads it back, a human signs.

The separation is the point. A builder agent checking its own work inherits its own blind spots. An independent checker on independent context does not. This is the control shape of the readback layer.

The chain that hands context down: values (tokens), meaning (machine-readable logic), intent (spec-driven development), delivery (runtime context).

The site's spine.

The readback is the document the readback layer produces: a monochrome scaffold of what an agent built, where the only color on the page is the color that shouldn't be there. Components carry their real system names. Lookalikes get flagged. Flows map to the patterns they claim to follow.

The name is aviation's. A pilot reads an instruction back before acting on it, so the drift gets caught before it flies. Here a checker agent, never the builder, reads the application back against the system, and a designer signs the page the way designers have always signed redlines. Coined here, July 2026.

The readback layer is the return path of the stack: the criteria, machinery, and sign-offs that check what an agent built against the system it built from. It validates behavior, flows, and states, not just pixels, because what agents produce is interaction design.

The four layers hand context down the chain, one direction. The readback layer closes the chain: one agent builds, a different agent reads the work back, a human signs. Coined here, July 2026. The best census of public design systems, 156 of them, found zero documenting validation of agent-built UI.

The argument that a design system is no longer documentation a human reads but infrastructure an agent executes against. The chain closes with a return path, the readback layer, that checks what agents build against the system they built from.

The synthesis the whole site argues.