Capability

Impeccable — the frontend design plugin

A design language that makes any AI coding agent better at frontend — 23 commands, a design hook, and a slop detector.

#design#plugin#frontend

Impeccable is a design language for AI coding agents — “the design language that makes your AI harness better at design.” Built by Paul Bakaus on top of Anthropic's frontend-design skill, it exists to break the homogeneous output models fall into when they've all trained on the same SaaS templates: Inter everywhere, purple-to-blue gradients, nested cards, tracked-uppercase eyebrows. It installs as a single skill plus a background hook that nudges any agent — Claude Code included — toward interfaces that don't look like “AI made that.”

This guide runs on it

This very Dev Guide has Impeccable installed — its detector hook scans every UI file edit in the repo. The config and the hook output you've seen in this project come straight from it.

How it works — three layers

One install gives you three cooperating surfaces: a skill you drive with commands, a hook that watches edits, and a detector you can run on its own.

The skill

A single /impeccable command with 23 sub-commands. It carries the design rules, the workflow, and the register-aware judgment (brand vs. product).

The design hook

A provider-native hook that runs the detector on direct UI edits and surfaces findings inside the agent flow. Cursor blocks bad writes before they land; Claude Code and Copilot surface them just after.

The detector CLI

npx impeccable detect scans files, folders, or URLs with no AI harness at all — deterministic rules, JSON output, CI-friendly.

Install

  1. 1

    Run the installer

    From your project root, run the installer. It detects which agent folders you have (.claude, .cursor, .codex, …), lets you pick providers and scope, and installs the skill plus the hook manifest.
    bash
    npx impeccable install
    # update an existing install later:
    npx impeccable update
  2. 2

    Reload the agent

    Reload so the new skill and hook register. In Claude Code the /impeccable command appears.
  3. 3

    Set up the project once

    Run /impeccable init so every other command has context to work from (see the workflow below).

Other ways in

Prefer not to use the installer? Add it as a git submodule (git submodule add …/impeccable .impeccable), copy the per-tool dist/ folders by hand, or download a ZIP from impeccable.style.

Works across a wide range of agents:

Claude CodeCursorGitHub CopilotGemini CLICodex CLIOpenCodeKiroTraeRovo DevQoderPi

The workflow

Everything starts at init, which writes the context files the rest of the commands read before they act.

initPRODUCT.md · DESIGN.md
shape / craftplan, then build
critique / auditscore & find issues
polishship-ready
Set up context once, then build, evaluate, and refine — every command reads PRODUCT.md / DESIGN.md first.

PRODUCT.md — the strategy

Who it's for, the product lane (brand vs. product surface), the voice, and anti-references. Written by init after a short discovery interview.

DESIGN.md — the visual system

Colors, typography, spacing, radii, and component patterns. Offered by init when code exists, or generated later with document. When present, the detector also checks fonts/colors/radii against it.

You invoke any command as /impeccable <command> [target], and the target narrows the scope — /impeccable audit the header. Pin a command you use often to get a top-level shortcut:

bash
/impeccable pin audit     # now /audit runs /impeccable audit
/impeccable unpin audit   # remove it

The 23 commands

Grouped by intent. Most take an optional [target] to focus on one feature, page, or component.

CommandWhat it does
craft [feature]Shape, then build a feature end-to-end — discovery, visual probes and a north-star mock, then build and visually iterate.
shape [feature]Plan UX and UI before any code: a required multi-round discovery interview that produces a user-confirmed design brief.
initOne-time project setup. Discovery interview → writes PRODUCT.md (strategy), offers DESIGN.md (visual), preconfigures live mode, recommends next steps.
documentGenerate DESIGN.md from existing code — auto-extracts colors, type, spacing, radii and component patterns (Google Stitch format).
extract [target]Pull repeated patterns, components and tokens into the design system; consolidate drift back to one consistent system.

Plus three management commands: pin / unpin <command> for shortcuts, and hooks <on|off|status|…> to manage the design detector hook.

What it enforces — the rules

The skill carries a compact rulebook the agent must satisfy. The essentials:

Color

Body contrast ≥ 4.5:1 (large text ≥ 3:1), placeholders included — light gray “for elegance” is the #1 reason AI designs feel unreadable. No gray text on a colored background. Tint every neutral; work in OKLCH; pick a color strategy (restrained → committed → full palette → drenched) before picking colors.

Typography

Line length 65–75ch. Don't pair two similar sans-serifs — pair on a contrast axis or use one family in weights. Display headings ≤ 6rem, letter-spacing ≥ -0.04em. text-wrap: balance on headings, pretty on prose.

Layout

Vary spacing for rhythm. Cards are the lazy answer — nested cards are always wrong. Flexbox for 1D, Grid for 2D; repeat(auto-fit, minmax(280px, 1fr)) for breakpoint-free grids. Build a semantic z-index scale, never 999/9999.

Motion

Intentional, designed-in, not bolted on. Ease-out with exponential curves — no bounce, no elastic. A prefers-reduced-motion alternative is mandatory. Reveals must enhance already-visible content, never gate it.

Interaction

Dropdowns rendered position: absolute inside an overflow container get clipped — use the native <dialog> / popover API, position: fixed, or a portal.

The AI-slop test

If someone could look at the interface and say “AI made that,” it failed. Run the category-reflex check at two altitudes: could you guess the theme from the category alone (first-order), or from the category plus its obvious anti-reference (second-order)? If yes, rework until neither is obvious.

The absolute bans

Match-and-refuse patterns. If the agent is about to write one of these, it rewrites the element with different structure instead.

The detector & hook

Underneath the skill is a detector: roughly 44 deterministic rules plus LLM-only critique checks, spanning AI-slop patterns (side-stripe borders, purple gradients, bounce easing), general quality (line length, cramped padding, small touch targets, skipped headings, overused fonts, contrast), and responsive/accessibility. When a DESIGN.md exists, it also checks fonts, colors and radii against it.

Run it standalone on files, folders, or a URL:

bash
npx impeccable detect src/                 # scan a directory
npx impeccable detect https://example.com  # scan a live URL
npx impeccable detect --fast --json src/   # regex-only, machine-readable (CI)

The hook wires that same detector into the agent: it runs automatically after UI edits and surfaces findings as you work. Configure it per project in .impeccable/config.json:

.impeccable/config.json
{
  "detector": {
    "ignoreRules": [],
    "ignoreFiles": [],
    "ignoreValues": [],
    "designSystem": { "enabled": true }
  },
  "hook": {
    "enabled": true,
    "quiet": false,
    "auditLog": ".impeccable/hook.ndjson"
  }
}

Suppress noise precisely — per rule, per file, or per value — from the CLI or with an inline comment, and keep machine-local settings (like hook consent) out of git in config.local.json:

bash
npx impeccable ignores add-file "src/legacy/**"
npx impeccable ignores add-value overused-font Inter --reason "Brand font"
# or inline, in any file:
# <!-- impeccable-disable overused-font: brand requirement -->

How this guide configures it

For reference, here is the actual Impeccable config committed to this project — one file is exempted from the detector, and hook consent is stored locally:

.impeccable/config.json
{
  "detector": {
    "ignoreRules": [],
    "ignoreFiles": ["components/shell/sidebar.tsx"],
    "ignoreValues": []
  }
}

Pair it with the workflow

Impeccable is strongest as a standing critic, not a one-off. Run /impeccable init once, leave the hook on, and reach for critique / audit before shipping a surface and polish to close the gaps it finds.