---
title: "The Living Design System"
url: /living-design-system
description: "A white paper by Pavol Hudran. Agents obey only what is written and enforced, and no framework says which design-system rule wins or what proves it. What the framework needs, and an invitation to build it."
---

## §0 · summary

# The Living Design System

A rule framework that people and agents can obey.


### Summary

A coding agent has no tacit knowledge. It reads the text that it gets, and it obeys what a check enforces. Today, a design system gives the agent its tokens and its components. It does not give the agent a rule book. A rule book has an order of authority, a strictness class for each rule and the evidence that a rule holds.

Other fields solved each of these parts years ago. This paper tells what a design system must get from them, and asks for help to make it a shared framework.

## §1 · problem

### The problem

Before agents, a team kept its rules in the heads of its people. A new member asked a colleague, read old pull requests and learned the habits of the team. An agent cannot do this. It sees only the text that it gets, and it follows a rule only when something stops it.

Public tests show the effect:

- With the component registry only, an agent broke 20 team rules in 9 runs. In 3 of 3 runs, it built its own dialog. A rules file of 12 lines removed all the breaks (Supernova, October 2026).
- From screenshots, an agent used 10 colors outside the system on three screens. From code and tokens, it used none. But it used 7 spacing values outside the scale and 2 components outside the system (Supernova, November 2026).
- 68 % of developers use AI to write code. 32 % of designers and developers trust the output (Figma).
- 59 % of practitioners see UI that goes around the design system (zeroheight, 123 respondents).

The tokens and the components were there in each test. The rules were missing, or no check enforced them.

## §2 · gap

### The gap

The market solved access. A field study examined 21 open-source design systems. 20 of them have an MCP server. MCP is the open protocol that agents use to read a system. Design-system platforms let agents read and edit tokens, components and documents.

No platform has a rule object. A platform keeps its guidance as pages. It does not say which page wins when two pages disagree. It does not say how strict a page is. It does not show which check proves the page, or which part obeys it.

In my research, I did not find a published framework, design system or agent-file format that defines an order of authority between documents. The design-system field solved two halves in isolation: named lint rules and decision logs. No public design system connects a lint rule to the decision that it enforces.

## §3 · parts

### The parts exist in other fields

Safety-critical software, accessibility and security compliance solved each part. Their names did not come into the design-system field.

| Need | Field | Norm |
|---|---|---|
| A decision record with an "Enforced by" field | Software architecture | MADR 4.0: "Confirmation" |
| The anatomy of a rule, with test cases | Accessibility | W3C ACT Rules Format 1.1 |
| Strictness classes and approved exceptions | Automotive software | MISRA Compliance:2020 |
| A log of findings with stable rule ids | Static analysis | OASIS SARIF 2.1.0 |
| Words that make a requirement | Standards writing | RFC 2119, ISO/IEC Directives Part 2 |
| Which rule wins | Law, compilers, agent tools | lex superior, posterior and specialis. Rust `forbid`. GitHub Spec-Kit |
| One rule set for each product or brand | Security compliance | NIST OSCAL profiles |
| A file format for tokens | Design tokens | DTCG 2025.10 |

The one part that nobody supplies is the order of authority with a class that no rank can override. For an agent, it is the most important part.

## §4 · living

### What "living" means

I call a design system "living" when it has these five properties:

| # | Property | Test |
|---|---|---|
| L1 | Current | Each view comes from the sources at the commit that you look at. No person keeps a copy by hand. |
| L2 | Self-proving | Each decision shows its check and the last result. Each part shows the decisions that govern it. |
| L3 | One door | Each change goes through one change request, with a visual difference and named approvers. |
| L4 | One text | People and agents read the same generated text. |
| L5 | Versioned | Each published state has a version. A consumer can cite the version and the decision. |

A design file can be a source of ideas and evidence. It is not the authority. The authority is the set of decisions in the sources, with their checks.

## §5 · framework

### The minimum framework

These eight requirements are the smallest set that I found sufficient. Each one has a test.

| # | Requirement | Test |
|---|---|---|
| R1 | One page declares the order of authority. It gives the ranks of the documents, the rule for a conflict in one rank and the Mandatory decisions. | An agent that gets two documents that disagree can find the winner on that page. |
| R2 | Each decision is a record with an id, a status, a strictness class and an "Enforced by" field. An id is never used again. | A script finds no decision without a class or an "Enforced by" field. |
| R3 | There are three strictness classes. Mandatory: nothing overrides it. Required: an approved exception can override it. Advisory: a recommendation. A lower rank can make a rule stricter. It cannot make it less strict. | A tool rejects a rank or a profile that makes a Mandatory decision less strict. |
| R4 | Each rule that a tool enforces has a stable id, its decision, its applicability and test cases that pass, fail and do not apply. | The failed test case makes the check fail. Without it, "Enforced by" is a claim. |
| R5 | A failed check proves that a decision is violated. A passed check does not prove that the decision is met. A rule that a tool cannot decide gets a review by a person. | The compliance summary says "compliant" only with a clean run and, where necessary, a review. |
| R6 | An exception is a record with the rule, the place, the cause, the precautions and the person who approved it. Its id is in the source, next to the exception. | An exception without an approver does not count. |
| R7 | The checks write one evidence log in a standard format. Each finding names its rule, and each rule names its decision. | From a finding, you can go to the rule and to the decision in two steps. |
| R8 | A missing part or a new rule starts as a proposal, not as an invention. An agent writes the proposal. A person approves it. | No new part enters the system without an approved proposal. |

A small team can start with R1, R2 and one check. The other requirements come when the system grows.

## §6 · limits

### What this framework is not

- It is not a product. A platform, a repository or a set of scripts can apply it.
- It is not a replacement for design. People continue to design. The framework says where a decision lives and which check proves it.
- It is not a score. A design system does not get a number. It gets a list of decisions, with the proof for each one and its gaps.

Open questions:

- What is the smallest format for the decision record and the rule entry that tools can share?
- How does a platform show the order of authority to an agent through MCP?
- What does adoption cost? No team has public data at this time.

## §7 · join

### Join the effort

I want to make this a shared, open framework, not one more internal convention. I look for design-system owners, tool makers and people from accessibility, safety and compliance standards. If you want to help, write to me with the form that follows. I read each message myself.


## §8 · references

### References

- [MADR 4.0](https://adr.github.io/madr/), Markdown Architectural Decision Records
- [W3C ACT Rules Format 1.1](https://www.w3.org/TR/act-rules-format/), Recommendation of 5 February 2026
- [MISRA Compliance:2020](https://misra.org.uk/app/uploads/2021/06/MISRA-Compliance-2020.pdf)
- [OASIS SARIF 2.1.0](https://docs.oasis-open.org/sarif/sarif/v2.1.0/sarif-v2.1.0.html)
- [RFC 2119](https://www.rfc-editor.org/rfc/rfc2119) and [RFC 8174](https://www.rfc-editor.org/rfc/rfc8174)
- [ISO/IEC Directives Part 2](https://www.iso.org/sites/directives/current/part2/index.xhtml)
- [Rust lint levels](https://doc.rust-lang.org/rustc/lints/levels.html)
- [GitHub Spec-Kit](https://github.com/github/spec-kit)
- [NIST OSCAL profiles](https://pages.nist.gov/OSCAL/learn/concepts/layer/control/profile/)
- [DTCG 2025.10](https://www.designtokens.org/tr/2025.10/), a Final Community Group Report
- Supernova tests: [registry and rules file](https://www.supernova.io/blog/shadcn-mcp-design-system), October 2026; [screenshots and code](https://www.supernova.io/blog/claude-design-design-system), November 2026
- [State of AI in Design Systems](https://state-of-ai-in-design-systems.netlify.app/), field study of July 2026
- [Figma AI report](https://www.figma.com/blog/design-systems-ai-mcp/)
- [zeroheight, State of AI in Design Systems 2026](https://zeroheight.com/resources/state-of-ai-in-design-systems/)
