Impeccable 4.5: The AI Design Skill Now Has 24 Commands and 61 Detector Rules

Impeccable, Paul Bakaus's design skill for AI coding agents, has changed a lot since we covered its GitHub Copilot integration in June. The repository now shows 76.5K stars, 4.6K forks, 77 releases and a latest skill release numbered 4.5.0. The June post described 23 commands and 44 rules. The README today lists 24 commands and 61 deterministic detector rules, and the engine underneath was rewritten in Rust.

This guide is the updated how-to: what Impeccable is for, what is new, how to install it in your harness, how the detector, hooks and live mode work, and the security details the README itself asks you to read before running it unattended.

TL;DR: the questions people are asking

The problem it targets

The README opens with a blunt claim: every model was trained on the same SaaS templates, so without guidance you get the same handful of tells on every project. Inter for everything, purple-to-blue gradients, cards nested inside cards, gray text on colored backgrounds, and a rounded-square icon tile above every heading.

Impeccable's answer is a shared vocabulary between you and the agent. Instead of typing "make it look better," you run a command with a defined meaning. It started from Anthropic's frontend-design skill and adds structure on top. If you want a refresher on how skills work in general, see our complete guide to agent skills.

What the 24 commands do

Everything runs through one skill: /impeccable <command> <target>. The README groups them roughly like this.

A few worth knowing:

• init is a one-time setup. It inspects the project, asks only for material gaps, and writes PRODUCT.md with durable product facts: audience, purpose, constraints and voice.
• document generates a root DESIGN.md from existing code, which links Impeccable to the open spec we covered in DESIGN.md for AI agents.
• critique is a UX review of hierarchy, clarity and emotional resonance, while audit runs technical checks for accessibility, performance and responsiveness.
• pin <command> turns a frequent command into a standalone shortcut, so pin audit gives you /audit.

Typical use is plain language: /impeccable audit blog, /impeccable polish settings, or /impeccable redo this hero section.

Install it in five minutes

1. Run the installer from your project root: npx impeccable install.
2. Choose providers and scope. It detects harness folders such as ~/.claude, ~/.codex or project-local .cursor, then asks for project or global scope. Scripts can pass --providers=claude,codex,cursor --scope=project.
3. Run setup in your agent: /impeccable init.
4. Reload the harness. Codex users should open /hooks and approve the project hook; Grok Build needs folder trust.
5. Keep it updated with npx impeccable update.

Alternatives in the README: a Git submodule linked with npx impeccable link, the Claude Code plugin via /plugin marketplace add pbakaus/impeccable, a VS Code extension for GitHub Copilot (skill-only, no hooks), a Grok Build plugin, or copying a prebuilt folder from dist/ for any supported tool. Some tools need a setting enabled first, such as Cursor's Nightly channel and Agent Skills, or Gemini CLI's preview build with Skills turned on.

One housekeeping step matters for teams. Impeccable writes screenshots, session state and caches under .impeccable/. The README provides a .gitignore block, and says to keep shared artifacts tracked: config.json, design.json, surfaces/*.md and critique/*.md.

The detector: 61 rules with no LLM

The part many teams will adopt first is the standalone detector, which needs no model and no key:

npx impeccable detect src/
npx impeccable detect index.html
npx impeccable detect https://example.com
npx impeccable detect --json .

It catches AI-slop patterns such as side-tab borders, purple gradients, bounce easing and dark glows, plus general quality issues like line length, cramped padding, small touch targets and skipped headings. Exit code 0 means no primary findings, 2 means findings, and 1 means a target could not be scanned, which makes it usable in CI. URL scans use an installed Chrome, Chromium or Edge and inspect the rendered DOM and computed layout.

Two honest caveats come straight from the README: browser security prevents reading cross-origin CSS without CORS, and a clean run "is evidence, not proof" of visual or accessibility quality. It does not replace looking at the page across viewports. You can add ignores per project (impeccable ignores add-value overused-font Inter --reason "Brand font") or per file with an inline impeccable-disable comment.

Hooks: design checks on every edit

On Claude Code, GitHub Copilot, Codex, Cursor and Grok Build, install also drops a provider-native hook that runs the detector when the agent edits UI files. Behavior differs by tool:

The Stop pass suppresses confirmed pre-existing findings when a before-edit baseline exists, and otherwise labels findings as new or attribution unknown. If you already use Claude Code's hook system, our write-up of function hooks and ant apply shows where this fits.

Read this before enabling it. The README says that in Claude Code, installed command hooks run independently of model-tool approval, so the first edit or Stop event can download and cache the engine even if the session denied the model's launcher command. The launcher runs the engine binary next to it or downloads a pinned version once into ~/.impeccable/bin/. For unattended runs, review installed hooks, and pass --settings '{"disableAllHooks": true}' if you want them off.

Live mode and the Rust engine

Two other changes since June deserve attention.

The Rust engine. One binary now replaces the separate scripts and the JavaScript detector. The skill itself needs no runtime; Node is only used if you go through npx. That reduces moving parts, but it also means a binary is fetched and executed, which is why the pinned version and the hook note above matter.

Live mode. /impeccable live lets you iterate on an element in the browser against a local dev server or static HTML, and /impeccable generate creates variants of a named element without manual picking. Treat it as local-only. The README says injecting its helper into a deployed production site is not supported, and warns that applying copy edits can run an optional impeccable:manual-edit-validate script from package.json in a shell with your permissions. Review that script before using live mode in an unfamiliar checkout. For production sites, use detect on the URL or the browser extension instead.

Comp-first or code-first. For new surfaces, init records a buildPath setting. Comp-first generates a full-fidelity comp first and builds to match it, which composes bolder but takes longer. Code-first builds directly with the ambition written into a direction contract, which is faster and leaner. Comp-first only appears where image generation is available.

How it compares with other design skills

Impeccable is not the only anti-slop design tool. Our write-ups of Nutlope's Hallmark and Vercel's DESIGN.md cover neighboring approaches. The distinguishing features here are the deterministic detector that runs without a model, the number of supported harnesses, and the edit-time hooks. If you want a spec file instead of a skill, start with DESIGN.md templates. The two approaches combine well: let document produce the spec, then let the hook enforce it.

Who should use it, and how

• Solo builders shipping with an agent: install, run init, then audit and polish before every deploy.
• Teams: commit .impeccable/config.json, design.json and surface briefs, ignore the rest, and run detect --json in CI.
• Skeptics: start with the detector alone. It has no model dependency and gives you concrete findings to judge.
• Security-minded orgs: vendor it as a Git submodule, pin the engine version, and review the hook and live-mode behavior before enabling either.

A sensible first-week workflow

If you are adopting it on a real project, a low-risk sequence looks like this. On day one, run the detector alone against your current UI and read the findings without changing anything, so you learn which of the 61 rules fire most. On day two, install the skill, run init and review the PRODUCT.md it writes, correcting anything that misstates your audience or constraints, since every later command leans on it. Midweek, run critique and audit on one important page and compare their output with your own judgment. Only then decide whether the hook is worth enabling, and if so, enable it in one repository first.

Record what you disagree with. Detector rules encode taste, and some will clash with a deliberate brand choice, such as a required font. Use the ignore mechanism with a written reason rather than turning rules off silently, so the next teammate understands why.

Related reading

• Impeccable inside GitHub Copilot (June 2026)
• What are agent skills? Complete guide
• DESIGN.md open spec for AI design systems
• DESIGN.md templates for professional UI
• Vercel DESIGN.md: spec-driven UI
• Nutlope's Hallmark anti-slop design skill
• Claude Code function hooks and ant apply

Primary: the Impeccable GitHub repository and README · impeccable.style documentation

Figures (stars, rule and command counts, release number) are as of October 5, 2026 and change often. Verify install commands and hook behavior against the current README before enabling hooks in a shared environment.