Impeccable: A deterministic design skill for AI coding agents

The problem: every AI frontend looks the same

AI coding models trained on the same SaaS templates produce the same tells on every project: Inter for everything, purple-to-blue gradients, cards nested in cards, gray text on colored backgrounds, and a rounded-square icon tile above every heading. Impeccable is a design skill for AI coding agents that tries to break that pattern. It provides one skill, 23 commands, and 61 deterministic detector rules for AI-generated frontend design. The project started from Anthropic's frontend-design skill, but Impeccable adds a structured setup flow and a set of commands that give the model a shared vocabulary. It is for developers who use AI coding tools like Claude Code, Cursor, Codex, or Grok Build and want more control over the visual output without hand-holding every step.

How it works: deterministic rules plus LLM checks

The core mechanism is a split between deterministic detector rules and LLM-only critique checks. The deterministic rules run with no LLM and no API key, either through the CLI or the browser extension. This means the basic checks for things like gray text on colored backgrounds or nested cards are scriptable and reproducible. The LLM-only critique checks, such as hierarchy, clarity, and emotional resonance, require a model. The README lists 61 deterministic detector rules, though it does not enumerate them. The browser extension and CLI run these rules, so you can audit a page without sending content to a model. That split is a design choice: the deterministic rules give you a fast, repeatable quality gate, while the critique commands rely on the model's judgment for subjective design qualities.

Installation and setup: one command to start

The recommended install is `npx impeccable install` from the project root. This command detects harness folders like `~/.claude`, `~/.codex`, `~/.grok`, or project-local `.cursor`, and lets you keep or customize the set of providers. You can skip the interactive prompts with `--providers=claude,codex,cursor,grok` and `--scope=project|global`. On Claude Code, Cursor, Codex, GitHub Copilot, and Grok Build, it also installs a provider-native hook manifest for the current project. After install, you run `/impeccable init` inside your AI coding tool. That command asks whether the surface is brand (marketing, landing, portfolio) or product (app UI, dashboard, tool), then writes `PRODUCT.md` and optionally `DESIGN.md`. Later commands read this context. To refresh an existing install, run `npx impeccable update`.

The 23 commands and how to use them

All commands go through `/impeccable <command> <target>`. For example, `/impeccable audit blog` runs technical quality checks on the blog hub and post pages, `/impeccable critique landing` does a UX design review, and `/impeccable polish settings` does a final pass before shipping. The commands cover distinct stages: `craft` is a full shape-then-build flow, `shape` plans UX/UI before writing code, `extract` pulls reusable components and tokens into the design system, and `live` is a visual variant mode that lets you iterate on elements in the browser. There are also commands for specific fixes: `typeset` for fonts, `layout` for spacing, `harden` for error handling and edge cases, and `colorize` for strategic color. You can create standalone shortcuts with `/impeccable pin <command>`, so `pin audit` creates `/audit`.

Anti-patterns and the design context files

The skill includes explicit anti-patterns to avoid: overused fonts like Arial, Inter, and system defaults; gray text on colored backgrounds; pure black or gray (always tint); wrapping everything in cards or nesting cards inside cards; and bounce or elastic easing. These are the tells that make AI output look generic. The `init` command gathers design context that later commands read: audience, brand/product lane, voice, anti-references, colors, type, and components. That context is written into `PRODUCT.md` and `DESIGN.md`. This is a key difference from a simple prompt: the model has persistent project-specific guidance, not just a one-off instruction. The README does not specify the exact format of these files, but the point is that they persist across sessions and commands.

Limitations and the wrong tool cases

The main limitation is that the deterministic rules do not cover subjective design quality. The README says the CLI and extension run the deterministic rules with no LLM, but the critique checks are LLM-only. So if you want a purely offline, deterministic design review, you get the technical checks but not the judgment on hierarchy or emotional resonance. Another limitation is the trust model for hooks. Codex tracks trust by hook definition, so updates that change `.codex/hooks.json` can require approval again. Grok Build needs project folder trust (`/hooks-trust` or launch with `--trust`) before `.grok/hooks/` scripts run. This means installation is not always one-and-done; you may need to re-approve hooks after updates. If you are not using a supported harness, the install flow may not work as described. The README lists many providers, but it does not guarantee that all commands work identically across all of them.

Alternatives and the difference in approach

The most direct alternative is Anthropic's frontend-design skill, which Impeccable started from. That skill is a single design guidance file for Claude, with no command structure and no deterministic detector rules. Impeccable adds a setup flow that writes `PRODUCT.md` and `DESIGN.md`, a set of 23 commands, and the deterministic rules that run without an LLM. Another alternative is to write your own design system prompt or use a custom instructions file in your AI tool. That gives you full control but requires you to maintain the guidance yourself and does not include the detector rules or the command vocabulary. Impeccable's difference is that it packages all of this into an installable skill with a consistent interface and a local, deterministic check layer.

Maintenance, licensing, and what to verify

The project is licensed under Apache-2.0, which allows commercial use and modification, but it is not legal advice. The repository is not archived, and the latest pushes are from August 2026, with releases for the skill (v4.1.2), extension (v1.3.3), and CLI (v3.6.1). The README describes an update path: `npx impeccable update` for the CLI installer, and `git submodule update --remote .impeccable` plus `npx impeccable link` for the submodule method. That suggests a maintenance cost: you need to keep the skill updated to get new commands and detector rules, and each update may require re-approving hooks in Codex and Grok Build. Before adopting, verify that your harness is listed and that you can handle the trust prompts. Also check whether the `live` browser iteration mode works with your specific setup, as the README does not detail its requirements.

Editorial conclusion

Adopt Impeccable if you use an AI coding agent and want to break the generic SaaS look without adding an API key or LLM cost. The deterministic rules run locally, so it works for teams that need reproducible checks. Do not adopt it if you expect fully automated visual judgment: the 61 rules cover technical and layout issues, but critique checks still require an LLM. Before adopting, verify that your harness supports the hook installation (Claude Code, Cursor, Codex, Grok Build, Gemini CLI are listed) and that you can approve the trust prompts, especially for Codex and Grok Build.

Official sources

1. Official documentation
2. Official README
3. Project repository
4. Release notes