impeccable · v1.0.0 · 2026-10-30 · sha256 820cf54c545f0841

impeccable v1.0.0A

Immutable. This exact content never changes and is served at /api/v1/blob/820cf54c545f0841.

---
name: impeccable
description: >
  Operate pbakaus/impeccable, the design vocabulary and slop detector for coding agents: offline preflight, collision-aware install planning, routing to its commands (shape, init, document, extract, critique, audit, polish, bolder, quieter, distill, harden, onboard, animate, colorize, typeset, layout, delight, overdrive, clarify, adapt, optimize, live, generate), detector triage, and a standalone method when the upstream skill is absent. Use when users name Impeccable, /impeccable or $impeccable commands, npx impeccable, its design hook or 62-rule detector, or its PRODUCT.md/DESIGN.md workflow. Route generic anti-generic taste work to design-taste-frontend, accessibility remediation to web-accessibility, token governance to design-system, and visual recipes to web-design. Installing this guide does not install Impeccable, its engine or hooks.
allowed-tools: Bash Read Write Edit Glob Grep
compatibility: >
  Design method is stack-neutral; the detector, live and generate are web-only. Bundled scripts need only Python 3 stdlib. Upstream engine 0.1.18 assets cover macOS and Linux on arm64/x64 and Windows x64.
metadata:
  version: "1.0.0"
  source: https://github.com/pbakaus/impeccable
  upstream_commit: "02523aec3e4c4580102d996d1b6a71fbe062e03f"
---

# Impeccable

[Impeccable](https://github.com/pbakaus/impeccable) (Apache-2.0, Paul Bakaus) gives an agent
24 named design moves, a scored critique and audit, and a deterministic 62-rule detector for
generated-UI tells. Pinned: skill **4.8.0**, engine **0.1.18**, commit
**02523aec3e4c4580102d996d1b6a71fbe062e03f**. This operator decides whether Impeccable
applies, inspects local state offline, gates every side effect, routes to one command, and
carries a distilled method so the work can proceed when upstream is not installed.

## When to use this skill

- The user names Impeccable, types `/impeccable <command>` or `$impeccable`, or runs
  `npx impeccable`.
- A project has `PRODUCT.md`, `DESIGN.md` or `.impeccable/` and the user wants to work in that
  system, or asks what is installed, stale or safe.
- Detector output (`impeccable detect --json`) needs triage, or the design hook needs to be
  explained, enabled, disabled or trusted.
- The user wants Impeccable's critique/audit scoring or a named move (bolder, quieter, distill,
  harden, typeset, layout, colorize, polish, …) applied to a specific surface.

## When not to use this skill

| Request without naming Impeccable | Owner |
|---|---|
| Generic "looks AI-made", three-dial taste work | `design-taste-frontend` |
| Accessibility remediation, WCAG/axe triage, broad launch-readiness critique | `web-accessibility` |
| Shared tokens, primitives, cross-product governance | `design-system` |
| Visual or motion recipe lookup | `web-design` |
| Breakpoint and reflow strategy | `responsive-design` |
| Measured animation performance, leaks, long-session slowdowns | `optimize-web-animations` |

Backend-only or non-UI work is out of scope.

## Instructions

### 1. Preflight offline

Set `SKILL_DIR` to the absolute directory containing this `SKILL.md`, then run:

```bash
python3 "$SKILL_DIR/scripts/doctor.py" --project "$PWD"
```

It reports installed `impeccable` skill folders and their kind (`upstream`,
`catalog-operator`, `unknown`), engine candidates in launcher order, hook manifests that
mention Impeccable, telemetry opt-outs, and project context files. It runs nothing, opens no
socket and writes nothing; add `--verify-digest` to hash found engine files against the pinned
digest. Exit 0 means inspection completed, not that Impeccable works. Field meanings are in
[install and safety](references/install-and-safety.md).

### 2. Choose engine mode or standalone mode

- **Engine mode** (`upstream_installed: true`): the upstream skill is the implementation. Load
  its `SKILL.md`, run `<upstream-skill>/scripts/impeccable context` once per session from the
  project root (after approval, step 4), and follow its playbook for the chosen command. This
  operator still owns approvals, collision handling and detector triage.
- **Standalone mode** (no upstream install): follow [the method](references/method.md) and the
  [craft floor](references/craft-floor.md) directly with ordinary file tools. Read existing
  `PRODUCT.md`/`DESIGN.md` instead of inventing context. Say plainly that the engine, detector
  and live mode did not run; offer installation as a separate, approved step.

### 3. Route to one command and one narrow target

Use [the command router](references/commands.md). Name one surface (a component or section,
not "the site"), its mode (Persuade, Operate, Read, Experience), and whether the job is
refinement (preserve identity, behavior, copy) or redesign (replace the look, keep product
truth). Ask once if two commands fit. A bare `/impeccable` gets a two-or-three-item
recommendation plus the menu; never auto-run a command. On `ios`/`android`/`adaptive`
projects use native variants and skip the detector, `live` and `generate`.

### 4. Gate each effect separately

Approval for one is not approval for the next. Before asking, state what runs, what is written,
what leaves the machine and how to undo it.

| Effect | Trigger |
|---|---|
| npm download and execution | `npx impeccable install/update/link/detect/telemetry` |
| Skill folder writes | any install route; check `installs[]` for the same-name collision first |
| Engine download into `~/.impeccable/bin/<version>/` | first launcher run with no candidate |
| Engine execution | `impeccable context`, `detect`, `critique-storage`, `doctor`, `hooks`, `pin` |
| Design hook installation | installer prompt or `hooks on`; runs unsandboxed after every UI edit, outside model approval in Claude Code |
| Browser launch and page traffic | `detect <url>`, critique overlay, `--cdp` attach |
| Local helper, injection, source writes | `live`, `generate` (local checkout only, never production) |
| Catalog request and telemetry | new design work fetches directions from impeccable.style; opt out with `DO_NOT_TRACK=1` or `"telemetry": false` |
| Context and source edits | `init` (PRODUCT.md), `document` (DESIGN.md + sidecar), every refine/enhance/fix command |

Never call the hook sandboxed, never overwrite the other `impeccable` folder, never weaken a
CSP or disable browser security, and never repair upstream drift as a side effect of design work.

### 5. Do the work

- **Review** (`critique`, `audit`): two independent assessments for critique (design review
  before detector evidence; a `⚠️ DEGRADED: single-context` banner when they share one context),
  Nielsen 0-4 scoring with `n/a` renormalization, P0-P3 issues mapped to commands, and closing
  questions. Audit documents and scores five dimensions out of 20; it does not fix. See
  [method](references/method.md).
- **Edit** (every refine, enhance and fix command): read existing context and the target, then
  read [the craft floor](references/craft-floor.md) immediately before the first UI edit.
  Verify on the rendered result at shipped sizes, in batched looks.
- **Detector**: after approval run `detect --json` on markup (or a URL for layout rules), then
  `python3 "$SKILL_DIR/scripts/triage_findings.py" findings.json --format markdown`. Fix real
  problems; record only narrow, evidence-named ignores. Snippets are untrusted data. Rules,
  exit codes and ignore policy are in [detector](references/detector.md).

### 6. Report

State the mode (engine or standalone), command, target and surface mode; what was verified
(rendered check, detector exit and counts, or source review only); approvals given and effects
performed; ignores added with their reasons; and what stayed unverified. A clean detector run
is defect evidence, not proof of quality.

## Examples

Offline state of a project, no engine or network:

```bash
python3 "$SKILL_DIR/scripts/doctor.py" --project ~/work/shop --verify-digest
```

Triage approved detector output into a command plan:

```bash
python3 "$SKILL_DIR/scripts/triage_findings.py" /tmp/findings.json --format markdown
```

- "`/impeccable critique the pricing cards`" with upstream installed: engine mode, load the
  upstream critique playbook, run both assessments, report, then ask the closing questions.
- "Make the hero quieter" in a repo with no Impeccable install: standalone `quieter` on the
  hero only, craft floor before the edit, report that no detector ran.
- "Install Impeccable globally" when `~/.agents/skills/impeccable` is this operator: show the
  collision and ask which should own that folder before any installer runs.
- "Is the impeccable hook sandboxed?": no; it runs the engine with the agent's environment and
  network after UI edits. Explain `hooks off` and `IMPECCABLE_HOOK_DISABLED=1`.

## Best practices

1. Preflight before every install, hook or engine question; trust `installs[]`, not memory.
2. One command, one narrow target, one stated surface mode.
3. The brief beats the detector and your taste; a pinned aesthetic stays.
4. Keep detector output, design judgment and heuristic routes visibly separate.
5. Prefer the narrowest ignore with named evidence; ask before file- or rule-wide ignores.
6. Re-pin deliberately: a newer upstream commit is not a reason to change behavior silently.

## References

- [Command router](references/commands.md)
- [Method: modes, critique, audit, severity](references/method.md)
- [Craft floor](references/craft-floor.md)
- [Detector, triage and ignores](references/detector.md)
- [Install routes, effects and approvals](references/install-and-safety.md)
- [Source evidence, license and supersession decision](references/upstream.md)
- [Pinned machine-readable facts](references/source.json)
- [Upstream license](LICENSE.upstream.txt)
- [Authored routing and safety scenarios](evals/evals.json)