The short answer
The design system team should own the AI rules (the design system section of rules files, token descriptions, component metadata, MCP tools, lint rules and evals), because they are design system decisions in machine-readable form. Product teams own their repo-specific rules and the agent output they merge. Make that explicit with four things: a decision-rights table saying who decides and who reviews each artifact; review for rules changes (CODEOWNERS on the files, release notes for changes); a contribution policy for agent-written work (same standard, same review, clearly labelled); and a feedback loop that turns repeated agent mistakes and reported gaps into backlog items. Keep it light: most changes should take minutes to approve.
- A rules-file line can change what hundreds of agent sessions do tomorrow. Review it like a code change.
- The person who merges agent-written code is accountable for it, as for any code.
- Part 18 of 20 in the series on AI-ready design systems.
The problem: new artifacts, no owners
An AI-ready design system creates artifacts that didn't exist before: AGENTS.md sections, token descriptions, metadata files, MCP servers, guidelines for prototyping tools, lint rules, eval tasks. Each one changes what agents do across every product. In most teams, nobody has decided who owns them.
An illustration: the helpful edit
An engineer on the admin team, frustrated that agents kept using Table for a three-row list, added "Prefer DataGrid for all tabular data" to the shared Harbor snippet in their repo's AGENTS.md.
Weeks later, someone updating the snippet template in the design system repo copied it from that repo's AGENTS.md. The next release pushed the line to all twelve product repos. Agents started using the heavy DataGrid for simple lists everywhere.
No one owned the snippet, nobody reviewed the change, and the line contradicted Table's metadata. Agents got two answers and followed the louder one.
The fix isn't a committee. It's clear ownership and the same lightweight review you already use for code. If you're new to design system governance, start with who decides what, and how.
Who owns what: a decision-rights table
| Artifact | Decides | Reviews | Informed |
|---|---|---|---|
| Design system section of AGENTS.md (generated snippet) | Design system team | A system designer and engineer | All product teams, via release notes |
| Repo-specific rules (domain, build, testing) | Product team | Product team | System team, if it touches UI |
| Token descriptions | System designer | System engineer | Product designers |
| Component metadata and usage rules | System designer | System engineer, accessibility specialist | Everyone, via docs |
| Pattern pages | System designer with product designers | Content designer | Everyone |
| MCP server and tool descriptions | System engineer | System designer | Product engineers |
| Lint rules and messages | System engineer | A product engineering champion | Product engineers, before rules become errors |
| Guidelines for prototyping tools | System designer | System engineer | Designers |
| Eval tasks and results | Design system lead | Designer and engineer pair | Sponsors, monthly |
| Agent-written code in a product | Product team | Normal code review | – |
Reviewing changes to AI rules
Rules files, metadata and lint messages are instructions that run in every agent session. Treat changes to them like code changes.
Keep them in the repo
All AI rules live as files in the design system repo, generated where possible. No rules that only exist in a tool's settings screen.
Require review with CODEOWNERS
GitHub and GitLab can require approval from named owners for changes to specific paths.
Check for contradictions
When a rule changes, check it against the metadata, docs and lint messages that cover the same thing. One decision, one wording, generated into every place.
Rerun evals for significant changes
A new rule should improve the eval tasks it targets without making others worse (part 9).
Announce in release notes
"Agents will now use ConfirmDialog for all destructive actions" is a behaviour change teams should hear about. See release notes.
# .github/CODEOWNERS in the design system repo
/tokens/ @kestrel/harbor-design @kestrel/harbor-eng
/src/**/*.meta.json @kestrel/harbor-design
/docs/patterns/ @kestrel/harbor-design @kestrel/content-design
/AGENTS.snippet.template.md @kestrel/harbor-design @kestrel/harbor-eng
/mcp/ @kestrel/harbor-eng
/lint/ @kestrel/harbor-eng
/evals/ @kestrel/harbor-lead
# .github/CODEOWNERS in a product repo: the generated block is read-only here
/AGENTS.md @kestrel/payroll-leads
In product repos, the CI check from part 6 fails if anyone edits the generated block by hand, which is what would have stopped the DataGrid line. Suggestions go to the design system team's front door instead.
A policy for agent-written contributions
Agents now draft design system changes too: new components, documentation, codemods. That's useful, and it needs a clear standard.
| Question | Policy |
|---|---|
| Can agent-written code be contributed to the system? | Yes, under the same contribution model and standard as any other contribution |
| Who is the author? | The person who opened the pull request. They must understand and stand behind every line |
| How is it labelled? | An "ai-assisted" label on the pull request, so reviewers know what to look for |
| What gets extra scrutiny? | Accessibility behaviour, API naming consistency, visual details in dark mode and at other densities, and invented dependencies |
| What can agents never do alone? | Change tokens, deprecate components, change rules files, or merge anything |
Who is accountable for agent output in products?
A simple rule removes most arguments: the person who merges agent-written code is accountable for it, exactly as if they'd written it. The design system team is accountable for whether the system gave agents correct guidance; the product team is accountable for what ships.
Accountable for guidance
- Rules, metadata and docs are correct and consistent
- Lint catches what it should
- Gaps reported by agents are triaged
- Eval results are shared
Accountable for output
- Agent code is reviewed before merge
- Checks pass; overrides are justified
- Local exceptions are recorded
- Gaps are reported, not quietly worked around
Turn agent mistakes and gaps into a backlog
Agents are an unusually honest source of design system feedback. When a rules file says "if no component fits, say so" (part 6), every gap gets reported, not quietly worked around. Collect those reports.
| Signal | Usually means | Typical action |
|---|---|---|
| Same "no component fits" from three teams | A real gap | Score it as a component request |
| Agents keep choosing the wrong one of two components | Purposes overlap | Rewrite both purposes, or merge |
| Searches for "popup" find nothing | Docs don't use people's words | Add the word to Dialog's purpose |
| Lint rule overridden often in one product | The rule is wrong for that case, or a gap | Talk to the team; adjust the rule or add a component |
Keep a decision log
When you decide something about AI and the design system, write it down with the reason. A future person, or an agent reading your docs, will ask why.
## 2026-11-20 · Agents may not edit files in components/ui
Decision: Agents must not modify shared component source in product repos.
Why: Two incidents where an agent edited Button for one screen and changed it everywhere.
Enforced by: AGENTS.md rule; CODEOWNERS on components/ui; eval task "export spinner".
Owner: Harbor team. Review: when we move to package-only distribution.
How governance scales with team size
| Team | What's enough |
|---|---|
| Startup, one or two people own the system | One owner for all AI rules; a short decision log; AGENTS.md reviewed in normal pull requests |
| Mid-size, a small system team | The decision-rights table, CODEOWNERS, an "agent" tag on the front door, monthly eval review |
| Enterprise, many products and a platform team | All of the above, plus an approved list of AI tools and MCP servers, security review (part 19) and quarterly reporting to sponsors |
Common mistakes
Rules edited in many places
The same rule hand-edited in twelve repos becomes twelve rules. Generate one, distribute it, protect it.
A new committee for AI
AI rules are design system decisions. Use the existing governance with a few new artifacts, not a parallel process.
"The AI did it"
Agent output is reviewed and merged by people. Accountability stays with them.
Ignoring agent gap reports
They're free, specific feedback. A team that never acts on them teaches everyone to work around the system.
The short version
- The design system team owns AI rules; product teams own repo rules and the agent output they merge.
- Write a decision-rights table for the new artifacts: rules files, descriptions, metadata, MCP, lint, evals.
- Review rules changes like code: CODEOWNERS, contradiction checks, evals, release notes.
- Agent-written contributions meet the same standard, with a named human author and a label.
- Turn agent gap reports and repeated mistakes into backlog items through your existing front door.
Next: Is it safe to connect your design system to AI tools?
Frequently asked questions
Who should own AGENTS.md and AI rules for a design system?
The design system team should own the design system section, ideally generated and distributed from the system's repo. Product teams own the repo-specific parts. Changes to either should be reviewed like code.
Who is responsible for AI-generated code?
The person who merges it, exactly as if they had written it. The design system team is responsible for giving agents correct guidance; product teams are responsible for what ships.
Should design systems accept AI-written contributions?
Yes, under the same contribution model and standard as any other contribution, with a named human author who understands the change, a label so reviewers know, and extra scrutiny for accessibility and API consistency.
How do I review changes to AI rules files?
Keep them in the repo, require approval with CODEOWNERS, check new rules against metadata and docs for contradictions, rerun evals for significant changes, and announce behaviour changes in release notes.
How can AI agents help improve a design system?
When rules tell agents to report gaps instead of inventing components, their reports, zero-result searches and repeated mistakes become specific feedback. Route them through the system team's normal intake.
Further reading
- GitHub: about code ownersRequiring review for specific paths.
- Design system governanceDecision rights and lightweight process.
- Design system contribution modelOne front door and a scoring formula.
- Design system release notesAnnouncing behaviour changes.
