Impeccable: 62 Rules Against AI-Generated Design Slop

By Indie Kings | October 29, 2026

Updated October 29, 2026: pbakaus/impeccable packages design guidance for AI coding agents as one skill, 24 commands and a Rust detector with 62 deterministic rules, and it passed 92,390 stars with 57 contributors. The project is Apache-2.0, was created on November 16, 2025, and installs with a single npx command that detects the agent harnesses already on your machine.

Image: a letterpress type case, via Wikimedia Commons.

The tells it is trying to kill

The pitch starts with an observation that anyone who has reviewed AI generated interfaces will recognize. Models trained on the same templates produce the same handful of habits: Inter for every typeface, purple to blue gradients, cards nested inside cards, gray text on colored backgrounds, and a rounded square icon tile above every heading. Those are not random failures. They are the statistical center of the training data, and a model asked for a landing page without guidance will drift toward them because that is what a landing page looks like in its corpus.

Impeccable's response is to name the tells and provide vocabulary to correct them. The README says it started from Anthropic's frontend-design skill, which was the first widely used design skill for Claude, and then extended the idea in three directions. One setup flow records durable product truth in a file called PRODUCT.md, so later commands know the audience, purpose, constraints and voice without confusing those facts with surface level visual direction. Visual systems for each surface are recorded separately in DESIGN.md, which keeps the brand and the page from fighting each other.

The 24 commands are a shared language for the collaboration. There is polish, audit, critique, distill, animate, bolder and quieter, among others, and each is invoked through a single slash command with an optional focus argument. The value of a fixed vocabulary is that it gives the model a target. Asking for polish is ambiguous; asking for the polish command, which has its own procedure and checks, is a much narrower request. The project's own case study, Neo Mirai, is presented as a before and after to demonstrate that the commands change output rather than just decorating it.

A detector that needs no model

The 62 deterministic rules are the most interesting technical decision. Most design guidance for AI is itself a prompt, which means it is advice the model may or may not follow, evaluated by the same model that wrote the code. Impeccable ships a self contained binary engine, written in Rust, that runs the rules without an LLM and without an API key. The CLI and the browser extension use it directly, so the check is reproducible and cheap.

The rule set splits into two families. The AI slop rules catch the tells listed above: side tab borders, purple gradients, bounce easing, dark glows. The general design quality rules catch problems that have nothing to do with AI: lines that are too long, cramped padding, touch targets that are too small, heading levels that skip a step. That second family is what makes the tool credible. A linter that only complains about purple gradients is a novelty; one that also flags a 200 character line length is doing typography.

The CLI is usable on its own. Running the detect command against a URL uses an installed Chrome, Chromium or Edge and inspects the rendered DOM, computed layout and linked stylesheets, which means it sees what a browser sees rather than parsing source. Output can be human readable on stderr, JSON on stdout for tooling, or GitHub Actions annotations, and the exit codes are meaningful: zero for a clean scan, two for primary findings, one for a target that could not be scanned. A list rules flag prints the catalogue without scanning, which is a small touch that makes the rule set auditable.

The engine is also honest about its limits. The README states plainly that a clean detector run is evidence, not proof of visual or accessibility quality, and that it does not replace inspecting the rendered experience across viewports. That sentence is more valuable than most marketing copy in this space, because the failure mode of automated design review is false confidence. A rule set can catch a 12 pixel tap target; it cannot tell you whether the page feels like the brand.

Hooks, harnesses and the real workflow

Installation is designed around the fact that developers use several agents. One command detects harness folders such as the Claude, Codex, Grok and Hermes directories, or a project local Cursor folder, and lets you keep the detected set or choose providers explicitly. It can install into the current project or globally, and on Claude Code, Cursor, Codex, GitHub Copilot and Grok Build it also writes the provider native hook manifest. The hook is what makes the tool more than a skill: it runs the detector on direct UI file edits and surfaces findings back into the agent's flow, so a bad pattern gets caught in the same turn that produced it.

That design has a security cost worth naming. The README notes that in Claude Code, installed command hooks run independently of model tool approval, and that the first edit or Stop event can download and cache the engine even if the session denies the launcher command. It recommends reviewing installed hooks before unattended runs and documents a flag to disable all hooks for a session. This is the correct disclosure, and it is also a reminder that hook manifests are executable configuration, not preferences. Anyone installing an agent tool that writes hooks should read what it writes.

The distribution surface is unusually wide for a design tool. There is an npm installer, a manual install, a git clone path, a VS Code extension that requires version 1.109.3 or later and Copilot Chat, plugin installs for Claude Code and Grok, and support for Gemini CLI, Replit Agent, Hermes and Veto. The README even documents the provider specific quirks, such as Codex requiring a manual hook approval and Grok needing project folder trust. That level of detail suggests the maintainers are tracking real installation failures rather than publishing an idealized path.

Project card

FAQ

What is Impeccable?
A skill for AI coding agents that supplies design vocabulary, product context and a deterministic linter for common interface problems.

Do I need an API key?
No for the detector, which runs as a local binary. The commands that rewrite code still run inside your chosen agent and model.

What are the 62 rules?
A mix of AI specific tells such as purple gradients and bounce easing, and general quality checks such as line length, padding, touch target size and heading order.

Which tools are supported?
Claude Code, Cursor, Codex, GitHub Copilot, Grok Build, Gemini CLI, Replit Agent, Hermes and Veto, with project or global installs.

Is a clean scan a guarantee of good design?
No. The README says a clean run is evidence rather than proof and does not replace looking at the rendered page on real viewports.

Why does it install hooks?
So the detector can run on UI file edits and report findings inside the agent session. Review the hook manifest before unattended use.

Bottom Line

Impeccable works because it separates taste from measurement. The skill and the commands handle the part that needs judgment, and the Rust detector handles the part that does not, which means the feedback loop does not depend on the same model that made the mistake. Sixty two rules is a serious corpus, and the split between AI tells and general quality is what keeps it from being a novelty linter. The hook mechanism and the wide harness support show a team optimizing for how people actually work, and the README's honesty about the detector's limits is the sign of a tool worth trusting. If your generated pages all look the same, start here.

Sources

• GitHub pbakaus/impeccable README, command list, detector rules, installation and hook documentation, accessed October 29, 2026
• GitHub API metadata for pbakaus/impeccable, stars, forks, contributors, issues and latest commit, accessed October 29, 2026
• impeccable.style documentation and detector pages as linked from the repository, accessed October 29, 2026

Related: Every App: A Prompt That Replaces Your SaaS With Open Source | LumaFin-AndroidTV: The Open-Source Custom Jellyfin Client Reinventing the Living Room Streaming Experience