Agent Skills

AI agent skills for Claude Code and compatible agents

Tested per skill, scanned by Cisco's skill-scanner.

latest ci scan branch license stars coroboros.com

Install

Install via skills.sh:

# All skills
npx skills add coroboros/agent-skills

# Individual skill
npx skills add coroboros/agent-skills --skill <name>

Requirements

  • bash
  • python3 (3.10+, stdlib only — no pip install needed)
  • A filesystem

Some skills wrap external CLIs — each is declared in its SKILL.md.

Skills

Skills are grouped by plugin. Each plugin collects related skills — expand any section below to see usage, flags, and behavior. Companion skills live in their tool's repo and install from it — see Companion Skills.

Plugin Skill Description
Workflow forge Research, weigh approaches, decide — emit one apex-ready plan
Workflow apex Structured implementation — Analyze, Plan, Execute, eXamine
Workflow ultrapex Judgment-first APEX for Fable-class models — invariants, parallel subagents, adversarial verification
Workflow oneshot Single-pass Explore-Code-Test for small, well-scoped tasks
Coding scaffold Bootstrap Next.js/Astro projects on Cloudflare Workers
Coding code-ultrareview Eight-axis judgment review at full strength, in-session — fresh eyes before commit
Design award-design Frontend design engineer for award-winning sites — forces a visual universe, builds it, audits any site
Design design-system Govern an existing DESIGN.md — token enforcement plus a CLI lifecycle
Claude Code claude-md Create and optimize CLAUDE.md and .claude/rules/
Claude Code agent-creator Expert guidance for creating Claude Code subagents
Media video-loop Loop background videos with invisible cut points
Media audio-loop Gapless web-ready ambient audio loops (FLAC + Web Audio)
Media suno-produce Turn a music brief into Suno v5.5 prompt artifacts
Media markitdown Convert PDF/Office/HTML/audio/YouTube to Markdown via Microsoft's CLI
Media download-media Download video, audio, playlists, clips, subtitles from ~1800 sites via yt-dlp
Productivity notion Notion via the official MCP connector, or the ntn CLI for uploads and CI
Writing brand-voice Govern BRAND-VOICE.md — extract, update, validate; feeds humanize-en -f
Writing write-clear-readme Author, audit, or polish READMEs — clarity, structure, concision
Writing humanize-en Strip AI tells from English prose — brand-aware via -f BRAND-VOICE.md
Companion scrybe Offline Whisper speech-to-text — transcripts, subtitles, translation
Companion skillward Vet an untrusted skill, plugin, or MCP server before install — offline scanner ensemble, one verdict
Companion shellscan Find and lint every shell in a project — .sh, shebangs, GitLab CI YAML
Companion karate Write, run, and triage Karate API and integration tests

Skills inherit the session model — no model: pins, so a stronger session is never downgraded by a skill. Scope is two-tier per the Agent Skills spec: portable skills omit the compatibility field entirely; Claude Code-optimized skills declare it and degrade gracefully on any open-standard agent (see Standards).

Workflow Skills

Strategic thinking, planning, and implementation — forge, apex, ultrapex, oneshot.

forge

Pre-implementation thinking — research the problem space, weigh approaches with devil's-advocate rigor, decide what's reversible while surfacing the load-bearing forks for the user, and emit one apex-ready plan. The "think" half; apex is the "build" half.

Usage

# Exploratory question — default emits a Decision and pauses for decompose
/forge should we use Neon or Supabase for our serverless Postgres?

# Build verb in the idea — promotes to a Spec with workstreams
/forge -s add user authentication with OAuth and email/password

# Auto mode + create GitHub issues
/forge -s -a -i migrate from REST to GraphQL

Flags

Flag Description
-s / -S Save artifact to ~/.agents/output/{project}/forge/forge-{slug}.md / force no-save
-i / -I Create GitHub issues from workstreams (implies -s) / disable
-a / -A Auto mode — skip Q&A, decide reasonable forks, no revision pause / disable
-e / -E Economy mode — no subagents (Hunt research floor and Judge's adversarial panel) / disable
-f Load prior context (forge plan, RFC, GitHub issue #N or URL)

Uppercase forms disable the ambient default when the skill runs with a pre-set mode. Requires gh authenticated when using -i or passing a GitHub URL/#N to -f.

What it does

  1. Hunt — frames and reframes the real problem, then researches wide via parallel subagents above a hard floor: ≥1 codebase + ≥1 external agent every run, -e the only escape. Triangulates sources rather than picking one, and auto-launches a second research round when the premortem surfaces an unresearched failure mode. On-demand references for breadth (research-discipline.md), the 5-question clarify playbook (clarify-playbook.md), and subagent prompt skeletons (subagent-prompts.md).
  2. Judge — diverges ≥3 structurally distinct approaches, stress-tests with premortem + steelman, then runs an adversarial panel (3-5 lensed clean-context critics in parallel) and a bounded convergence round on the survivors — the same conversation cannot reliably argue against the plan it just shipped (adversarial-panel.md).
  3. Decide — three tiers: decide the reversible and conventional calls, surface the structurally load-bearing forks for the user (named with the pick, the runner-up, and what would flip it), escalate the few forks the user genuinely owns.
  4. Forge — chooses the artifact shape, walks a pre-save audit, saves, validates (when there are workstreams), pauses for revision under non-auto, then routes.

Routing. Default = # Decision: (terminal — present and ask the user whether to decompose into workstreams, then wait). Promotes to # Spec: (with 3-7 workstreams + /apex bridge) when -a is set, when -i forces issue creation, when -f points at a prior Spec, when the idea carries an unambiguous build verb (build, add, implement, migrate, refactor, create, …), when it carries an explicit decomposition signal (plan, break down, spec out, workstreams, issues, roadmap), or when the Decision IS the build plan.

Sources

apex

Systematic implementation using the APEX methodology — Analyze, Plan, Execute, eXamine — with parallel subagents and self-validation.

Usage

# Autonomous + save outputs
/apex -a -s implement user registration

# From a GitHub issue
/apex -f "#42" implement what issue 42 describes

# From a prior forge plan
/apex -f ~/.agents/output/{project}/forge/forge-{slug}.md implement WS-1

# Resume a previous task
/apex -r 01-auth-middleware

Flags

Flag Description
-a / -A Autonomous mode — skip confirmations / disable
-s / -S Save outputs to ~/.agents/output/{project}/apex/{task-id}/ / force no-save
-e / -E Economy mode — no subagents / disable
-b / -B Branch mode — verify not on main, create branch if needed / disable
-g / -G Wire /goal to loop step-04 until AC verified (auto-on under claude -p; requires Claude Code v2.1.139+) / disable
-f Load prior context (GitHub issue #N, forge plan, RFC)
-r Resume a previous task by ID
-i Interactive flag configuration

Uppercase forms disable the ambient default when the skill runs with a pre-set mode.

What it does

  • Analyze — launches 1–10 parallel subagents based on task complexity. Infers acceptance criteria in Given/When/Then form with explicit ## Not Included negative scope. When -f points to a spec (H1 # Spec: + ## Workstreams), accepts the spec's AC verbatim (closure rule) instead of re-inferring.
  • Plan — file-by-file implementation strategy with AC mapping. Inline Challenge mini-phase (premortem + alternative consideration) stress-tests the plan. Surgical-scope advisory fires when the plan touches >5 files, >2 systems, or introduces cross-cutting concerns — advisory only, never blocks.
  • Execute — todo-driven implementation with progressive step loading.
  • eXamine — derivation lens (code↔plan reconciliation, classifying each divergence as GAP / SCOPE-ADD / DECISION-OVERRIDE / CONSISTENT) runs before typecheck/lint/tests. GAP blocks completion; SCOPE-ADD advisory unless declared in negative scope; DECISION-OVERRIDE surfaces for user judgment. Optional /goal integration via -g loops the session until AC verified — transcript-only Haiku evaluator, requires Claude Code v2.1.139+; auto-on under claude -p.
  • Resume — -r auto-validates state via validate_state.sh before restoration; partial or corrupt task dirs fail loud rather than cascade.

Accepts output from forge via -f. Works standalone.

Trust model

Analyze fetches third-party content into the workflow — web research via general-purpose subagents, library docs via Context7, GitHub issue bodies via -f #N, any file passed to -f. An adversarial document hosted at a fetched URL, or pasted into an issue body, can attempt indirect prompt injection. User review of the analysis report before approving the plan is the trust boundary — confirm the surfaced files, patterns, and acceptance criteria match intent. Pass -e (economy mode) to disable subagents and remove the third-party surface entirely. Full disclosure in skills/apex/SKILL.md § Trust model.

Sources

ultrapex

Outcome-driven end-to-end implementation for Fable-class frontier models — the judgment-first sibling of /apex: same mission, invariants instead of step scripts.

Usage

# Implement end to end, save the report
/ultrapex -s implement user registration

# Build a forge plan
/ultrapex -f ~/.agents/output/{project}/forge/forge-{slug}.md

Flags

Flag Description
-s Save the final report to ~/.agents/output/{project}/ultrapex/
-f Feed a producer artifact (usually a forge plan) as the task context

What it does

Five invariants instead of gated steps: understand before building, decide and commit (pause only at genuine forks), build complete and scoped, verify adversarially with fresh-context refuter subagents scaled to blast radius, report grounded in tool-result evidence. Self-scoped by a Model scope section — on models below Fable-class it routes to /apex, which keeps step gates, resume, and economy mode.

oneshot

Single-pass feature implementation — Explore, Code, Test. Ship now, iterate later.

Usage

/oneshot add dark mode toggle to the navbar
/oneshot #42

What it does

  1. Resolve — if input is a GitHub issue (#N or URL), fetches via gh and uses the title/body
  2. Explore — finds 2–3 key files, searches for patterns (no tours)
  3. Complexity check — if >5 files or multiple systems, suggests /apex or /forge instead
  4. Code — follows existing codebase patterns exactly
  5. Test — runs lint and typecheck, fixes only what it broke

One task only. No tangential improvements, no refactoring outside scope. Stops after 2 failed attempts.

Sources

Coding Skills

Bootstrap projects and review changes before commit — scaffold, code-ultrareview.

scaffold

Scaffold new web projects with an opinionated stack on Cloudflare Workers.

Strict opinion — no Vercel/Netlify, no ESLint/Prettier. Use a different scaffold for any other stack.

Requirements

  • pnpm — enable via Corepack: corepack enable && corepack prepare pnpm@latest --activate
  • Node.js ≥ 22

Usage

/scaffold next-cloudflare my-saas
/scaffold astro-cloudflare landing-page
/scaffold next-cf                        # alias

Scaffolds

Scaffold Framework Infra Key stack
next-cloudflare Next.js (App Router) Cloudflare Workers (OpenNext) Drizzle + Neon, Better-Auth, shadcn/ui, Vitest, Playwright
astro-cloudflare Astro (SSG-first) Cloudflare Workers Zero JS default, Content Collections, SEO rules

Shared: TypeScript strict, pnpm, Biome, Tailwind CSS.

What it does

Runs the official framework CLI, overlays the opinionated config (Biome, Cloudflare Workers, CLAUDE.md, pnpm scripts, .worktreeinclude — copies dev-critical gitignored files into Claude Code worktrees), and installs the full stack. Chains to /award-design then /design-system for design tokens.

code-ultrareview

Eight-axis judgment code review at full strength, in-session — every axis run, full battery, no sampling. The 8 axes (Correctness, Simplification, Tests, Documentation, Style, Intent, Design/API, Performance) run as parallel Explore subagents; Coherence joins as a 9th when a manifest, SKILL.md, tsconfig.json, pyproject.toml, Cargo.toml, go.mod, or root README.md is in the diff. In-session on the user's own subscription — distinct from Anthropic's remote /ultrareview.

Usage

/code-ultrareview                              # full 8-axis review, print report
/code-ultrareview -s                           # save the report + JSONL for /apex -f
/code-ultrareview -b origin/main               # review HEAD against an explicit base
/code-ultrareview --verify-build               # promote sub-80 findings via real build verification
/code-ultrareview --mutation-test              # add Stryker / Pitest / mutmut on changed files
/code-ultrareview --reconcile @auto            # add Intent-axis derivation sub-mode
/code-ultrareview --apply-safe                 # full review + gated low-risk fixes
/code-ultrareview --preflight                  # list tools the battery would run, no review
/code-ultrareview --axes correctness,tests     # subset of axes

Flags

Flag Description
-s / -S Save the report + JSONL to ~/.agents/output/{project}/code-ultrareview/code-ultrareview-{slug}.{md,jsonl} / force no-save
-b <ref> Override the review base (skip auto-detection)
--repo-kind <kind> Override the scope classifier. <kind> ∈ skills, app, library, docs, monorepo, python, rust, go, unknown. Persistent per-repo at .code-ultrareview.yaml; the flag wins on conflict. Invalid value exits 2
--reconcile <input> Activate the Intent-axis derivation sub-mode. <input> ∈ @auto, @pr, an explicit path or directory, gh:pr:<N>, gh:issue:<owner>/<repo>#<N>, or a GitHub issue URL
--verify-build Confirm sub-80 findings against a real build before validation
--mutation-test Stryker (JS/TS), Pitest (JVM), or mutmut (Python) on changed files only. Surviving mutants route to the Tests axis as Medium severity
--apply-safe Opt-in writers — manifest version sync, structured-field description sync (full-agreement guard), one failing test per confirmed bug. Diff preview + per-file confirmation
--include-prose Coherence axis compares README freeform paragraphs (default: structured fields only)
--axes <list> Comma-separated axes subset (e.g. correctness,tests). Default: all 8 + Coherence when triggered
--preflight List detected tools per repo_kind + install commands for missing ones. Informational, no install

The five phases

  1. Scope — deterministic, no LLM: resolves the diff, classifies the repo (one of 9 kinds), reads the CLAUDE.md chain, decides whether Coherence activates.
  2. Tool battery — per-language static analysis (table below); findings carry confidence: 100 and skip validation. Never auto-installs.
  3. Axis review — 8–9 parallel Explore subagents, each scoped to its axis with the diff + filtered tool findings, scoring 0–100 against the verbatim Anthropic rubric.
  4. Validation — a Haiku validator re-scores every sub-80 finding. A2 no-silent-drop: promoted (≥80), demoted with reason, or surfaced in ### ⚠️ Unverified — never omitted. --verify-build runs before this.
  5. Synthesis — dedup, inter-axis precedence, a Ship / Fix-then-ship / Needs work verdict, Conventional Comments JSONL, and a mandatory What I did NOT check closing section (defers security to /security-review, runtime perf, flaky detection, skipped tools).

Tool battery — tool → axis

npx / uvx wrappers are zero-install (cached after first run); native binaries are PATH-only, skipped gracefully when absent. Run /code-ultrareview --preflight for the exact list on the repo plus install commands for the missing ones.

Tool Axis Wrapper
knip Simplification (JS/TS dead code) npx
jscpd Simplification (cross-language duplication) npx
markdownlint-cli2 Documentation (Markdown lint) npx
api-extractor Design/API (TS public surface) npx
lizard Simplification (cyclomatic complexity) uvx
vulture Simplification (dead Python code) uvx
semgrep Correctness + Performance (perf-rules) uvx
vale Documentation (prose lint) native
oasdiff Design/API (OpenAPI breaking changes) native
atlas Design/API (DB migration lint) native
deadcode Simplification (Go unreachable) native
gocyclo Simplification (Go complexity) native
dupl Simplification (Go duplication) native
cargo-machete Simplification (Rust unused deps) native

Bundled Semgrep perf-rules (references/perf-rules/) route N+1 and sync-IO findings to the Performance axis.

Rules

  • Zero auto-install — never runs brew / cargo / go / pip / npm -g; natives are installed explicitly.
  • Cite precisely — every finding carries file:line; CLAUDE.md findings quote the violated rule verbatim.

Sources

Design Skills

Recommend design archetypes and enforce DESIGN.md tokens across UI — award-design, design-system.

award-design

Takes the lead on any frontend design, build, or redesign — an art-director (ambient forcing, not a phased checklist) targeting Awwwards SOTD 7.5+, FWA, CSSDA. Forces a committed, anti-default visual universe, writes it as a DESIGN.md (the Google open standard) when none exists, adapts to an existing one and alerts when it is thin, then builds the frontend itself under that direction. Frontend only — single-token tweaks route to /design-system, never backend. A review mode audits any site at any time.

Usage

/award-design landing page for a sustainable coffee brand
/award-design -u https://linear.app portfolio for a motion designer
/award-design review https://example.com         # audit an existing site

-u <url> reverse-engineers the brand from a live site as the archetype seed; the observation informs the direction but doesn't constrain it — the brief is still the destination. review <url|path> runs the adversarial critic against any site at any time, no build required.

Archetypes

Each archetype anchors to a canonical reference (article-credentialed; Spatial Organic is the emerging exception). The reference file splits DNA (non-negotiable identity, mood-agnostic) from common expressions (2–4 named stacks per archetype), so one DNA admits multiple valid styles — Immersive runs cinematic-dark, editorial-portrait, or daylight-automotive without losing identity.

Archetype Canonical reference Ideal for
Minimalist Terminal Industries (SOTM Sept 2025) SaaS, luxury, architecture, portfolios
Brutalist FlowFest 2025 (SOTD July 2025) Creative agencies, indie tech, festivals
Editorial Siena Film Foundation (SOTM April 2025) Media, fashion, cultural institutions
Bold / Maximal Ponpon Mania (SOTM Oct 2025) Entertainment, music, Gen Z brands
Immersive / Cinematic Lando Norris (Site of the Year 2025) Automotive, luxury, gaming, athlete portfolios
Experimental Bruno Simon (SOTM Jan 2026) Developer portfolios, art institutions
Corporate Luxury Cartier WAW 2025 (SOTM Aug 2025) Fashion, hotels, jewelry, wealth, watchmaking
Bento / Card Anime.js v4 (SOTM May 2025) SaaS product pages, AI products, feature comparisons
Spatial Organic trend-credentialed (Arc, Granola) Sustainability, wellness, post-2025 creative studios

Key features

  • Ambient forcing, not a checklist — an art-director, not a project-manager. The direction rules are the air the whole build breathes, from the first line to the last, never phases to clear before coding; once the universe is set, it never relaxes into a default
  • Universe mandatory — no frontend ships without a committed world: Design Read (one line — page kind, audience, vibe, archetype line), Concept Spine (one named world that layout, type, color, motion, and copy each express), anti-default-with-teeth (name the lazy default, reject it; rotate the palette / type pairing / hero layout across builds; invent ≥1 new mechanic per build), signature moment (one loud climax + a quiet second-read detail). A thin, literal, or safe universe is refused and regenerated
  • Commit-and-prove — a binding design_plan before any JSX commits explicit per-element choices (hero architecture, type stack, color roles, the real visual per section, motion paradigms, the signature beat, spacing rhythm) and proves each load-bearing one (the clamp()/max-w that lands the H1 in ≤2 lines, the named hero asset, the easing + trigger for the signature, the grid spans with zero empty cells). Drifting to a default mid-build is forbidden
  • Builds the frontend itself — conceives AND builds in one coherent context, no handoff; claimed = shown (every universe claim present in the code, not just promised), section by section, no section ships generic
  • Verify in the browser — when Chrome DevTools MCP or the dev-browser CLI is available, renders and screenshots its work (mobile + desktop) to trace computed styles to the DESIGN.md tokens and reach pixel-perfect; the pre-ship pass reads the rendered page, not the markup
  • Review mode — award-design review <url|path> is the always-on adversarial fresh-eyes: refute by default against the awwwards rubric (Nielsen usability heuristics included) + the anti-slop catalog + the DESIGN.md, with cited fixes and an on-track / off-track verdict, never a silent pass. Runs internally twice — at the direction-commit and before ship
  • Brief-signal routing — picks a first-pass archetype from the brief (luxury → Corporate Luxury, bento → Bento, bespoke nav → Experimental); a hybrid brief mixes via the remixing arbitration framework. Match the brand's personality, not what is trending
  • Anti-AI-slop ambient — axiomatic rejections (the AI-purple gradient, Inter/Roboto on the display face, pure #000/#fff, placeholder names and fake stats, the centered-hero-over-dark template, 3 equal feature cards, SECTION 01 labels, a hero with no real visual) plus countable archetype-scoped checks, applied through the build — not held back as a final gate
  • Imagery — real assets, an acquire-and-verify protocol for branded builds (secure real logos and photography, verify resolution and rights), never faked out of divs, never a CSS-pastiche product shot
  • Stack — locked universal craft every build (GSAP + Lenis + CSS scroll-driven + View Transitions API + variable fonts + OKLCH) with the framework keyed to the archetype: Astro for content/perf archetypes (zero-JS LCP), TanStack Start (React on Vite + Nitro) for motion/3D. The existing project's stack wins; host orthogonal via Nitro
  • WebGL/3D delegation — a self-contained WebGL/R3F signature delegates to ONE specialist subagent briefed with the DESIGN.md and pointed at the embedded ingredient cheats (web3d-for-sites, web-audio, ogl-shaders) or the official GSAP/R3F skill by name; the returned module is integrated in-context. Never co-writes a shared file, never more than one parallel writer
  • Ship-ready — the judged craft floor (semantic HTML + landmarks, :focus-visible, reduced-motion, AA contrast, real imagery, explicit <img> dimensions) auto-authored inline; production plumbing (canonical/OG, sitemap/robots, JSON-LD, PWA manifest, prerender, blur-up) offered per-brief, never auto-built
  • Judging criteria — Design 40%, Usability 30%, Creativity 20%, Content 10%. Performance targets LCP < 1.5s, CLS < 0.05, INP < 100ms
  • DESIGN.md handoff — authors the DESIGN.md up front and builds under it; /design-system governs it afterward (drift, updates, audits). Clean author-vs-govern boundary

Sources

design-system

Govern an existing DESIGN.md — the Google DESIGN.md open standard (YAML frontmatter tokens + eight prose sections). Auto-activates during UI edits to enforce token-only sourcing when a DESIGN.md is present, and steps aside when none exists — it never blocks the edit and never authors a design file from scratch (that is /award-design's job; it forces a universe, writes the DESIGN.md, and builds the frontend). Exposes seven CLI-backed subcommands for the full DESIGN.md lifecycle. audit-extensions closes the bidirectional drift loop between DESIGN.md extension namespaces (motion, shadows, aspect-ratios, heights, containers, breakpoints, z-index, border-widths, opacity, scroll-triggers — see references/extended-tokens.md) and the globals.css @theme mirror.

Requirements

  • npx (for the @google/design.md CLI wrapped by audit, diff, export, spec). Missing → subcommands fall back to manual validation against the bundled spec.

Usage

Auto-activates when editing:

  • src/components/**, src/app/**, src/pages/**, src/layouts/**, src/styles/**
  • src/features/*/components/**
  • DESIGN.md, tailwind.config.*

Also invocable directly via /design-system with one of seven subcommands:

/design-system audit                                # lint ./DESIGN.md, report with fix proposals
/design-system audit ./docs/DESIGN.md -s            # save the report under ~/.agents/output/
/design-system diff                                 # diff ./DESIGN.md vs HEAD (git-aware)
/design-system diff old.md new.md                   # two-file diff
/design-system export tailwind                      # → tailwind.theme.json
/design-system export dtcg -o tokens.json           # W3C DTCG format
/design-system spec --rules                         # emit canonical spec + lint rules
/design-system migrate ./legacy-DESIGN.md           # Stitch 9-section → Google standard
/design-system init editorial                       # scaffold a minimal DESIGN.md
/design-system audit-extensions                     # YAML ↔ prose ↔ globals.css drift check
/design-system audit-extensions --strict            # promote orphan warnings to errors

Subcommands

Subcommand Purpose Output
audit (aliases check, lint) Lint DESIGN.md + produce fix proposals per finding Markdown report
diff Regression check between versions — git-aware default Markdown report
export Convert tokens to Tailwind theme or W3C DTCG tailwind.theme.json / tokens.json
spec Emit the canonical spec from the installed CLI Markdown or JSON
migrate Port legacy Stitch 9-section DESIGN.md → Google standard New DESIGN.md + backup + migration report
init Scaffold a minimal valid DESIGN.md (fallback from /award-design) New DESIGN.md
audit-extensions Bidirectional drift check between DESIGN.md extension YAML, prose refs, and globals.css @theme Markdown report

Flags

Flag Subcommand Description
-s audit, diff, audit-extensions Save the report to ~/.agents/output/{project}/design-system/{sub}/report.md
-o <path> export, spec, migrate, init Output file (defaults vary by subcommand)
--json audit, diff, spec, audit-extensions Raw JSON instead of the formatted report
--strict audit, audit-extensions audit: cross-check the DESIGN.md against /award-design's anti-patterns catalog. audit-extensions: promote extension-orphan-css warnings to errors
--rules spec Append the active lint rules table
--rules-only spec Output only the lint rules
--format tailwind|dtcg export Target format (default: tailwind)
--base <ref> diff Git comparison base (default: HEAD)
--css <path> audit-extensions Path to globals.css (auto-detected when omitted)

When dev-browser is installed globally (pnpm add -g dev-browser / npm i -g dev-browser / bun add -g dev-browser), audit auto-suggests visual verification in its Next steps — no flag needed. Skip silently otherwise.

What it does

  • Source of truth — reads DESIGN.md before any UI code; colors, fonts, spacing, and radius come only from its YAML tokens, never arbitrary values (text-[13px]) when a token exists. Maps to CSS custom properties and tailwind.config.ts (or export tailwind).
  • Post-edit invariant — after any DESIGN.md mutation (token update, migrate, init), runs audit and surfaces findings; a mutation that leaves errors behind is not done.

DESIGN.md structure

A DESIGN.md has two layers: YAML frontmatter (normative design tokens) + eight ordered prose sections (rationale).

Canonical YAML token groups (validated by the Google CLI): colors, typography, rounded, spacing, components — with {path.to.token} cross-references. Components bind ONLY to the closed set of 8 property tokens (backgroundColor, textColor, typography, rounded, padding, size, height, width).

Extension YAML namespaces (preserved-but-unvalidated per the Google spec, validated by audit-extensions against the globals.css @theme mirror): motion, shadows, aspectRatios, heights, containers, breakpoints, zIndex, borderWidths, opacity, scrollTriggers. Extension tokens are referenced from prose only — never as components: keys (the empirical lint-failure mode). See references/extended-tokens.md for the full convention and the 1:1 CSS-mirror mapping table.

Eight ordered prose sections: Overview, Colors, Typography, Layout, Elevation & Depth, Shapes, Components, Do's and Don'ts. Per-section token and extension mapping: references/design-md-spec.md.

Lint rules — audit runs the Google CLI rules (broken-ref, contrast-ratio at WCAG AA, section-order, …); audit-extensions adds project-side extension rules. Severities, fix strategies, and per-rule logic: references/cli-reference.md.

Ships a condensed spec, CLI + subcommand references, deterministic scripts, and two example DESIGN.md files. Never authors a design file — that is /award-design's job; design-system governs from there.

Sources

  • Google DESIGN.md — the canonical open standard this skill enforces; @google/design.md CLI for lint, diff, export, spec
  • W3C Design Token Format — token schema inspiration; export --format dtcg produces a compatible tokens.json

Claude Code Skills

Meta skills for configuring Claude Code itself — claude-md, agent-creator.

claude-md

Create and optimize CLAUDE.md memory files and .claude/rules/ modular rules for Claude Code projects.

Usage

/claude-md init        # Scaffold a new CLAUDE.md
/claude-md optimize    # Deep cleanup of existing CLAUDE.md
/claude-md revise      # Capture session learnings

What it does

  • init — detects stack, scripts, and architecture-critical files. Generates a minimal CLAUDE.md (20–50 lines)
  • optimize — research-backed cleanup using 6 bloat categories (ETH Zurich study). Target: < 100 lines
  • revise — reviews the current session for commands, patterns, and corrections. Drafts additions with diffs for approval

Key features

  • File hierarchy (enterprise > project > user > local)
  • Modular .claude/rules/ with path-scoped YAML frontmatter
  • Size limits guidance (< 100 ideal, < 150 max, > 200 = directives get lost)
  • Writing rules — directive phrasing, emphasis reserved for genuine constraints, show don't tell

Sources

agent-creator

Expert guidance for creating, configuring, and orchestrating Claude Code subagents.

Usage

/agent-creator

What it does

  • Walks through creating new agents with proper YAML frontmatter (name, description, tools, model)
  • Covers tool restrictions, model selection, permission mod