Agent skill

Color Audit

by rome-os in rome-os/rome

Audit a design system's color palette against measurable color-science disciplines — WCAG/APCA contrast of declared token pairs, perceptual (OKLCH) ramp uniformity, color-blindness safety of…

MITAuto-check passedFrontend & Design

Install Color Audit

skills CLI
$ npx skills add rome-os/rome --skill color-audit -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install rome-os/rome color-audit --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/rome-os/rome.git skills-src && mkdir -p .claude/skills && cp -r skills-src/.claude/skills/color-audit .claude/skills/color-audit && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
color-audit
GitHub stars
748
Token cost
~2.7k tokens
SKILL.md length
765 words
Files
3 (incl. scripts, references)
Skills in repo
18
Repo updated
First seen
Licence
MIT

At a glance

Audit a design system's color palette against measurable color-science disciplines — WCAG/APCA contrast of declared token pairs, perceptual (OKLCH) ramp uniformity, color-blindness safety of…

  • Works in 7 steps: Locate the palette → Extract a palette file → Run the mechanical checks (Tier 1) → …
  • The user asks to review
  • SKILL.md covers Design philosophy (shared with…, Workflow, Passes worth keeping and Not flagged (borderline)
  • Runs JavaScript scripts from its folder; calls node

What it does

Color Audit is an agent skill from rome-os/rome. Audit a design system's color palette against measurable color-science disciplines — WCAG/APCA contrast of declared token pairs, perceptual (OKLCH) ramp uniformity, color-blindness safety of status/categorical sets, token architecture (primitives → semantic → components), dark-mode integrity, and hue budget — and produce evidence-cited findings with concrete fixes. Use this skill whenever the user asks to review, evaluate, or fix design-system colors, palettes, ramps/scales, themes, or dark mode; asks "are our…

Its SKILL.md is about 2.7k tokens, which your agent loads only when the skill is triggered. The skill folder holds 4 other files, including scripts and reference files (for example `references/rules.md`).

It sits in Frontend & Design, covering Theming and dark mode, Accessibility and Design systems. The repository describes itself as: A compounding agent OS for recursive agents. Also an open source alternative to Grok Bot and Meta's Muse. The licence is MIT.

When your agent uses it

  • The user asks to review
  • Fix design-system colors
  • Asks are our colors accessible/consistent?
  • Is this palette reasonable?

Example prompts

  • “are our colors accessible/consistent?”
  • “is this palette reasonable?”
  • “audit our tokens”
  • “/color-audit”

Requirements

  • Node.js

Workflow steps

7 steps, taken from the step headings in SKILL.md.

  1. Locate the palette
  2. Extract a palette file
  3. Run the mechanical checks (Tier 1)
  4. Load the ruleset and run structural checks (Tier 2)
  5. Judged review (Tier 3)
  6. False-positive sweep
  7. Emit the report

What it can do on your machine

Read from SKILL.md and the folder at commit 18057a0. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    Ships 1 file in scripts/ (JavaScript), which the agent can run.

    Shell commands in SKILL.md call:

    • node

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    No URLs in SKILL.md.

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names no API keys, tokens, secrets or passwords.

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

Color Audit loads about 2.7k tokens when it runs, and up to ~6.5k if it reads all its reference files. Until then it costs about 235 tokens; SKILL.md has 765 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~235
When it runs · the whole SKILL.md, loaded when a task matches
~2.7k
With references · SKILL.md plus every file in references/, read only if the agent opens them
~6.5k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check passed

The automated check found no risky patterns in SKILL.md.

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); the scripts in this folder are not scanned.

SKILL.md

The full file from rome-os/rome at commit 18057a0, republished under its MIT licence (© rome-os). 765 words, ~2,688 tokens.

Download SKILL.mdSave it as .claude/skills/color-audit/SKILL.md (or your agent's skills folder). This skill also uses 2 other files; get the full folder from GitHub.
name
color-audit
description
Audit a design system's color palette against measurable color-science disciplines — WCAG/APCA contrast of declared token pairs, perceptual (OKLCH) ramp uniformity, color-blindness safety of status/categorical sets, token architecture (primitives → semantic → components), dark-mode integrity, and hue budget — and produce evidence-cited findings with concrete fixes. Use this skill whenever the user asks to review, evaluate, or fix design-system colors, palettes, ramps/scales, themes, or dark mode; asks "are our colors accessible/consistent?", "is this palette reasonable?", or "audit our tokens"; wants to add or change a theme, accent, or status color safely; or reports contrast/readability/color-blindness concerns — even if they don't say "audit". For behavioral/semantic UX review of views (labels, states, redundancy), use ux-semantics-audit instead; this skill owns everything palette- and token-level about color.

Color Audit

Evaluate a design system's color selection against the codified disciplines from color science and design-system practice (WCAG/APCA, Material HCT, Radix scale semantics, Adobe Leonardo, Stripe's accessible-palette work) and emit findings a coding agent can directly act on. This is a linter for the palette, not an aesthetic critique: most rules are mechanically checkable, and the bundled analyzer computes the numbers so no check is eyeballed.

Design philosophy (shared with ux-semantics-audit — it shapes every judgment call)

  1. Precision over recall. A false positive costs more than a miss: the consuming agent will "fix" a non-problem and degrade a palette someone chose deliberately. When in doubt, don't flag.
  2. No evidence, no finding. Every finding cites the token source (file, line, value) and — for Tier 1 rules — the measured number from the analyzer. If you cannot point at the value and the measurement, the finding does not exist.
  3. Exceptions are where precision lives. Each rule in references/rules.md has an enumerated exceptions list; check it before flagging. Deliberate design (documented OLED black, brand-pinned steps, compressed dark ramps) is a pass, not a borderline flag.
  4. Severity is trust calibration. block = mechanical and near-certain (a declared pair failing WCAG is failing). warn = judgment involved. Never promote a judgment call to block.
  5. Measure, don't estimate. Never state a contrast ratio, lightness value, or CVD verdict from intuition — run scripts/analyze-palette.mjs. A report whose numbers are wrong is worse than no report.

Workflow

Step 1 — Locate the palette

Find where color truth lives. Look for, in rough order: CSS custom properties (:root/theme blocks), a theme/token definition module, Tailwind config, and the framework vocabulary layer that exposes tokens to components.

In this repo the layers are:

  • Primitives (oklch ramps): packages/web/src/styles/primitives.css
  • Semantic values per theme × mode: packages/web/src/lib/themes.ts (light/dark halves per theme)
  • Component-facing vocabulary: the @theme inline block in packages/ui/src/styles.css (its token comments are also the step-semantics documentation)

If the palette lives only in scattered component styles with no token layer, that is itself the headline token-architecture finding — audit what exists and say so.

Step 2 — Extract a palette file

Write the extracted colors into palette.json in your scratchpad, following the schema documented at the top of scripts/analyze-palette.mjs:

  • ramps — the primitive scales, step → color
  • pairs — every declared fg/bg pairing with its use (text | large-text | ui). Derive pairs from the system's own pairing convention (*-foreground partners, on-* tokens, status -fg/-bg families). One palette file per theme × mode — light and dark are separate audits.
  • groups — meaning-carrying sets that must stay mutually distinguishable (status family, categorical/chart series, diff colors)

The script accepts hex, rgb(), and oklch() syntax directly, so paste values as-is. Resolve var() chains and color-mix() by hand to concrete values (note any you had to approximate).

Show full SKILL.md (316 more words)Show less
Step 3 — Run the mechanical checks (Tier 1)
bash
node .claude/skills/color-audit/scripts/analyze-palette.mjs <palette.json> all

Run per theme × mode. The script covers declared-contrast-pairs (WCAG + APCA), ramp-uniformity (OKLCH lightness tables, spacing irregularity, cross-ramp interchangeability), and cvd-safety (protan/deutan/tritan simulation, collapse detection). Its ⚠ flags are advisory — the rules in references/rules.md decide what becomes a finding, and their exceptions lists are the rubric.

Step 4 — Load the ruleset and run structural checks (Tier 2)

Read references/rules.md in full. Then run the grep-backed checks: token-architecture (raw hex/oklch/primitive references/raw framework shades in component code), step-semantics (is there a documented role per step/token; are near-duplicate tokens used interchangeably), state-derivation (ad-hoc hover/active values bypassing the system's state rule), dark-mode-integrity (independently authored dark half + the full contrast rerun against dark values).

Step 5 — Judged review (Tier 3)

hue-budget: list every hue family and its nameable job. Also verify the exceptions you relied on in earlier steps (e.g. the CVD redundant-channel exception requires actually checking usage sites — don't assume icons exist).

Step 6 — False-positive sweep

Re-examine every finding and drop any that:

  • matches an enumerated exception,
  • lacks a concrete citation (token source + measured number for Tier 1),
  • depends on an assumption you did not verify (an "undocumented" intent you didn't search the docs for; a usage site you didn't read),
  • would require the fix to violate another rule.

If a finding survives with genuine uncertainty, keep it at warn and say what would confirm it.

Step 7 — Emit the report

Use exactly this structure:

markdown
# Color Audit: <scope> (<theme> × <mode(s)>)

## Summary
<2-4 sentences: overall assessment, count of block/warn findings, and the
remediation order when findings depend on each other (ramps → contrast/states;
see the cross-references section of rules.md).>

## Findings

### [BLOCK|WARN] <rule-id>: <one-line title>
- **Where**: <token/ramp/component> — `<file>:<lines>`
  ```<lang>
  <minimal quoted value or snippet>
  • Measured: <the analyzer's numbers, for Tier 1 rules>
  • Why it matters: <1-2 sentences tied to this palette, not a rule recital>
  • Suggested fix: <concrete change — target values or token restructure; a code sketch when it fits in a few lines>
  • Confidence: high | medium (warn-tier only; say what would confirm a medium)

Passes worth keeping

<2-5 things the palette gets right that a fix must not regress.>

Not flagged (borderline)

<Candidates examined and declined, each with the exception or reason.>


Order findings: all `block` first, then `warn`, each group by leverage (user impact × fix cheapness). Zero findings is a valid result — say so and fill in "Passes worth keeping".

When proposing replacement values, propose them in OKLCH (adjust L to hit the contrast target while preserving hue/chroma identity) and verify the proposal by running it back through the analyzer — a suggested fix that fails its own target is the fastest way to lose the reader's trust.

**Exception: brand-pinned fills.** If the failing color is a brand/identity value (documented as such, or the owner says so), changing it is usually not on the table — proposing "darken the brand" wastes the finding. Present the brand-preserving alternatives ladder from the `declared-contrast-pairs` rule (flip label polarity, split brand vs action token, demote the fill to non-text duty, soft-fill variant) with each option's measured number, and state the trade-off that picks between them. When the reader may not know the contrast scale, anchor the numbers once: 1:1 invisible, 3:1 large-text floor, 4.5:1 the AA line for body text, 21:1 black-on-white.

### Step 8 — Build the shareable report (Rome surfaces)

When the audit covers a Rome surface and the user wants an artifact to look at, share, or triage, reuse **ux-semantics-audit's report app** at `.claude/skills/ux-semantics-audit/report/` — do not hand-author an HTML page. `findings.tsx` and `repros.tsx` are gitignored per-run outputs rewritten by every audit (seeded from the committed `*.example.tsx` when missing); the chrome, filtering, triage and prompt export are fixed, and the deliverable is the built HTML, never the source. Read `.claude/skills/ux-semantics-audit/references/report-app.md` for the authoring contract, then:

1. Rewrite `findings.tsx` against the `AuditReport` type (rule ids from this skill's ruleset slot straight into `Finding.rule`; use `surface` values like `palette`, `dark-mode`, `status colors`).
2. Rewrite `repros.tsx`. For color findings the honest reproduction is usually **the real tokens doing the wrong thing**: a swatch/ramp strip rendered from the live CSS custom properties, real `@rome-os/ui` components on the failing pair, side-by-side shipped/fixed values, or a CVD-simulated rendering (the analyzer's matrices are in `scripts/analyze-palette.mjs` if a repro needs them inline). "Shipped" mode must show the defect — a failing pair renders at its actual illegible contrast.
3. `node .claude/skills/ux-semantics-audit/report/build.mjs` → single self-contained `dist-report/index.html`.

## Division of labor with ux-semantics-audit

| Question | Skill |
|---|---|
| Is the palette itself sound (contrast pairs, ramps, CVD, tokens, themes)? | **color-audit** |
| Does a *view* misuse color (color-only status, emphasis budget, missing states)? | **ux-semantics-audit** |

The seam is `color-not-sole-channel`: the per-view rule lives in ux-semantics-audit; this skill's `cvd-safety` covers the palette-level half and hands per-view violations off. When one root cause spans both (e.g. no status tokens exist, so views hand-roll colored text), report it here as the palette finding and name the ux-semantics-audit follow-up in the summary.

## What this skill does NOT do

- Aesthetic judgment — whether the brand hue is *pretty* is not auditable; whether it can carry AA text is.
- Full WCAG conformance beyond color (focus order, semantics, zoom) — recommend axe-core.
- Per-view UX review — that's ux-semantics-audit.
- Choosing a brand identity — this skill evaluates and repairs a system around the hues it's given; it only proposes hue changes when a hue cannot meet its assigned job at any lightness.

© rome-os, MIT. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

SKILL.md and 2 other files (scripts, references) in .claude/skills/color-audit of rome-os/rome.

  • SKILL.md
  • references/rules.md
  • scripts/analyze-palette.mjs

Open the folder on GitHubat commit 18057a0

Compare with similar skills

Color Audit next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

Color Audit compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Color Audit this skillrome-os/rome748—~2.7kAutomated safety check: PassMIT
Impeccablebestofjs/bestofjs3.1k26 repos~2.6kAutomated safety check: PassMIT
Material Design 3 UI/UX Guideskydashnet/material-design-3-ui-skill138—~3kAutomated safety check: PassMIT
UI Design Systemtry-works/role-model117—~5kAutomated safety check: PassMIT
Super UI UX Designsyahiidkamil/Software-Engineer-AI-Agent-Atlas401—~9kAutomated safety check: PassNone
Apply Aestheticplugin87/ux-ui-agent-skills1.6k—~597Automated safety check: PassMIT

Similar skills

  • Impeccable

    bestofjs/bestofjs

    A skill your agent uses when the user wants to design, redesign, shape, critique, audit, polish, clarify, distill, harden, optimize, adapt, animate, colorize, extract, or otherwise improve a…

    3.1k GitHub starsUsed in 26 repos~2.6k tokens
    Frontend & DesignAuto-check passed
  • Material Design 3 UI/UX Guide

    skydashnet/material-design-3-ui-skill

    Guides designing, reviewing or implementing interfaces that follow Google's Material Design 3 system: semantic tokens, component states, adaptive layout and accessibility.

    138 GitHub stars~3k tokensUpdated 10 days ago
    Frontend & DesignAuto-check passed
  • UI Design System

    try-works/role-model

    React UI component systems with TailwindCSS + Radix + shadcn/ui.

    117 GitHub stars~5k tokensUpdated today
    Frontend & DesignAuto-check passed
  • Super UI UX Design

    syahiidkamil/Software-Engineer-AI-Agent-Atlas

    Complete UI/UX design capability — a wiki-style knowledge map of design theory (UX laws, Nielsen heuristics, usability, visual hierarchy, typography, contrast/WCAG, design systems…

    401 GitHub stars~9k tokensUpdated 3 mo ago
    Frontend & DesignAuto-check passed
  • Apply Aesthetic

    plugin87/ux-ui-agent-skills

    Applies a chosen visual direction, an archetype or one of 138 named design systems, by remapping design tokens, then checks contrast before it finishes.

    1.6k GitHub stars~597 tokensUpdated today
    Frontend & DesignAuto-check passed
  • Brand Kit Design Tokens

    plugin87/ux-ui-agent-skills

    Builds a from-scratch brand design system as three-tier DTCG tokens plus one theme.css with light and dark modes, checked against WCAG contrast rules.

    1.6k GitHub stars~809 tokensUpdated today
    Frontend & DesignAuto-check passed

More from rome-os/rome

All 18 skills in this repo
  • Audit the subordinate copy in a UI — section descriptions, field helper text, hints, card subtitles, empty-state body copy, tooltip bodies — against the secondary-text ruleset, and emit a per-string…

    748 GitHub stars~2.8k tokensUpdated today
    Auto-check passed
  • UX Semantics Audit

    rome-os/rome

    Audit an existing UI/UX design (React/JSX/TSX components, HTML, or generated app code) against a tiered ruleset of verifiable UX principles, and produce structured, evidence-cited findings that a…

    748 GitHub stars~2.1k tokensUpdated today
    Auto-check passed
  • Add a new Rome-managed OAuth integration for a third-party service so a user can delegate access by clicking Connect, and Rome can act on the service with the delegated token (the GitHub/Slack model…

    748 GitHub stars~3.6k tokensUpdated today
    Auto-check passed
  • Composio CLI

    rome-os/rome

    Help users operate the published Composio CLI to find the right tool, connect accounts, inspect schemas, execute tools, subscribe to trigger events with composio listen, script workflows with…

    748 GitHub stars~2.7k tokensUpdated today
    Auto-check passed
  • File Issue

    rome-os/rome

    File one GitHub issue from a description the user gives — classify it as a bug report, feature request, or task spec, gather what the body needs from the tracker and the code, ask the user only for…

    748 GitHub stars~1.7k tokensUpdated today
    Auto-check passed
  • Routine From Chat

    rome-os/rome

    Turn a plain-language "do this automatically" request into a routine — either event-triggered ("text me when I get an email from my landlord") or scheduled ("remind me every Friday at 9am").

    748 GitHub stars~4k tokensUpdated today
    Auto-check passed

Questions about Color Audit

What does Color Audit do?

Audit a design system's color palette against measurable color-science disciplines — WCAG/APCA contrast of declared token pairs, perceptual (OKLCH) ramp uniformity, color-blindness safety of…. Color Audit is an agent skill from rome-os/rome. Audit a design system's color palette against measurable color-science disciplines — WCAG/APCA contrast of declared token pairs, perceptual (OKLCH) ramp uniformity, color-blindness safety of status/categorical sets, token architecture (primitives → semantic → components), dark-mode integrity, and hue budget — and produce evidence-cited findings with concrete fixes.

When should I use Color Audit?

Color Audit fits situations like: the user asks to review; fix design-system colors; asks are our colors accessible/consistent?; is this palette reasonable?.

How do I install Color Audit in Claude Code?

Run `npx skills add rome-os/rome --skill color-audit -a claude-code`. Or copy the skill folder (.claude/skills/color-audit in rome-os/rome) into .claude/skills/color-audit in your project. Claude Code loads it when a task matches its description.

How do I install Color Audit in Codex?

Run `npx skills add rome-os/rome --skill color-audit -a codex`. Or copy the skill folder (.claude/skills/color-audit in rome-os/rome) into .agents/skills/color-audit in your project. Codex loads it when a task matches its description.

Can I use Color Audit in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add rome-os/rome --skill color-audit -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/color-audit, .gemini/skills/color-audit, .github/skills/color-audit and .opencode/skills/color-audit in your project.

What does Color Audit need to run?

Going by SKILL.md and its folder, Color Audit needs JavaScript for the scripts in its folder and the command-line tools its instructions call (node). Our summary lists: Node.js.

Does Color Audit access the network?

SKILL.md contains no URLs. Any network use would come from the scripts or tools the agent runs. This is read from the text; nothing was executed.

Is Color Audit safe to install?

Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. The check reads SKILL.md only: the scripts in the folder are not scanned, so read them before running anything.

What licence does Color Audit use?

Color Audit is published under the MIT licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Color Audit use?

About 2.7k tokens (SKILL.md is roughly 11k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full. Its references folder adds about 3.8k tokens, read only when the agent opens those files.

What are the alternatives to Color Audit?

Skills that share tags, products or a category with Color Audit: Impeccable (bestofjs/bestofjs, 3.1k stars), Material Design 3 UI/UX Guide (skydashnet/material-design-3-ui-skill, 138 stars), UI Design System (try-works/role-model, 117 stars) and Super UI UX Design (syahiidkamil/Software-Engineer-AI-Agent-Atlas, 401 stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Color Audit?

rome-os (a GitHub organization) maintains it in rome-os/rome, which has 748 GitHub stars. The repository holds 18 skills in this directory. The repository was last updated on October 11, 2026.

Source: rome-os/rome on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.