onsystem

Name: onsystem
Author: dgesteves

@dgestevesMCP server · External

Keeps coding agents on your design system: knows your real components, props, variants and tokens.

Code reviewv0.5.0MITTypeScript

Freeno charge per call

How to install

Runs on your machine from its package; the steps are below.

What it does

Reads
Writes
High impact

Not assessed yet.

What it costs

Free

Odel charges nothing per call. The publisher may charge for its own service.

Runs locally over stdio

This server isn't hosted — your MCP client launches it from a package registry. Use one of the commands below, or drop the config into your client (e.g. Claude Desktop).

npmonsystemv0.5.0

Run

npx -y onsystem

MCP client config

{
  "mcpServers": {
    "onsystem": {
      "command": "npx",
      "args": [
        "-y",
        "onsystem"
      ]
    }
  }
}

README6 min readView on GitHub

Keeps coding agents on your design system: it knows your real components, props, variants and tokens, catches the moment an agent invents one and has it fix it, and the same check gates your PRs. Local, zero config, works alongside @shadcn/lint.

Built for design-system and platform teams with a React design-system package; a shadcn/ui app is the zero-config demo. Formerly @dgesteves/design-system-mcp (what changed).

Website and docs: onsystem.vercel.app, with a playground that checks your own code.

https://github.com/user-attachments/assets/ebfa176b-a66a-4ab7-bc3b-a4787540647f

_{On the website, an agent drafts a settings card, check_ui finds 11 problems with a fix each, and the agent applies them. Then a real Claude Code session with the plugin: Claude looks the components up before writing, and check_ui passes. Last, the benchmark.}

The problem

Coding agents write UI from their training data, not from your design system. Ask for a settings card and you get bg-[#ef4444], p-[13px], a native <button>, variant="danger" on a Button that only has destructive, and <Card.Header> where the system exports CardHeader. On the demo draft above, tsc reports 3 of the 11 problems, and review catches the rest when someone has the time. Describing the design system to the agent helps; what holds is checking what it actually wrote, at the edit and at the pull request.

What it checks

onsystem reads your components, cva and tv variants, parts and tokens from source with the TypeScript compiler, and checks .tsx and .jsx against them. Every finding has a rule id, a location and the fix.

Rule	Default	Catches
`no-unknown-component`	error	Components and parts that don't exist (`<Card.Header>`, typos)
`no-unknown-prop`	error	Props a component doesn't take (`tone`, `isDisabled`)
`no-unknown-variant`	error	Values outside a variant (`variant="danger"`)
`prefer-design-system-component`	error	Native elements the design system has a component for (`<button>` → `<Button>`)
`no-hardcoded-color`	error	Hex, rgb, hsl, oklch and Tailwind palette colors (`bg-gray-100` → `bg-muted`)
`icon-button-accessible-name`	error	Icon-only buttons without an accessible name
`no-hardcoded-spacing`	warn	Arbitrary padding, margin and gap (`p-[13px]` → `p-3`)
`no-hardcoded-radius`	warn	Arbitrary radius (`rounded-[7px]` → `rounded-sm`)

How often it is wrong. The corpus job runs check on 10 public repositories pinned by commit (Documenso, Dub, Cal.com, midday and others, the four monorepos also from their root and Dub's app also with a config: 21 runs, 3,702 distinct findings) and compares the findings with hand labels. In a random sample of 126 findings, 66 are clearly right (52.4%), 55 are debatable and 5 are false positives (4.0%); weighted by each run's and rule's share of all findings, about 1.0% are false positives. Shipped code rarely invents components, props or variants, so those three rules have 1 finding in the corpus and none in the sample; their precision comes from the test suite. The rules reference shows each rule on an example and how to suppress a finding.

Quickstart

Run it from the app's folder or from the monorepo root, with Node.js 20.19 or later:

npx -y onsystem inspect   # what it found; --explain says why
npx -y onsystem check .   # the same check the agent and CI run
npx -y onsystem init      # write the config, and offer a baseline

At a monorepo root, inspect lists every app and design-system package, and check checks each file by its own project's design system.

Claude Code. The plugin brings the hook, the MCP server and a skill:

text

/plugin marketplace add dgesteves/onsystem
/plugin install onsystem@dgesteves

After each Write or Edit of a .tsx or .jsx file, the hook runs onsystem check on it. Errors go back to Claude as a blocking error with the fix, so Claude corrects the file before it moves on; warnings go as a note. It stays quiet in projects without a design system. What it runs and touches.

Cursor or VS Code. , or commit the config. The agent gets the tools and runs check_ui on what it writes.

Other agents. npx skills add dgesteves/onsystem adds the skill to any agent with Agent Skills, and there are plugins for Codex, GitHub Copilot CLI, VS Code and Cursor.

Any MCP client. Run npx -y onsystem as a stdio server. There are configs for Claude Desktop, Codex CLI, GitHub Copilot CLI, Windsurf, JetBrains IDEs, Zed, Gemini CLI and Grok Build.

CI. Install it as a dev dependency, accept the findings the codebase already has once, and fail pull requests only on new ones:

npm install --save-dev onsystem
npx onsystem check . --update-baseline   # writes onsystem.baseline.json: commit it

yaml

- run: npx onsystem check . --format github --require-design-system

Findings show up as annotations on the pull request, and --require-design-system fails the job when the design system is no longer found. CI and baselines has the whole workflow. The GitHub Action, uses: dgesteves/onsystem@v0, annotates only the lines a pull request changed: make it a required check on agent pull requests.

ESLint. The same rules for ESLint 9 and 10: add onsystem.configs.recommended from onsystem/eslint to eslint.config.mjs (ESLint plugin, with @shadcn/lint).

Works with @shadcn/lint

@shadcn/lint checks the Tailwind classes written against a component and the theme (restyling, raw colors, arbitrary and unknown classes) as ESLint or Oxlint rules on Tailwind v4. onsystem checks that the components, props and variant values exist, flags native elements and unnamed icon buttons on Tailwind v3 or v4, and in Claude Code catches an invented one right after the edit, so run both.

Does it help?

Claude Code built the same ten components for vercel/ai-chatbot, once as it ships and once with the plugin, and check scored what it wrote:

Model	Clean without	Clean with the plugin	Design-system errors	Cost
Claude Haiku 4.5	6 / 10	10 / 10	13 → 0	−11%
Claude Opus 5	8 / 10	10 / 10	5 → 0	+7%

It is small: one repository, Claude models only, 40 runs (one per task, model and condition), scored by the tool itself, and run before the rename. With the plugin, the agent looked components and tokens up before writing, and the hook never had to block. Read it as a direction, not a rate; the method, per-run results and every generated file are in the repository.