mrkeyoor.com_
Wed 16 Sept 00:01 UTC
AI Toolsevaluationupdated 27 Aug 2026

impeccable review

Impeccable is a design skill and detector for AI coding agents such as Claude Code, Codex, Cursor, Gemini CLI, and Copilot. It gives an agent named design commands, project context files, browser iteration, and deterministic checks so generated interfaces follow a deliberate visual system instead of repeating common AI defaults.

+1,466stars / 7d
Verdict

Our Impeccable run installed 244 packages and built in 15 seconds, but the overall test script exited 1 with a final summary of 32 failures, so adopt the workflow only after reproducing its checks in your project. It is useful for teams whose coding agents already edit UI and need shared design language plus mechanical feedback. Keep human review in charge, approve hooks deliberately, and treat detector output as a prompt to inspect code rather than a design verdict.

We ran it

Lab card: what happened when we ran impeccableScreenshot of impeccable (impeccable.style)
Install✓ · 53s244 packages · 760 MB
Build✓ · 15s
Tests✗ · 81s712 passed · 0 failed of 712 (node:test)
Repo3265 files~1,281,695 lines of source · 62.6 MB · 3 CI workflows · tests dir

Answers from our run

Does impeccable build from source?

Dependencies installed in 53 seconds (244 packages), and the build succeeded in 15 seconds. We cloned commit 56f4452 into a clean Debian container with 3 CPUs and no project-specific setup.

Do impeccable's tests pass?

Yes: 712 of 712 passed when we ran the project's own test command (node:test). Some failures need services or credentials a bare container does not have.

Who should not use impeccable?

Teams without an AI coding harness: most of the value is delivered through an installed skill, agent commands, and edit hooks.

What are the alternatives to impeccable?

Anthropic Skills, UI Skills, Vercel Agent Skills. Our Impeccable run installed 244 packages and built in 15 seconds, but the overall test script exited 1 with a final summary of 32 failures, so adopt the workflow only after reproducing its checks in your project.

Setup3/5Installer is guided, but 760 MB and trusted hooks are meaningful costs
Docs5/5Commands, providers, hooks, state files, and detector use are explicit
Community5/562,993 stars with active issues and releases in August 2026
Maturity3/5Broad feature set, but our final test summary contained 32 failures

Who it’s for

Frontend teams already using Claude Code, Codex, Cursor, Copilot, or another supported coding agent.
Designers and engineers who want PRODUCT.md and DESIGN.md to carry decisions between agent sessions.
Projects that can review hook findings and generated edits instead of accepting AI changes automatically.
Teams wanting a scriptable detector for recurring typography, color, spacing, accessibility, and AI-design patterns.

Who it’s NOT for

Teams without an AI coding harness: most of the value is delivered through an installed skill, agent commands, and edit hooks.
Developers expecting a clean test result at the measured commit: the final script summary reported 32 failures out of 141 tests and exited 1.
Projects that cannot approve or trust local hooks: Codex requires explicit hook approval, while Grok Build requires project trust.
Users who need every detector finding to be authoritative: issue 656 documents a valid CSS radius fallback being flagged as off-scale, and issue 662 describes ignore entries that can be stored yet never match.

Setup reality

Our sandbox installed 244 packages in 53 seconds and used 760 MB. The build passed in 15 seconds. The test step exited 1 after 81 seconds. The harness aggregate recorded 712 passed and 0 failed, but the final script tail reported 141 tests, 109 passes, and 32 failures.

The deterministic CLI needs no LLM key, while the design skill needs a supported coding agent. Browser URL scans use Puppeteer. Provider-native hooks write into project configuration, and Codex or Grok users must explicitly trust them. Image-assisted comp work also depends on image-generation access.

Installation can be project-wide or global through npx, a submodule, a provider plugin, a ZIP, or manual copies. The tool writes runtime state and screenshots under .impeccable, so teams should adopt the documented ignore rules and decide which design artifacts remain tracked.

One skill gives coding agents 23 named design operations

Impeccable turns vague requests such as "make this better" into a shared set of actions. Its 23 commands cover initial direction, interface shaping, critique, technical audit, refinement, typography, layout, motion, responsive work, onboarding, error states, and browser-based variants. /impeccable init records product and design context so later sessions can read the audience, visual lane, voice, colors, type, components, and examples the team wants to avoid.

That persistence is more useful than another prompt pasted into chat. PRODUCT.md and DESIGN.md give the agent project-specific constraints, while command names make requests easier to review in a pull request or task. The repository is substantial: 3,265 files, about 1,281,695 source lines, and a 62.6 MB checkout before installation. This is an evolving toolchain with provider builds, hooks, a browser extension, live mode, and test machinery, not one Markdown instruction.

The 59-rule detector catches patterns without an LLM

The standalone CLI scans files, directories, or a URL and can return JSON for CI. Its 59 deterministic rules cover recurring AI design habits and ordinary interface defects, including font choices, contrast patterns, excessive cards, bounce easing, line length, padding, touch targets, and heading order. Configuration can ignore rules, paths, or values, and inline comments can waive one finding close to the code. No model or API key is needed for this detector path.

A deterministic result is still a heuristic. Issue 656 shows a CSS custom-property fallback such as var(--radius-md, 8px) being parsed as 128px and reported outside the declared radius scale. Issue 662 says the CLI can accept ignore values for rules that will never consult those values. Both reports are specific and recent. They argue for checking the snippet and rule logic before turning every finding into an automatic edit or CI failure.

What happened when we ran it

Our sandbox installed 244 packages in 53 seconds, leaving 760 MB on disk. The build completed successfully in 15 seconds at commit 56f4452. We ran the project in an unprivileged Node 22 Debian container with 3 CPUs and 8 GB of RAM. The checkout had no Dockerfile, contained a tests directory, and exposed 3 CI workflow files.

The test script exited with code 1 after 81 seconds. Our harness aggregate recorded 712 Node tests passed and 0 failed out of 712, while the final log tail gave a different script summary: 141 tests, 35 suites, 109 passes, and 32 failures. The process then printed script "test" exited with code 1. We cannot reconcile those 2 summaries from the supplied excerpt, so the decision-relevant result is a failed overall step.

Hooks put findings inside the edit loop

The installer can add provider-native hooks for Claude Code, Copilot, Codex, Cursor, and Grok Build. Depending on the harness, findings appear before a write, after an edit, or when the agent stops. That timing is valuable because the warning arrives while the changed file and intent remain in context. The installer preserves unrelated hook entries and refuses malformed manifests unless the user chooses a forced replacement with backup.

Trust is part of installation. Codex users must open /hooks and approve the project hook after install or an update that changes its definition. Grok Build also requires folder trust. Hook code runs in the developer's project context and reads edited UI files, so teams should inspect the manifest, pin updates, and keep audit logging off unless they have a reason to retain invocation details. A design helper does not deserve invisible execution.

Runtime state needs a deliberate Git policy

Impeccable writes screenshots, session files, preview state, manual-edit evidence, caches, and developer overrides under .impeccable. The README supplies a detailed ignore block, while shared files such as config, design state, and critique reports may remain tracked. A monorepo needs unanchored ignore patterns because the active workspace can sit below the repository root. Existing tracked screenshots also require a separate untrack operation; adding .gitignore does not remove them.

Issue 660 exposes a related lifecycle problem. A critique snapshot can remain on disk after its findings are fixed, then a later polish session treats that stale file as a current backlog. The issue reports a later agent spending about 200,000 tokens proving old findings were already resolved. Until snapshots have a close or freshness path, remove or archive them deliberately when the work is done and inspect inherited critique state before acting on it.

August 2026 activity is high, while stability still needs proof

GitHub showed 62,993 stars, 58 combined issues and pull requests, and a last push on August 26, 2026. The latest GitHub release, Extension 1.3.3, shipped that day with detector accuracy fixes while keeping 59 rules. Active pull requests cover live variant generation, CI routing, and credential redaction. This is a fast-moving project, and provider-specific installation details can change with the harnesses it supports.

Impeccable is worth testing if AI already writes meaningful amounts of your frontend. The 15-second build and no-key detector lower the barrier, but the 760 MB install, trusted hooks, false-positive reports, stale state, and failed test step keep it out of blind-default territory. Start with detect --json on a representative directory, review each rule's usefulness, then enable the skill and hooks for one project. The human accepting the UI should remain the final quality gate.

Alternatives

ProjectWhat it isPick it when
Anthropic Skills gh↗Anthropic's public collection of reusable Agent Skills, including frontend design guidance.pick this instead when you want a smaller general skill collection without Impeccable's detector and live design workflow.
UI Skills gh↗A collection of skills aimed at design engineers working on interfaces.pick this instead when concise interface guidance is enough and you do not need Impeccable's hooks or 59-rule detector.
Vercel Agent Skills gh↗Vercel's official collection of agent skills for web development workflows.pick this instead when your main need is framework and deployment guidance around Vercel's stack.

What people are saying

  1. [github-trending] pbakaus/impeccable

Sources

  1. Impeccable README
  2. Impeccable repository
  3. Impeccable Extension 1.3.3 release
  4. CSS radius false-positive issue
  5. Stale critique snapshot issue
  6. Inactive ignore-value issue

More ai tools reviews

LocalMiniDrama · agents-towards-production · Marinara-Engine · AI-Engineering-Coach · sdf-js · TradingAgents-astock · the whole board →