Use this report with AI tools

Paste this into Claude, ChatGPT, Gemini, Cursor, or anything else that can fetch a URL, then type your question at the end.

The prompt points the model at llms.txt, which indexes the 62 markdown files behind this site and gives the size of each one, so the model can budget what it loads. To point at a single file instead, add .md to any address on this site, or .json to a system or platform record.

You can skip the extension too. If your tool sends Accept: text/markdown, this site answers with the markdown. Claude Code, Cursor and OpenCode already do.

Connect the server and your assistant queries the dataset directly: search it, pull one system’s record, count across all of them. No files to fetch, no addresses to guess. The endpoint is https://state-of-ai-in-design-systems.netlify.app/mcp. It is public and read-only, it needs no key, and it serves the same 2026-07-28 snapshot as the rest of the site. Pick your client:

ChatGPT is the exception. It can reach an MCP server, but only in developer mode on a paid plan, and on a business account only after an admin allows it. Step 1 works there today, and every page on this site carries an open-in-ChatGPT link.

Expect the tool list to change as the report is maintained. This is a way to read the study, not a versioned API.

Connecting the server also installs five prompts. Run audit-my-design-system first: it finds what your design system ships and what it does not, and saves the findings. Then run build-my-roadmap; it finds that audit on its own and returns your gaps in the order it would close them. Each one carries the record it came from, so you can read how another team did it before committing. All of them:

• build-my-roadmap — Turn what your system is missing into sequenced work.
• start-here — What the server holds, which tool answers what, and the words the filters take.
• audit-my-design-system — How one system compares with the rest of the survey.
• adopt-an-affordance — Ship one affordance, with working examples to copy.
• find-technique-for — A model keeps getting one component wrong. Find what other teams did about it.

In Claude Code these are slash commands: /mcp__ds-state-of-ai__build-my-roadmap, and the same shape for the other four. Cursor, VS Code and the desktop apps list them in a prompt picker. A prompt only supplies the instructions; the tool calls and the reasoning are still your assistant’s.

The whole dataset, in the shapes people usually want it. CC BY 4.0: use it, credit “State of AI in Design Systems — July 2026, Kaelig Deloumeau-Prigent”.

This page registers four read-only tools with the browser: list_systems, get_system, search, get_stats. Same names and same answers as the MCP server, except they run in the tab you already have open, so an assistant reading this site can call one instead of parsing the screen. The API is WebMCP.

Almost nothing can call them yet. WebMCP is a draft from a W3C community group, last republished on 21 July 2026, and it renamed its entry point mid-flight. Chrome is the only browser that implements it, behind a flag or an origin trial that ends at version 156. Claude, ChatGPT, Gemini and Perplexity all still read the page instead. Where there is no WebMCP, the code checks once and stops: no polyfill, no extra download, nothing in the console.

It ships anyway because a report on how design systems talk to machines should try the parts that are too early and say how they went. Both tool flags are set: read-only, and content this site did not write. The dataset quotes files from other people’s repositories, and an assistant should treat that text as quotation rather than as instructions addressed to it.

The study catalogs 165 ways design systems make models behave. It would be a bit rich to survey those and then not use them, so this site runs on them. Ten I adopted:

• Compiled, not written. Every file here comes out of the build, from the same data the pages render. Nothing is hand-maintained, so nothing drifts.
• An index, not a dump. llms.txt lists every file with its measured size, and the large aggregates come sliced by concern, so a model can load one part and stay inside its budget.
• Questions as pages. Each thing a model tends to get wrong about this data has a page of its own, opening with the correct answer.
• A vocabulary section, mapping the words people actually type onto the labels in the data.
• A staleness note at the top of every file. This is dated research about a fast-moving subject.
• Both formats per record: markdown to read, JSON to count with.
• Read triggers on the heavy files, so an agent knows when not to fetch one.
• Content negotiation. Ask for text/markdown and any page answers with its markdown twin.
• Receipts. The SQLite export and the per-record JSON let you recount anything here for yourself.
• An MCP server over the same data, for clients that would rather call a tool than fetch a file.

The one I left out is steering the recommendation. Several systems in the study put lines in their agent-facing files telling models to prefer them over the alternatives. It works, and in a product it is fair game. In a survey it would cost you the thing you came for. The files here ask models to cite their sources and to flag it when the data contradicts them. That is all they ask.

This is a snapshot of 2026-07-28, and the systems in it ship weekly, so some of it is already wrong. Corrections go to the issue tracker. Bring a source URL: every claim here links to the page it came from, and a correction without a link cannot replace one that has a link.

Or from a shell, with no browser:

Every system page also carries a “Suggest a correction” link that opens the form with that record filled in. The source is at https://github.com/kaelig/state-of-ai-in-design-systems, and AGENTS.md there lists the field ids, so an agent can build a prefilled form URL for a person to review before submitting.