Impeccable: 98K-Star Skill That Stops AI Coding Agents Shipping Ugly UI

You know the look. The hero section with the purple-to-blue gradient. Every headline set in Inter. Cards nested inside cards like Russian dolls, gray text floating on colored backgrounds, and the same rounded-square icon tile parked above every heading. Ask an AI coding agent to build a page with no other guidance and this is what comes back, across models, across projects, across codebases. Designers have a word for it: slop.

Paul Bakaus, the developer who created jQuery UI and later led Chrome DevTools developer relations at Google, decided the problem was not taste but vocabulary. Engineers tell a model "make it pop" and leave too much room for interpretation; designers get better results because they speak in specific moves. So he packaged those moves as Impeccable: a free, open-source design skill that plugs into the coding agent you already use. It has collected more than 98,000 GitHub stars since November 2025, adding roughly 2,000 a day through late October. Here is what it does, what it costs, and the catches worth knowing before you install it.

What Impeccable actually is

Impeccable is three things in one package, and the distinction matters. First, it is a skill: a SKILL.md plus command references that hand your coding agent a design vocabulary, 24 named commands like polish, critique and audit that you invoke as /impeccable <command> <target>. Second, it is a deterministic slop detector: 62 hard-coded rules that flag the generic tells, with no large language model and no API key involved. Third, it is a live mode that opens your running dev server with an overlay, lets you click an element, and hot-swaps design variants in place until you accept one.

What it is not: a model, a component library, or a design tool with a canvas. It does not replace your agent; it steers the one you have. The author's own description is "the design vocabulary for your coding agent," and that framing is the whole bet: coding agents are good at code and bad at taste, and taste can be shipped as instructions.

The 24 commands

The commands are grouped by job, and the grouping tells you how the author thinks about design work:

The 24th, craft, is a deprecated alias for a plain build request. The usage pattern is always command plus target: /impeccable critique the pricing cards, /impeccable quieter the landing page, /impeccable polish settings. Narrow targets get better results; the README's own advice is that a single section reviewed closely beats a whole page at a glance. Commands you use constantly can be pinned, so /impeccable pin audit gives you /audit as its own shortcut.

The 62-rule slop detector

This is the part with no AI in it at all. Sixty-two deterministic rules flag the tells the README names outright: Inter for everything, purple-to-blue gradients, cards nested in cards, gray text on colored backgrounds, a rounded-square icon tile above every heading, plus quality problems like cramped padding and skipped headings. Because the rules are hard-coded, the detector needs no model call and no API key, which means it can run after every single edit without costing you tokens.

There are three ways to run it. In your agent, a design hook scans every UI file the agent edits and hands the findings back before the agent calls the work done; the hook is available on Claude Code, Cursor, Codex, GitHub Copilot, Grok Build and Hermes Agent, and the installer sets it up. In your terminal or CI, the CLI needs no agent at all: npx impeccable detect src/ scans a directory, --github emits GitHub Actions annotations, and exit code 2 means findings, so it slots into a pipeline as a quality gate. In your browser, a Chrome extension overlays the same findings on any live page, yours or anyone else's.

How to install it

From your project root, run npx impeccable install, reload your coding tool, then run /impeccable init in your agent ($impeccable init on Codex). The installer detects your tools, asks whether to install for the project or globally, and offers the design hook where your tool supports one. Refresh an existing install with npx impeccable update, and run /impeccable doctor if something looks broken; it finds stale context files, unused settings and broken hooks.

The supported list is long: Claude Code, Cursor, Codex CLI, GitHub Copilot, Devin, Replit Agent, Gemini CLI, Grok Build, OpenCode, Google Antigravity, Kiro, Trae, Rovo Dev, Qoder, Mistral Vibe, Pi, Hermes Agent, DeepSeek Harness and Veto, nineteen in total. There are also native plugin routes: a Claude Code plugin via /plugin marketplace add pbakaus/impeccable, a VS Code extension for GitHub Copilot, and a Grok Build plugin. If you have no Node available, the manual route is a copy of the skill folder into your tool's skills directory; the README documents every path. Node, incidentally, is only needed for npx itself. The skill runs a self-contained engine binary that ships next to it or downloads once into ~/.impeccable/bin/.

Impeccable lives inside the agent you already use, so if you have not priced those agents yet, our Claude Code explainer covers what the agent itself costs, and our roundup of the 7 best AI coding agents in 2026 compares Cursor, Codex and Copilot on price and limits.

Who built it, and why that matters

Paul Bakaus created jQuery UI in 2007, co-founded the in-browser game engine Aves (later acquired by Zynga), then spent years at Google leading Chrome DevTools developer relations and product, before founding Renaissance Geek, the company behind Impeccable, with a seed round led by a16z. That history matters because Impeccable is built like developer tooling, not like a design manifesto: hooks, CLIs, exit codes, CI annotations, git hygiene for its working files.

His own summary of the idea, from a July 2026 podcast interview, is that Impeccable is "turning your coding harness into a design harness" and that "it gives your agent the vocabulary of design." His diagnosis of the slop problem is worth quoting: telling a model "this doesn't look good" leaves "too much room for interpretation," like "shooting in the dark." Designers do better because they name the move. The skill is that naming, packaged.

One claim to handle carefully: Bakaus's site says Renaissance Geek partnered with GitHub to bundle Impeccable with the new GitHub Copilot app. The exact shape of that bundling is not documented anywhere public, so treat it as the company's claim, not a confirmed integration. The README itself documents Copilot support through the VS Code marketplace extension.

What it costs

Nothing. Impeccable is released under the Apache 2.0 license with no paid tier, no subscription and no credit system. The repository, the skill, the detector and the live mode are all free, and the company behind it monetizes separately.

The real meter is your coding agent's tokens. Every /impeccable polish is a model call inside Claude Code, Cursor or Codex, billed on whatever plan you already have. Think of it this way: if you already pay for a coding agent, Impeccable adds design quality at zero marginal software cost. If you do not, the agent subscription is the price of admission, not the skill.

For context, the paid tools that generate UI from prompts bill very differently. v0 charges per token on its live rate card, from $0.20 per million input tokens on its smallest model to $10 per million on its fastest flagship, all in USD before tax. Lovable's live pricing page confirms its free tier is 5 build credits a day up to 30 a month; its paid plan prices are not readable on the live page right now, so we are not quoting them. Framer's pricing page renders no plan prices to automated reads and aggregator figures conflict with each other, so there is no Framer number in this article either. When a vendor's own page will not confirm a price, the honest move is to say so.

The catches

A tool with 98,000 stars still deserves a skeptical read. Here is what the README and the independent coverage actually say, good and bad.

Hooks run outside model approval. This is the README's own warning, in bold: in Claude Code, installed command hooks run even when you deny the model's own commands, so the first edit can download the engine binary. Review installed hooks before unattended runs, or pass the disable-all-hooks setting for a run. One independent write-up makes the same point from the other side: look at what the installer adds to your project before you commit it.

Telemetry is on by default. When a new design starts, the skill fetches visual directions from the impeccable.style catalog, and telemetry records which directions were shown and which one you picked, which is how the catalog learns. Your project name, files, code and PRODUCT.md are never sent, according to the README and the privacy page. If the record-keeping bothers you, npx impeccable telemetry off, DO_NOT_TRACK=1, or the telemetry: false config flag all disable it. Turning it off does not stop the catalog fetch itself.

Live mode has a safety caveat. It edits a local checkout only. The README says plainly: do not inject it into a deployed site or weaken a production content security policy to make it work.

It is strongest on interfaces that already exist. Point it at a page or a component and iterate; that is the designed workflow. Building new pages from scratch is the harder mode, and the docs have a separate guide for getting the most out of it. Set expectations accordingly.

Nobody has independently tested the quality claims. The striking before-and-after on the README, a Ligurian guesthouse site called Villa Castagneto, is the project's own demonstration: same model, same brief, with and without the skill. As one independent write-up put it, popularity is not proof of quality, and no independent evaluation of the design claims has surfaced yet. Treat the demo as a direction, not evidence.

Older coverage is already stale. Write-ups from September quote 23 commands and 44 rules; the live README describes 24 commands and 62 rules. Skill software moves fast; check the repo, not the blog post.

There is a licensed rebrand out-installing the original. The skills catalog skillselion reports a licensed rebrand of Impeccable's playbooks, published as "anti-ui-slop," with 370,344 installs against 238,573 for the original in its registry snapshot. That is a backhanded compliment to the playbooks' value, and a reason to install from the canonical repo rather than a renamed copy pinned to an older version.

How it compares

The honest summary: unslop is the closest alternative and the only one with a real workflow of its own, but it is Claude-only, has no deterministic rule engine, and its Creative Commons license requires crediting the author. Anthropic's frontend-design is the minimalist ancestor. And ECC, the 291,000-star toolkit we covered earlier, is the complementary layer: ECC brings workflow discipline to Claude Code, Impeccable brings design vocabulary.

Pro tips and common mistakes

• Audit before you ship, not after. The cheapest time to catch slop is before the deploy. Pin the command with /impeccable pin audit and make /audit part of the definition of done.
• Read what the installer adds before you commit it. The hook manifest lands in your project; know what is in it, especially before unattended runs.
• Put the detector in CI. npx impeccable detect --github src/ turns taste into a check that fails the build, with exit code 2 on findings.
• Use narrow targets. "Critique the pricing cards" beats "review the site." One section reviewed closely beats a whole page at a glance.
• Turn telemetry off if you want. The opt-outs are documented and simple; there is no reason to leave data flowing if you do not want it to.
• Do not expect miracles from a blank page. The tool is strongest iterating on something that exists. For greenfield pages, start with shape and the new-work docs, and keep expectations modest.
• If you try unslop instead, remember the license. CC BY 4.0 means crediting the author and linking the repo, even in commercial work.

Frequently asked questions

What is Impeccable for AI coding agents?

Impeccable is a free, open-source design skill that plugs into AI coding agents like Claude Code, Cursor and Codex. It adds 24 named design commands such as polish, critique and audit, plus a 62-rule detector that flags generic AI-looking design patterns. The goal is to give agents a design vocabulary so their output looks designed rather than generated.

Is Impeccable free to use?

Yes. Impeccable is released under the Apache 2.0 license with no paid tier, no subscription and no feature gates. The software costs nothing; the only cost is the tokens your coding agent burns running its commands, billed on whatever agent plan you already have. There is no hosted service to pay for.

How do I install Impeccable in Claude Code?

From your project root, run npx impeccable install, reload Claude Code, then run /impeccable init in the agent. The installer detects your tools and offers the design hook, which you should accept. You can also add it as a plugin with /plugin marketplace add pbakaus/impeccable. Refresh later with npx impeccable update.

Which coding agents does Impeccable support?

Nineteen, according to the README: Claude Code, Cursor, Codex CLI, GitHub Copilot, Devin, Replit Agent, Gemini CLI, Grok Build, OpenCode, Google Antigravity, Kiro, Trae, Rovo Dev, Qoder, Mistral Vibe, Pi, Hermes Agent, DeepSeek Harness and Veto. The deterministic detector also runs standalone in any terminal or CI pipeline with no agent at all.

What is AI design slop?

AI design slop is the generic look AI coding agents default to: 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's README lists these as the tells its 62-rule detector flags. The term captures design that looks generated rather than decided.

Does Impeccable send my code anywhere?

According to the README, your project name, files, code and PRODUCT.md are never sent. When a new design starts, the skill fetches visual directions from the impeccable.style catalog, and telemetry records which directions were shown and picked. You can disable that with npx impeccable telemetry off, DO_NOT_TRACK=1, or a config flag.

Verdict

Impeccable earns its stars by solving a real, visible problem with unusual honesty: the rules are deterministic, the telemetry is disclosed, and the README warns you about its own hooks. It will not turn a bad brief into a great design, but it will stop your agent shipping the generic look. If you build UI with an AI coding agent, /impeccable audit belongs in your workflow before the next deploy.

Install it from the canonical repository, read what the installer adds before you commit it, and keep an eye on the changelog: at roughly 2,000 new stars a day, this is a project still being written.

Sources: Impeccable on GitHub; impeccable.style; Impeccable docs; Impeccable privacy page; Paul Bakaus about page; It Shipped That Way, Ep. 36; Skillselion catalog entry; heydamir/unslop on GitHub; Anthropic frontend-design skill; v0 pricing; Lovable pricing; Digisoulhub; AI Vaded.