Skip to content
CAI
Software that uses CAICheck a score

pbakaus/impeccable

52.6

Adequate · 13 November 2026

229.2k

lines of production code

Rust

with JavaScript

7

measurements over time

CAI band scale
CAI trend line
CAI lens gauges

What this system is

Features

Impeccable design skill v4.4.0 with automated hook integration

The Impeccable design skill has been updated to version 4.4.0, consolidating design, critique, and live-iteration capabilities into a single command set. This release introduces a new \.gemini/settings.json\ configuration that automatically triggers the \impeccable\ hook before shell commands and after agent completions, enabling real-time design feedback and context synchronization. The skill now includes comprehensive reference documentation for native platform adaptation (iOS and Android), technical auditing, and motion design, ensuring consistent quality across web and native interfaces.

.gemini · high confidence

Impeccable skill v0.1.17 introduces live browser mode and cross-platform engine launcher

The Impeccable skill now includes a new 'live' mode that allows users to visually experiment with design alternatives in real time via a browser overlay, supporting features like element picking, variant generation, and hot-swapping via HMR. This is enabled by new browser-side scripts (live-browser.js, live-browser-dom.js, etc.) that handle UI chrome, session state, and DOM helpers. Additionally, the skill ships a new cross-platform launcher script (impeccable/impeccable.cmd) that resolves and executes the underlying engine binary, supporting automatic download and verification on Windows and Unix-like systems. The skill version is set to 0.1.17. Also in this area: 1 commit (0 fixes) modifying (repo-wide); 8 commits (0 fixes) modifying (repo-wide).

.vibe/skills/impeccable/scripts · medium confidence · unverified

Impeccable skill v0.1.6 introduces live variant mode and cross-platform engine launcher

The Impeccable skill now includes a new version (0.1.6) and a comprehensive set of scripts that enable interactive live design experimentation and robust cross-platform execution. A new shell launcher (\impeccable\) and Windows batch file (\impeccable.cmd\) handle binary discovery, version pinning, and secure download/verification of the engine, ensuring the tool works without Node.js. The skill also introduces a 'Live Variant Mode' via browser-side JavaScript (\live-browser.js\, \live-browser-dom.js\, \live-browser-session.js\) that allows users to select elements in the browser, pick design actions, and receive AI-generated HTML+CSS variants hot-swapped via HMR. Additionally, \command-metadata.json\ defines a rich set of new commands like \live\, \generate\, \adapt\, \animate\, and \audit\, expanding the skill's capabilities beyond simple generation to include responsive adaptation, animation enhancement, and technical auditing. Also in this area: 1 commit (0 fixes) modifying (repo-wide); 8 commits (0 fixes) modifying (repo-wide); Impeccable skill v4.5.2: code-led rounds now use HTML sketches instead of wireframes; Impeccable skill v4.5.1: Surface-specific build paths and clarified defaults.

.qoder/skills/impeccable/scripts · medium confidence · unverified

Impeccable skill v0.1.6 with live mode browser scripts and self-contained launcher

The Impeccable skill now ships as a self-contained package (v0.1.6) with a platform-agnostic shell launcher (impeccable/impeccable.cmd) that resolves and executes the native engine binary, including automatic download, SHA-256 verification, and fallback logic for Windows ARM. The skill includes a full set of command metadata (craft, init, document, extract, live, generate, adapt, animate, audit, bolder, clarify, colorize, critique, delight, distill, harden, onboard, layout, optimize, overdrive, polish, quieter, shape, typeset) and browser-side scripts for live variant mode: DOM helpers (live-browser-dom.js), project ignore resolution (live-browser-ignores.js), durable session state (live-browser-session.js), and the main live overlay UI (live-browser.js). A bundled modern-screenshot.umd.js is also included to support screenshot capture in live mode.

.agents/skills/impeccable/scripts, .claude/skills/impeccable/scripts, .cursor/skills/impeccable/scripts · high confidence

Impeccable skill v0.1.6: New launcher, command metadata, and live-mode browser scripts

The skill directory now ships a self-contained v0.1.6 launcher (impeccable/impeccable.cmd) that resolves and executes a native platform binary, supporting automatic download with SHA-256 verification and fallback to cached or PATH-installed engines. A new command-metadata.json defines the full set of Impeccable commands (init, live, generate, adapt, animate, audit, etc.) with descriptions and argument hints. Live mode is supported by new browser-side scripts: live-browser.js (the main overlay UI and session management), live-browser-dom.js (DOM helpers for element picking and framework HMR detection), live-browser-ignores.js (resolution of project detector waivers against page URLs), and live-browser-session.js (durable session state in localStorage). A bundled modern-screenshot.umd.js is also included for screenshot capabilities. Also in this area: 5 commits (4 fixes) fixing skill; 10 commits (4 fixes) modifying skill/scripts; Code-led decision cards now use HTML skeleton sketches; Operate and Read surfaces are now code-led by default.

skill/scripts · medium confidence · unverified

Impeccable skill v0.1.6: new launcher, live mode browser scripts, and command metadata

The Impeccable skill now ships a self-contained launcher script (impeccable/impeccable.cmd) that resolves and executes the platform-specific engine binary, including automatic download and SHA-256 verification when the binary is missing. A new command-metadata.json defines the available commands (init, live, generate, adapt, animate, audit, etc.) with descriptions and argument hints. Browser-side scripts for Live mode are added: live-browser.js provides the floating UI and variant cycling; live-browser-dom.js supplies DOM helpers for element picking and framework HMR ownership detection; live-browser-ignores.js resolves project-level detector waivers in the browser; and live-browser-session.js manages durable session state (checkpoints, handled IDs, scroll position) via localStorage. A VERSION file pins the skill to 0.1.6. Also in this area: 1 commit (0 fixes) modifying (repo-wide); 5 commits (1 fix) modifying plugin; 8 commits (0 fixes) modifying (repo-wide); Impeccable skill v4.5.2: code-led rounds now use HTML sketches instead of wireframes; Impeccable skill v4.5.1: Surface-specific build paths and clarified defaults.

plugin/skills/impeccable/scripts · medium confidence · unverified

Impeccable skill v4.0.0-alpha.9: new launcher, live mode browser scripts, and command metadata

The Impeccable skill introduces a standalone, platform-native engine launcher (shell and Windows batch) that resolves and executes a version-pinned binary (0.1.14) with SHA-256 verification, removing the dependency on the legacy npm CLI. It also adds the full browser-side implementation for Live Variant Mode, including DOM helpers, modal top-layer handling, session persistence, and project-aware detector ignores, alongside a comprehensive command metadata definition for the skill's 20+ design and live-edit verbs.

(repo-wide) · high confidence

Impeccable skill v4.2.3 release with live mode browser scripts

The Impeccable skill has been updated to version 4.2.3, introducing a new launcher script (\impeccable\) and its Windows counterpart (\impeccable.cmd\) that automatically detect and execute the platform-specific engine binary, including secure download and SHA-256 verification if the binary is missing. This release also adds a suite of browser-side JavaScript modules (\live-browser.js\, \live-browser-dom.js\, \live-browser-ignores.js\, \live-browser-session.js\) that power the new 'live mode' for real-time visual experimentation, providing DOM helpers, session state management, and project-aware ignore resolution for the overlay UI. Also in this area: 1 commit (0 fixes) modifying (repo-wide); 8 commits (0 fixes) modifying (repo-wide).

.grok/skills/impeccable/scripts · medium confidence · unverified

Initial release of Impeccable design skill and CLI

Introduces the Impeccable product, a design skill and CLI that provides a shared design vocabulary for AI coding tools. The skill includes 23 design commands for tasks like critique, audit, and live iteration, while the CLI and browser extension run 59 deterministic anti-pattern detection rules. The release also includes a Neo Kinpaku design system with specific color tokens and typography scales, and supports major AI harnesses like Claude Code, Cursor, and GitHub Copilot.

(repo-wide) · high confidence

Introduce Chrome DevTools extension with WASM-based anti-pattern detection

Adds a new Chrome extension that detects UI anti-patterns using a WebAssembly rule core running in an offscreen document. The service worker manages per-tab state, injects content scripts on demand, and routes messages between the popup, DevTools panel, and the offscreen document. The content script captures page snapshots, answers runtime questions (hit tests, pixels) from the live page, and draws overlays for findings. The extension also surfaces scan failures (e.g., local file restrictions) and updates the toolbar badge with the total count of anti-pattern findings.

extension/background · high confidence

Introduce Impeccable DevTools panel and sidebar for anti-pattern detection

Adds a new Chrome DevTools extension that integrates an 'Impeccable' panel and sidebar into the browser's developer tools. The panel provides a dedicated UI for viewing detected anti-patterns, with controls to re-scan the page, toggle visual overlays, copy findings, and adjust settings such as auto-scan behavior, line length strictness, and spotlight blur. The sidebar pane displays findings specific to the currently selected element in the Elements panel, allowing developers to inspect issues directly in context. The extension communicates with a background service worker via persistent ports with automatic reconnection logic to handle service worker termination in Manifest V3. Also in this area: Removal of layout-transition rule from devtools panel.

extension/devtools · high confidence

Introduce PR Sheriff automation for pull request lifecycle management

Adds a new automated 'PR Sheriff' system (scripts/github/sheriff.mjs) that monitors open pull requests and applies labels to reflect their current status. The script automatically manages state labels such as 'waiting on contributor', 'needs maintainer review', and 'ready to merge', as well as blocker labels like 'blocked: ci' or 'blocked: merge conflicts'. It also handles stale detection, applying 'stale' labels to inactive PRs and providing configurable warning and auto-close timelines. The automation respects maintainer overrides via a '/sheriff wait' command and exempts specific labels (e.g., 'security') from automatic closure.

scripts/github · high confidence

Introduce human component review workflow with native asset verification

This change adds a new human component review capability to the context crate, replacing the previous component kit review with a plan and asset review process. It introduces a new review UI (component-review.js) and a Rust backend (component\_review module) that manages the review lifecycle, including capturing native previews, verifying asset integrity via SHA-256 hashes, and tracking review history. The system supports both native browser captures and plan-based proofs, ensuring that approved components are backed by verifiable evidence. It also includes schema versioning for product and design sidecars, and a concept catalog for managing design tokens and patterns.

crates/context/src · high confidence

Landing demo now ships with a documented design system and a classic dark-mode variant

The landing demo now includes a formalized design system (Lumina) defined in DESIGN.json and DESIGN.md, specifying a warm-cream palette, Fraunces/Inter typography, and flat, rounded component styles, alongside a PRODUCT.md that outlines the brand's anti-monoculture positioning. Additionally, a new classic/index.html provides a contrasting dark-mode variant with purple/pink gradients and glassmorphism effects, offering users a distinct visual alternative to the primary editorial-warm theme.

demos · high confidence

Live server engine ported to Rust

The live server's core logic has been rewritten in Rust, replacing the previous JavaScript implementation. This change introduces new modules for CSS reconciliation and baking (\accept\_css\, \bake\), post-condition verification of accepted source (\accept\_verify\), browser script assembly and injection (\browser\_assets\), and automated browser launching (\browser\_open\). It also includes a new configuration parser (\config\), an AI-driven copy-edit agent runner (\copy\_edit\_agent\), and a design system markdown parser (\design\_md\). The Rust engine now handles the generate lane's mechanical bake, variant acceptance, and live-edit application, providing a single binary that replaces the prior script-based tooling.

crates/live/src · high confidence

Native Cursor marketplace plugin packaging

The Impeccable skill is now packaged as a native Cursor plugin, providing a \plugin.json\ manifest, a set of specialized agents (asset producer, documenter, finish reviewer, manual edit applier), and a \preToolUse\ hook that triggers the Impeccable engine on file writes. This allows users to install the plugin directly from the Cursor marketplace or locally, enabling design and refinement workflows without requiring a separate project-level installation. Also in this area: 1 commit (0 fixes) modifying (repo-wide); 11 commits (0 fixes) modifying .cursor, cursor-plugin.

cursor-plugin · medium confidence · unverified

Native Rust browser engine replaces Puppeteer for URL scanning

The URL scanning engine has been rewritten in Rust (crates/browser/src) to replace the previous Node.js/Puppeteer implementation. This new engine discovers installed Chromium-based browsers, drives them via a custom Chrome DevTools Protocol client, and executes the rule core natively. For users, this means scans no longer require a WebAssembly bundle or bypassing Content Security Policy, allowing strict-CSP sites to be scanned passively. The engine also includes built-in handling for hiding known consent managers, product tours, and preloaders before analysis, and supports full-page screenshot stitching for complex layouts.

crates/browser/src · high confidence

New Rust-based HTML analysis examples for detection, profiling, and debugging

Added three new command-line examples in the \crates/html/examples\ directory to support the new Rust static engine. \detect\_json\ allows users to run HTML detection and output results as JSON, mirroring the JS CLI's \detect --json\ capability. \rule\_cost\ provides a profiling tool to measure the performance cost of each detector rule per edit, helping users understand engine overhead. \unsupported\_selectors\ helps identify CSS selectors that the underlying parser rejects, serving as a parity aid for debugging selector compatibility.

crates/html/examples · high confidence

New build and release tooling for the Impeccable engine and browser extensions

The scripts directory now includes a comprehensive set of build and release automation tools. The main build script (build.js) orchestrates the transformation of design skills into provider-specific formats (Cursor, Claude Code, Gemini, etc.), generates site counts, and validates plugin versions. A new extension build script (build-extension.js) compiles the Rust-based detector into WebAssembly, packages the Chrome and Firefox browser extensions, and verifies file integrity. Additional scripts handle fetching and verifying the native engine binaries (fetch-engine.mjs, check-engine-release.mjs), publishing platform-specific npm packages (publish-platform-packages.mjs), generating font indexes (build-font-index.mjs), and creating extension assets like icons and promo tiles. This replaces previous ad-hoc build processes with a unified, verified pipeline.

scripts · high confidence

New build harnesses and plugin packaging for Cursor, OpenAI, and VS Code

The build system now generates distributable plugin packages for Cursor, OpenAI (Codex), and VS Code alongside the existing Claude Code support. New scripts/lib modules handle provider-specific manifest generation, path rewriting (e.g., replacing project-relative paths with host-specific variables like ${CLAUDE\_SKILL\_DIR} or ${CLAUDE\_PLUGIN\_ROOT}), and asset staging. Additionally, a test harness safety net was added to detect and kill orphaned live-server processes left behind by crashed or killed test runs, ensuring cleaner test environments.

scripts/lib · high confidence

New bundle crate for generating browser artifacts

A new \crates/bundle\ crate has been introduced to handle the assembly of the detector's JavaScript and WebAssembly outputs. This component embeds the page JS sources (such as \00-header.js\, \15-snapshot.js\, and \50-scan.js\) at compile time and provides functions to generate the in-page bundle (\detect-antipatterns-browser.js\) and the individual extension pieces (snapshot, overlay, and core scripts). It manages the concatenation order, including the insertion of wasm-bindgen glue and the base64-encoded WASM module, ensuring deterministic output for both the browser page and the extension components.

crates/bundle · high confidence

New rule registry and browser detector assets for the live server

The live server now ships a generated rule registry (\antipatterns.json\) and an in-page detector bundle (\detect-antipatterns-browser.js\) that are tracked in the repository and rebuilt by \cargo xtask bundle\. The registry exposes the full list of detection rules (including new anti-patterns like side-tab accents, AI color palettes, and nested cards) so that consumers without a Rust toolchain can read and render the rule definitions. The browser bundle embeds the WASM-compiled rule core and DOM probe, allowing the live server to serve \/detect.js\ for in-browser scanning.

crates/live/assets · high confidence

Port of browser-mode accessibility rule engine to Rust

The \crates/core/src/browser\ module has been implemented in Rust, porting the in-page accessibility rule engine from the previous JavaScript implementation (\checks.mjs\ and \browser/injected/index.mjs\). This change introduces new modules for handling background resolution, decorative text classification, element-level checks, field labeling, page-level typography and layout analysis, and the paint-gate logic that determines which elements are visible at capture time. The Rust implementation maintains parity with the original JavaScript logic, ensuring that the same accessibility findings are generated for browser-based scans.

crates/core · high confidence

Port of the analysis engine to Rust

The analysis engine has been ported from JavaScript to Rust, replacing the previous script-based implementation. This new binary engine includes the core foundation layer (color math, font handling, inline-ignore parsing, and rule registry) and the rule-checking logic, ensuring bit-for-bit parity with the original JS behavior for deterministic results.

crates/foundation/src · high confidence

Port of the static CSS cascade engine to Rust

The static HTML cascade engine has been ported from JavaScript to Rust, introducing a new \csstree\ module that reimplements the CSS tokenizer, parser, and generator to match the behavior of \css-tree\ 3.2.1. This change enables the cascade to collect and process static CSS rules, resolve custom properties, and compute specified styles without relying on a live DOM or the JS CSSOM, ensuring that color, contrast, and layout checks receive complete and accurate style data.

crates/html/src/cascade · high confidence

Ported comp-fidelity pipeline to Rust

The \crates/comp\ library now provides the pure, browser-independent foundation for the component-fidelity pipeline, ported from the existing JavaScript skill scripts. This Rust implementation includes modules for PNG I/O (\png\_io\), raster operations (\raster\), image metrics (\metrics\), font fingerprinting (\font\_fingerprint\), font indexing (\font\_index\), and hero-gate checks (\hero\). It also introduces \jsnum\ to replicate JavaScript number semantics (rounding, fixed-point formatting, hex conversion) and \review\_groups\ to enforce structural constraints on component review data. This change replaces the previous JS-based logic for these specific fidelity checks with a self-contained Rust crate.

crates/comp · high confidence

Scan running desktop apps via local DevTools port

The \impeccable detect\ CLI now supports the \--cdp \<port\|url\>\ flag to attach to a running Chromium-based desktop application (such as Electron, NW.js, CEF, or WebView2) through its local DevTools endpoint. This allows the detector to scan the live, rendered page of a running app without launching a new browser instance or navigating to a URL. The implementation enforces strict security by only accepting loopback addresses (e.g., \127.0.0.1\, \localhost\, or \\[::1\]\), rejecting any external hosts to prevent unauthorized remote access to the application's debugging interface.

crates/detect · high confidence

Static HTML analysis engine ported from JavaScript to Rust

The HTML detection engine has been rewritten in Rust, replacing the previous JavaScript implementation to provide a single, faster binary. This new static engine parses HTML and computes styles without a browser, enabling accessibility checks for contrast, typography, layout, and decorative text in headless environments. The port maintains behavioral parity with the original JS engine, ensuring that findings for issues like low-contrast text, oversized headings, and broken images are reported consistently.

crates/html/src · high confidence

Unified build transformers for multi-IDE agent and hook generation

The build pipeline now uses a new transformer system in scripts/lib/transformers to generate IDE-specific agent definitions and hook manifests for a wide range of providers, including Claude Code, Codex, Cursor, GitHub Copilot, Grok Build, Gemini, Kiro, OpenCode, Pi, Qoder, Rovo Dev, Mistral Vibe, Veto, Trae, Antigravity, and Hermes. This change introduces provider-specific formatting for agent files (e.g., TOML for Codex, Markdown with YAML frontmatter for Claude/Cursor/Copilot) and generates correct hook installation scripts for each environment, ensuring that design checks and deep-pass rules are properly wired into the respective IDEs' hook systems.

scripts/lib/transformers · high confidence

Architecture

Introduce Rust-based WASM rule engine and new browser-bundle architecture

The browser-bundle JavaScript files have been completely rewritten to serve as a thin measurement and presentation layer for a new Rust-based WebAssembly rule engine. The previous logic for rule evaluation and detection has been removed from the browser bundle and moved into the WASM core (crates/core). The new bundle now consists of a DOM probe (10-probe.js) that exposes specific DOM APIs to the WASM core, a snapshot producer (15-snapshot.js) for off-screen analysis, visual-contrast sampling (35-visual.js), and an overlay UI (40-overlay.js) that uses a new 'Kinpaku' gold branding. The scan orchestration (50-scan.js, 60-offscreen.js) now acts primarily as a bridge, marshalling data between the page/extension and the WASM core, which handles all rule decisions, serialization, and finding aggregation. Also in this area: Fix contrast analysis for stacked gradients with fading stops.

browser-bundle · high confidence

Behavioural changes

1 commit (0 fixes) modifying .hermes/plugins/impeccable-design-hook

A change to existing behaviour in .hermes/plugins/impeccable-design-hook — 1 commit, 2 files: “Sync generated provider output”.

.hermes/plugins/impeccable-design-hook · medium confidence · unverified

1 commit (0 fixes) modifying skill/hermes-plugin

A change to existing behaviour in skill/hermes-plugin — 1 commit, 2 files: “Add a design hook for Hermes Agent (\#1178) (\#1209)” (refs \#1178, \#1209).

skill/hermes-plugin · medium confidence · unverified

2 commits (1 fix) modifying vscode

A change to existing behaviour in vscode — 2 commits (1 fix), 2 files: “Add declarative VS Code skill extension packaging (\#775)”; “Fix: declare VS Code Agents window support (\#1333)” (refs \#775, \#1333).

vscode · medium confidence · unverified

20 commits (5 fixes) modifying crates/wasm/src

A change to existing behaviour in crates/wasm/src — 20 commits (5 fixs), 7 files: “Page-level premises: the white canvas, script text, pseudo marquees, rings, blinks, flat fades and unloaded faces (\#1199)”; “Fix deferred review findings in the rule core and the in-page probe (\#968)”; “Report a side stripe on a status row or cell as a side tab (\#1133)”; and 17 more (refs \#1199, \#968, \#1133, \#1136, \#1181, …).

crates/wasm/src · medium confidence · unverified

22 commits (1 fix) modifying crates/agents

A change to existing behaviour in crates/agents — 22 commits (1 fix), 9 files: “Add impeccable agents engine for owner-scoped hooks, MCP and rule blocks”; “Let hooks carry timeout, async and asyncRewake”; “Add agents list: a read-only setup report of every installation”; and 19 more.

crates/agents · medium confidence · unverified

24 commits (0 fixes) modifying .devin/skills/impeccable/scripts

A change to existing behaviour in .devin/skills/impeccable/scripts — 24 commits, 12 files: “Sync generated provider output”; “Release skill and CLI 4.9.0 on engine 0.1.23”; “Release skill 4.8.2: carry the engine 0.1.21 checksums into every harness copy”; and 3 more.

.devin/skills/impeccable/scripts · medium confidence · unverified

35 commits (0 fixes) modifying .omp/skills/impeccable/scripts

A change to existing behaviour in .omp/skills/impeccable/scripts — 35 commits, 12 files: “Sync generated provider output”; “Release skill and CLI 4.9.0 on engine 0.1.23”; “Release skill 4.8.2: carry the engine 0.1.21 checksums into every harness copy”; and 3 more.

.omp/skills/impeccable/scripts · medium confidence · unverified

4 commits (0 fixes) modifying crates/context/assets

A change to existing behaviour in crates/context/assets — 4 commits, 1 file: “Run CI on Bun 1.4.4 (\#1165)”; “Add human component review and prepare Impeccable 4.4.0 (\#811)”; “Replace the component kit review with a plan and asset review (\#858)”; and 1 more (refs \#1165, \#811, \#858, \#1056).

crates/context/assets · medium confidence · unverified

5 commits (0 fixes) modifying extension/content

A change to existing behaviour in extension/content — 5 commits, 1 file: “Report a low-contrast colour pair and a nested-cards panel once, with a count (\#1200)”; “Polish Chrome extension for Web Store submission”; “Add Copy all findings to the extension popup (\#1157)”; and 2 more (refs \#1200, \#1157, \#714).

extension/content · medium confidence · unverified

5 commits (1 fix) modifying crates/account/src/pro

A change to existing behaviour in crates/account/src/pro — 5 commits (1 fix), 2 files: “Refuse to ship an engine with no Pro release key”; “Fix: renew the Pro lease in its last day, for 48-hour leases”; “Say 'Pro rules are on.' once per sign-in”; and 2 more.

crates/account/src/pro · medium confidence · unverified

56 commits (0 fixes) modifying .veto/skills/impeccable/scripts

A change to existing behaviour in .veto/skills/impeccable/scripts — 56 commits, 12 files: “Sync generated provider output”; “Release engine 0.1.4, CLI 4.0.5 and skill 4.2.3 (\#782)”; “Release skill and CLI 4.9.0 on engine 0.1.23”; and 11 more (refs \#782, \#811, \#787, \#743, \#725, …).

.veto/skills/impeccable/scripts · medium confidence · unverified

6 commits (2 fixes) modifying crates/cli/src

A change to existing behaviour in crates/cli/src — 6 commits (2 fixs), 3 files: “Add repo labels to DESIGN.md sync and clarify lock errors”; “Fix setup report concurrency and bound inventory probes”; “Free uploads: the decider's defaults, approved wording and first-time notices”; and 3 more. Also in this area: 7 commits (1 fix) modifying crates/cli; Telemetry v2: explicit opt-out, seed references, and runtime state protection; Native capture engine and offline diagnostic examples.

crates/account/src, crates/cli/src · medium confidence · unverified

63 commits (0 fixes) modifying .hermes/skills/impeccable/scripts

A change to existing behaviour in .hermes/skills/impeccable/scripts — 63 commits, 10 files: “Sync generated provider output”; “Release engine 0.1.4, CLI 4.0.5 and skill 4.2.3 (\#782)”; “Release skill and CLI 4.9.0 on engine 0.1.23”; and 9 more (refs \#782, \#811, \#787, \#743, \#995, …).

.hermes/skills/impeccable/scripts · medium confidence · unverified

8 commits (1 fix) modifying crates/context/src/component\_review

A change to existing behaviour in crates/context/src/component\_review — 8 commits (1 fix), 11 files: “Print the quoted .cmd launcher with PowerShell's call operator (\#1110)”; “Replace tiny\_http with the shared HTTP core in serve-question and component review (\#1072)”; “Serve every connection of a burst and write question state atomically (\#1071)”; and 5 more (refs \#1110, \#1072, \#1071, \#811, \#858, …).

_crates/context/src/component\review · medium confidence · unverified

Approved comp is now a fixed, immutable reference for all build gates

The build process now locks the approved component (comp) as a fixed reference that every gate measures against, preventing silent drift if the source file is edited or replaced during the build. The engine keeps a byte copy of the approved comp and records its pixel hash; if the current file no longer matches this record, gates refuse to measure and require restoration via \build-phase restore-comp\. This ensures that plates, code, and responsive checks are always validated against the exact version the user approved, rather than a potentially modified or stale image.

crates/comp-verbs · high confidence

CLI now delegates to a native Rust engine binary with platform-specific packaging

The CLI has been replaced by a Node.js shim that locates and executes a native Rust engine binary. This binary is delivered via platform-specific optional npm dependencies (e.g., @impeccable/cli-darwin-arm64) or, if unavailable, is securely downloaded and cached to the user's home directory with SHA-256 verification. The shim also changes the --version output to report the npm package version rather than the engine version, and provides clearer error messages if the binary cannot be located or executed.

cli · high confidence

CSS analysis engine ported from JavaScript to Rust

The CSS parsing, measurement, and scanning logic has been rewritten in Rust (crates/foundation/src/css), replacing the previous JavaScript implementation. This change introduces new modules for handling CSS value parsing (measures.rs) and stylesheet text scanning (scan.rs), providing the underlying data structures and utilities for the rule checks. Users should expect the same CSS analysis capabilities, now executed by the Rust engine.

crates/foundation/src/css · high confidence

Impeccable skill updated to v0.1.17 with expanded command metadata and font failure tracking

The Impeccable skill has been updated to version 0.1.17. This release syncs the generated provider output, introducing a comprehensive \command-metadata.json\ file that defines descriptions and argument hints for 24 distinct design and development commands (such as \live\, \animate\, \audit\, and \polish\). Additionally, a new \font-index-failures.json\ data file has been added to track specific font families (e.g., Betania Patmos, Doto, Jacquard) that failed to load or lack lettering data, aiding in debugging typography issues. Also in this area: 1 commit (0 fixes) modifying (repo-wide); 8 commits (0 fixes) modifying (repo-wide).

.agent/skills/impeccable/scripts, .dsh/skills/impeccable/scripts · medium confidence · unverified

Introduce Rust-based xtask for building and tracking generated assets

The workspace now uses a new Rust binary (\crates/xtask\) to replace previous scripts and the JS detector for building the in-page detector bundle. Running \cargo xtask bundle\ compiles the WebAssembly module, concatenates it with JavaScript glue code, and generates two tracked assets: \dist/detect-antipatterns-browser.js\ and \crates/live/assets/antipatterns.json\. It also produces extension-specific files (snapshot.js, overlay.js, core.js, core\_bg.wasm) into \extension/detector/\. The task supports a \--check\ flag to verify that these generated assets are up-to-date, serving as a staleness gate for CI.

crates/xtask · high confidence

Introduce plan and asset review for component visual checkpoints

The component review UI now supports a new 'plan and asset' review mode (schemaVersion 3) alongside the existing inventory view. This mode presents a focused, attention-first interface for human reviewers to evaluate generated assets and code-drawn regions against the design comp. Key changes include a streamlined workflow that replaces bulk approval with item-by-item decisions (Approve, Needs work, Split/Make it an image), a visual comparison canvas with synced loupe and space-to-flip inspection, and a summary screen that consolidates all decisions and missing-region marks. The review is served via a new native static capture pipeline that verifies rendered pixels against frozen inputs, ensuring provenance. The UI also incorporates the Impeccable design-system kit (Alumni Sans, Albert Sans, and JetBrains Mono fonts) and supports repair rounds that track changes and carry over feedback.

ui · high confidence

New Impeccable extension popup with scan controls and error visibility

The extension now features a redesigned popup interface that displays the current anti-pattern count, provides buttons to scan the page and toggle overlays, and explicitly surfaces scan failures via a dedicated error message area. This change updates the user experience by making it clear when a scan cannot complete, rather than silently failing or leaving the UI in an ambiguous state.

extension/popup · high confidence

New shared Rust engine core replaces Node.js scripts and detectors

The \crates/common\ library introduces a new Rust-based engine core that replaces the previous JavaScript-based scripts and detectors. This change introduces several new modules: \fsx\ for atomic file writes that safely handle symlinks and dangling links; \git\ for reading repository layout and managing \.gitignore\ files without spawning the \git\ binary; \http\ for a lightweight, shared HTTP server core replacing \tiny\_http\; \jsp\ for Node-compatible path semantics; \launcher\ for correct Windows PowerShell command spelling; \proc\ for cross-platform process management and signal handling; and \seed\ for secure, salted telemetry key management. These modules provide the foundational plumbing for the application's verbs, ensuring testability and cross-platform consistency.

crates/common · high confidence

Ported design hook logic from JavaScript to a native Rust binary

The design hook logic previously implemented in \skill/scripts/hook.mjs\ and related Node.js scripts has been ported to a new Rust crate (\crates/hook\). This change replaces the JavaScript execution with a native binary, updating the hook manifests to invoke the new \impeccable\ launcher instead of \node\. The port includes the per-edit pass, the Stop deep pass, the pre-edit gate (retired for Cursor but kept for migration), and the admin commands, ensuring the same detection and reporting behavior while removing the Node.js runtime dependency for these operations. Also in this area: 4 commits (4 fixes) fixing crates/hook.

crates/hook/src · medium confidence · unverified

Rust accessibility engine introduces refined text and contrast reporting rules

The Rust engine in this location now applies stricter, more human-centric thresholds for text readability and contrast. Tight-leading checks exempt bold titles (weight ≥600, ≤2 lines or clamped) and ignore single-line text, while undersized-ui-text tolerates sizes down to 10.9px (11px floor) and 9.9px (10px smallprint floor). Contrast scoring now only triggers where text is visible, reports near-misses as advisory, and excludes icon fonts and glyph-only text. All-caps body text is flagged only for runs ≥80 characters, and justified text is restricted to narrow columns.

crates/foundation/src/rules · high confidence

Rust engine replaces JS detector with WASM-based implementation

The detection engine has been rewritten in Rust and compiled to WebAssembly, replacing the previous JavaScript-based detector. This change introduces a new bundling system (\impeccable-bundle\) that generates the in-page bundle and extension pieces from embedded sources, and a vector-replay system (\impeccable-foundation\) that allows the Rust engine to replay recorded JS call vectors for parity verification. The new engine is verified against the old JS implementation using A/B differential testing tools (\ab-diff.mjs\, \ext-diff.mjs\) and specific regression checks (\disabled-values-check.mjs\, \skip-scan-check.mjs\).

crates/foundation/src/vectors, crates/wasm/tools, extension/offscreen · high confidence

Rust engine replaces JavaScript for in-page accessibility checks

The in-page accessibility rule engine has been ported from JavaScript to Rust, consolidating the measurement logic into a single binary. This change introduces a new \Dom\ trait in \crates/foundation/src/browser/dom.rs\ that defines the interface for DOM queries, computed styles, and geometry, replacing the previous \checkElement\*DOM\ adapters. A \SnapshotDom\ implementation in \snapshot.rs\ now allows these rules to run against serialized page snapshots (JSON) for environments where WebAssembly cannot execute next to the page, such as Chrome extensions on strict-CSP sites. The port includes a Chrome-flavored selector engine (\selector.rs\) and a table-driven \FakeDom\ (\fake\_dom.rs\) for unit testing, ensuring parity with the previous JavaScript probe's behavior.

crates/foundation/src/browser · high confidence

Rust engine replaces Node.js for skills management

The skills management CLI (install, update, check, link) has been rewritten in Rust, replacing the previous Node.js implementation. This change introduces signed skill bundles verified via Ed25519 signatures before extraction, automatic downloading and installation of the self-contained engine binary for each skill, and rewritten hook manifests that invoke the new launcher instead of Node.js scripts. The Rust engine also standardizes terminal prompts and handles provider-specific hook paths across various AI harnesses. Also in this area: 1 commit (0 fixes) modifying crates/skills; 3 commits (0 fixes) modifying crates/skills; 4 commits (3 fixes) fixing crates/skills.

crates/skills/src · medium confidence · unverified

Shared UI theme and design tokens for the extension interface

A new shared CSS file (kinpaku.css) introduces a consistent 'paper and ink' visual system across the extension's popup, DevTools panel, sidebar, and overlays. This update defines a specific color palette (gold, patina, vermilion, paper, ink), typography using system font stacks to match the site's design, and UI components like the brand mark, tags, and controls, ensuring the extension's interface aligns with the main site's aesthetic.

extension/shared · high confidence

Fixes

5 commits (4 fixes) fixing crates/live/src/inject

A fix in crates/live/src/inject — 5 commits (4 fixs), 9 files: “Fix: Nuxt live plugin types its script query (\#1223) (\#1224)”; “Fix live-inject CSP meta patch escaping and revert (\#1128)”; “Fix: Vue live variants get their preview CSS from a component style tag (\#1283) (\#1294)”; and 2 more (refs \#1223, \#1224, \#1128, \#1283, \#1294, …).

crates/live/src/inject · medium confidence · unverified

Test coverage

2 commits adding/updating tests in tests/fixtures/evidence; 23 commits adding/updating tests in crates/cli/tests; 27 commits adding/updating tests in crates/skills/tests; 32 commits adding/updating tests in crates/hook/tests; Added framework fixture suites for E2E testing; Added skill-behavior test suite for LLM-driven skill protocol verification; Added test assets for hook-umbrella workspace; Added test coverage for HTML analysis rules and CSS cascade logic; Added test coverage for the skills transformer factory and provider-specific output logic; Added test fixtures for Astro, Next.js, SvelteKit, and Vite-React; Added test fixtures for HUMAN Security (PerimeterX) press-and-hold overlay states; Added test fixtures for Next.js CSP and Turborepo configurations; Added test fixtures for Next.js app router patterns; Added test fixtures for TanStack Router and TanStack Start live mode; Added test fixtures for consent wall detection; Added test fixtures for monorepo workspace tooling; Added test fixtures for overlay hiding scenarios; Added test fixtures for the Oracle engine; Added test infrastructure and coverage for engine binary detection, live server lifecycle, and utility functions; Added tests for the WASM detection exports and rule pack integration; Expanded browser-based test coverage for URL engine rules and behaviors; Expanded test coverage for build, signing, CI, and live-mode fixtures; Expanded test fixtures for AI color palette, typography, and layout anti-patterns; Expanded test fixtures for live mode across modern frameworks and CSP configurations; New live-mode E2E test infrastructure and agent helpers; Oracle test corpus for the Rust engine binary.

Dependencies

Introduce Rust-based detection engine and platform-specific binaries

The project now includes a Rust workspace (Cargo.toml/Cargo.lock) containing the core detection engine and supporting crates (foundation, core, detect, html, browser, live, etc.), replacing previous JavaScript-based implementations. To support this, platform-specific optional dependencies are added for the CLI (\@impeccable/cli-darwin-arm64\, \@impeccable/cli-darwin-x64\, \@impeccable/cli-linux-arm64\, \@impeccable/cli-linux-x64\, \@impeccable/cli-windows-x64\), which provide the compiled engine binaries for their respective operating systems and architectures.

(dependencies) · high confidence

Written by cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

How this codebase got here

Score

  • CAI 47 → 53 (+6.1)
  • Rubric changed (rubric-2026.10.5 → rubric-2026.11.3) — scores are not directly comparable.

Lenses

  • Code Health 43 → 46 (+3.6)
  • Architecture 98 → 98 (+0.2)
  • Maturity 65 → 68 (+3.3)
  • Readiness 37 → 47 (+9.9)
  • Security 73 → 74 (+0.7)
  • Accessibility 63 → 74 (+11.3)
  • Performance 60 → 60 (+0.0)

Resolved (132)

  • (anonymous) (cognitive 23) (extension/content/content-script.js)
  • (anonymous) (cognitive 33) (extension/background/service-worker.js)
  • (anonymous) (cyclomatic 22) (browser-bundle/60-offscreen.js)
  • (anonymous) (cyclomatic 27) (extension/background/service-worker.js)
  • Di::$n (cyclomatic 18) (crates/context/assets/component-review.js)
  • Di::Ge (cyclomatic 22) (crates/context/assets/component-review.js)
  • Di::ae (cognitive 53) (crates/context/assets/component-review.js)
  • Documentation: written for insiders (docs/BUNDLE-SIGNING.md)
  • Duplicate type definition across modules. imperfect_browser.html_snapshot.HtmlSnapshot and imperfect.capture_snapshot.HtmlSnapshot appear to serve the same purpose (managing HTML snapshots) with nearly identical methods (freeze, digest, manifest, entry, bytes, verify_current, serve_path, serve). This suggests a refactoring artifact or split between 'browser-level' and 'capture-service-level' concerns that should be unified.
  • Duplicate type definition. imperfect_browser.html_snapshot.SnapshotSelection and imperfect.capture_snapshot.SnapshotSelection have identical properties (root, entry, served, bound).
  • Duplicate type definition. imperfect_browser.html_snapshot.SnapshotServer and imperfect.capture_snapshot.SnapshotServer both expose entry_url(). This indicates redundant server implementations.
  • Duplicated block (10 lines × 2) (crates/live/src/live_commit_manual_edits.rs)
  • Duplicated block (10 lines × 6) (crates/live/src/manual_edits/commit.rs)
  • Duplicated block (10–11 lines × 2) (crates/core/src/browser/quality.rs)
  • Duplicated block (10–11 lines × 2) (crates/html/src/engine.rs)
  • Duplicated block (11 lines × 2) (crates/context/src/context_cli.rs)
  • Duplicated block (11 lines × 2) (crates/foundation/src/vectors/mod.rs)
  • Duplicated block (11 lines × 3) (crates/live/src/manual_edits/commit.rs)
  • Duplicated block (12–14 lines × 2) (crates/live/src/manual_edits/commit.rs)
  • Duplicated block (13 lines × 2) (crates/browser/src/html_snapshot.rs)
  • …and 112 more

New (431)

  • (anonymous) (cognitive 27) (extension/content/content-script.js)
  • (anonymous) (cognitive 37) (extension/background/service-worker.js)
  • (anonymous) (cyclomatic 18) (extension/content/content-script.js)
  • (anonymous) (cyclomatic 24) (browser-bundle/60-offscreen.js)
  • (anonymous) (cyclomatic 32) (extension/background/service-worker.js)
  • 15-snapshot.__snapRenderedFaces (cyclomatic 16) (browser-bundle/15-snapshot.js)
  • Documentation: no map of the repository's parts (README.md)
  • Duplicated block (10 lines × 2) (crates/core/src/browser/driver.rs)
  • Duplicated block (10 lines × 2) (crates/core/src/checks/vectors_a.rs)
  • Duplicated block (10 lines × 2) (crates/live/src/live_commit_manual_edits.rs)
  • Duplicated block (10 lines × 6) (crates/live/src/manual_edits/commit.rs)
  • Duplicated block (10–11 lines × 2) (crates/core/src/checks/css_scan.rs)
  • Duplicated block (11 lines × 2) (crates/foundation/src/vectors/mod.rs)
  • Duplicated block (11–12 lines × 2) (crates/agents/src/fs_writer.rs)
  • Duplicated block (12 lines × 2) (crates/agents/src/resources.rs)
  • Duplicated block (12 lines × 3) (crates/live/src/manual_edits/commit.rs)
  • Duplicated block (12–14 lines × 2) (crates/live/src/manual_edits/commit.rs)
  • Duplicated block (13 lines × 2) (crates/agents/src/lib.rs)
  • Duplicated block (14 lines × 2) (crates/account/src/store.rs)
  • Duplicated block (14 lines × 2) (crates/live/src/manual_edits/apply.rs)
  • …and 411 more

Changes since last survey

  • 300 commits — 237 feature/other, 63 fixes

By area

  • (repo) — 77 commits
  • crates/account — 36 commits
  • .agent/skills — 23 commits
  • crates/cli — 22 commits
  • crates/agents — 18 commits
  • skill/reference — 18 commits
  • (root) — 15 commits
  • skill/scripts — 11 commits
  • .github/workflows — 10 commits
  • tests/oracle — 10 commits
  • crates/context — 8 commits
  • crates/hook — 8 commits
  • crates/skills — 6 commits
  • scripts/staging-cli-e2e.sh — 6 commits
  • scripts/launch-smoke.sh — 5 commits
  • scripts/cli-pro-release-keys.json — 3 commits
  • docs/CLI-CONTRACT.md — 2 commits
  • scripts/check-engine-release.mjs — 2 commits
  • scripts/lib — 2 commits
  • tests/live-e2e — 2 commits

Notable commits

  • fix: Fix DESIGN.md sync review findings
  • fix: Fix Windows DESIGN.md metadata containment
  • fix: Fix Windows directory handle open options
  • fix: Fix adversarial DESIGN.md upload review findings
  • fix: Fix bounded credential reads and numeric critique targets
  • fix: Fix critique upload input, opt-out, and renewal boundaries
  • fix: Fix hook wiring status and consent-aware context repair
  • fix: Fix hooks for Claude account-scoped user installs
  • fix: Fix setup report concurrency and bound inventory probes
  • fix: Fix sync opt-out race and JSON alias notice suppression
  • fix: Fix: PATH loop variables are not path-modifier letters
  • fix: Fix: a PATH binary runs without call, so % in its arguments survives
  • fix: Fix: a trailing-dot host matches; proxy tests survive Windows env
  • fix: Fix: critique personas read PRODUCT.md, onboard empty states and libraries (#985)
  • fix: Fix: declare VS Code Agents window support (#1333)
  • fix: Fix: define the FORM seed value for a pinned direction (#1244) (#1265)
  • fix: Fix: disconnect stops waking and names the MCP server after rolling back a stopped connect
  • fix: Fix: discovery follows the cache's root rule, skips pipes and big files
  • fix: Fix: discovery runs for a session started inside a project
  • fix: Fix: doctor knows the reports config key
  • …and 280 more

Written by cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

Survey your own repository

pbakaus/impeccable was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.

About this page

  • The score is its most recent published measurement, taken on 13 November 2026 at a pinned commit. It is not a live figure and does not change until the project is measured again.
  • Measured at commit c4cd1924c389f68d37c687d9c2bbf13f12547c41 — the exact code this score is about.
  • Scored under rubric-2026.11.3 — the same rubric and the same method as every other entry in this index.
  • Measured by Canine Code Analyzer (cca.canine.dev) using cca measure-2026.11.63+preprod-4a8cc97a9484.