impeccable

• Useful errors instead of silent exits. Blocked cache writes and failed engine downloads now identify the required engine version, cache location, and recovery steps. Automatic first-use downloads and reuse of the cached engine are preserved.

• Windows setup stops cleanly. Unwritable download locations report an error instead of leaving the launcher waiting for input.

• Artwork that belongs on your page. Impeccable can now generate illustrations and objects with genuinely transparent backgrounds, ready to sit over your own colors and textures. Photos and full-frame artwork keep their backgrounds.

• GPT Image 2.5 joins the workflow. Flare now powers image generation and reference edits when Impeccable uses your OpenAI key. Your agent's native image tool remains the first choice.

• More iterations, less waiting. In our 24-image comparison, Flare reduced median generation time from 88 seconds to 18, with approximately 73% lower estimated cost.

• Cutouts get a closer look. Asset production checks white details, fine edges, and interior gaps on light and dark backgrounds, then refines visible misses. Fidelity checks account for transparency against the reference background.

• Choose the model and background. generate-image defaults to GPT Image 2.5 Flare and adds --model and --background transparent|opaque|auto for generation and reference edits.

• Reusable PNG assets. Transparency survives prompt embedding, background choices are recorded alongside the image, and output paths are validated before generation.

• Commands survive spaces in install paths. Comp-workflow instructions quote launcher paths correctly while preserving prefixes such as npx impeccable.

Prebuilt impeccable engine binaries (engine-v0.1.5). The launcher, the npm shim and impeccable install download these on first run. Docs: https://impeccable.style

• Design hooks respect each app. In monorepos, post-edit, before-edit, and Stop checks use the target app's DESIGN.md, with repository fallback and no sibling leakage. Thanks to @tylerjryan for the report and proposed approach.

• Stop findings distinguish existing debt. When a trustworthy edit baseline is available, the Stop pass separates pre-existing findings from new ones; uncertain attribution is stated explicitly.

• Windows and managed-network fixes. Engine 0.1.4 fixes Windows update prompts and CSP configuration discovery, and trusts certificates installed in the operating system's certificate store.

• Clearer fallback when the launcher is blocked. The agent uses readable references and discloses checks it could not run. Surface briefs also stay distinct when long target paths share a prefix.

• Document the finished design. New designs and approved system changes require both design tokens and their sidecar metadata; ordinary extensions preserve an unchanged design system.

• Install from the VS Code Marketplace. GitHub Copilot users can install the Impeccable skill extension without copying files into a project. This skill-only package does not install design hooks.

• Windows updates can prompt normally. Interactive confirmations use line input instead of unsupported raw terminal mode, without automatically accepting the update.

• HTTPS works with managed certificates. Engine requests trust the operating system's certificate store, including organization-installed certificates, while keeping certificate verification enabled.

• More accurate project checks. Windows CSP discovery recognizes normalized paths; design hooks load per-app monorepo rules and distinguish existing Stop findings where an edit baseline is available.

Prebuilt impeccable engine binaries (engine-v0.1.4). The launcher, the npm shim and impeccable install download these on first run. Docs: https://impeccable.style

• DeepSeek Harness joins the supported providers. Install the skill into .dsh/skills, with project and global installation support. Thanks to @sheecegardezi for the contribution.

• No external fonts in the picker. Decision pages use system fonts and an inline SVG logo, with a light theme and no Google Fonts requests or bundled font files.

• Setup handles a refused launcher. Guidance now tells the agent to disclose the limitation and use readable references when the host blocks the engine, without claiming checks ran. Claude plugin launcher paths also resolve from the skill directory.

• Install and update DeepSeek Harness skills. Use --providers=dsh for project or global installs, including supported custom DSH_HOME locations and Windows paths.

• A lighter decision picker. System fonts and an inline SVG logo replace external font requests, and the picker adopts the light theme.

Prebuilt impeccable engine binaries (engine-v0.1.3). The launcher, the npm shim and impeccable install download these on first run. Docs: https://impeccable.style

• Windows engine signed by Renaissance Geek, Inc. New installs use engine 0.1.2, with a timestamped Windows publisher signature. Signing verifies the publisher; it does not guarantee that every antivirus will accept the file.

• Clearer download failures. The launcher distinguishes missing or removed downloads from checksum failures, including files removed while entering the cache.

• Claude activation and workflow guidance. Non-interactive Claude sessions can discover the skill, command entry points are clearer, and advice-only requests stay read-only.

• Working reference links. Documentation links to test fixtures resolve from installed skills.

• Verified Windows publisher. The CLI uses engine 0.1.2, whose Windows binary is signed and timestamped as Renaissance Geek, Inc. Both the npm platform package and fallback download use the same signed binary.

Prebuilt impeccable engine binaries (engine-v0.1.2). The launcher, the npm shim and impeccable install download these on first run. Docs: https://impeccable.style

• Signed installs and updates. The CLI checks each downloaded skill bundle against a trusted release-signing key before extracting it. Missing signatures or altered downloads stop the operation without replacing installed skills.

Prebuilt impeccable engine binaries (engine-v0.1.1). The launcher, the npm shim and impeccable install download these on first run. Docs: https://impeccable.style

• --version reports the package version. npx impeccable --version printed the engine's baked-in 3.6.0 after the 4.0.0 release; the shim now answers --version and -v itself from its own package.json, without locating or downloading a binary.

• The detector runs as WebAssembly. The extension now takes a snapshot of the page and evaluates the rules in an offscreen document, so a site's Content Security Policy no longer decides whether the detector runs. Same rules as the CLI and live mode, built from the same source. The new offscreen permission is what makes that possible; nothing else about what the extension can see has changed.

• npx impeccable runs the binary. The package resolves a platform package (@impeccable/cli-<os>-<arch>) installed as an optional dependency, then the user cache, then a checksum-verified download of the pinned engine release. A download without a verifiable checksum is refused rather than run.

• The JavaScript detector API is gone. The package no longer exports a detect function; the same rules are available as a WebAssembly module for hosts that cannot run the binary. Every documented command (detect, ignores, install, update, check, link) keeps its name, flags, and output.

• No runtime to install. The skill ships a small launcher that finds or downloads one static binary for your platform on first run. Windows gets a .cmd twin for shells without sh. Nothing Impeccable does needs Node, npm, or a package install any more.

• The hook stops taxing every edit. On the same corpus and machine, the design hook runs in 10.6 ms where the Node script took 46.9 ms, and a CLI scan of 110 files finishes in 132 ms instead of 282 ms. The URL scan is unchanged, because headless Chrome is the whole cost there.

• One rule engine everywhere. The static and URL scans, the live overlay, the Chrome extension, and the site all execute the same compiled rules, so a fix lands in every surface at once. The rule core is Apache-2.0 like the rest of the project, and a downstream package can add its own rules without forking.

• Behavior is pinned, not re-imagined. The port replays 830 recorded command invocations and 16,058 recorded function calls against the binary and compares byte for byte, with every reviewed exception listed in the repository.

• Live mode hands off reliably. When variants land in one HMR batch, the loader now clears the moment they mount instead of staying painted over them until a refresh, and a discard restores every wrapper of a mapped element.

Prebuilt impeccable engine binaries (engine-v0.1.0). The launcher, the npm shim and impeccable install download these on first run. Docs: https://impeccable.style

• Comps become executable contracts. New phase gates measure structure, typography, material, assets, and responsive fidelity before a build can claim the approved direction is shipped.

• Harness installs line up. Codex reads spec-compliant version metadata, OpenCode gets its slash-command bridge, Veto installs natively, Hermes is documented, and scripts resolve correctly through symlinks, plugin roots, and paths with spaces.

• Live mode survives framework churn. HMR cleanup races no longer tear down active work, encoded script responses stay intact, and the fallback path can never inject raw JSX into a page.

• Direction work stays grounded. Incumbent evidence is explicit, the winning direction absorbs the best rival ideas, PRODUCT.md keeps its schema, and internal direction contracts stay out of production output.

• Detection gets quieter and truer. Flat type hierarchies, Roboto inside system stacks, and radius variables stop producing false alarms, while live waivers and ignore scopes apply to the surfaces that actually earned them.

• Cleanup means cleanup. Hook reset removes installed manifest entries, critique snapshots close reliably, and review artifacts stay out of source-control suggestions.

• The accuracy work, bundled. Rebuilds the engine with this round's detector fixes: comments are stripped before matching, oklch parses in the contrast checks, color-mix() hexes stop tripping gradient contrast, and dashed single-direction rules no longer read as grid backgrounds. The same 59 rules, quieter. Chrome and Firefox.

• Root-relative stylesheets resolve. A page linking /styles.css was judged without its CSS in static scans; those links now resolve against the scan root, and .. escapes are refused with a warning.

• Comments stop matching. Markup and stylesheet comments are stripped before the regex matchers run, including Astro fences, preprocessor line comments, and script strings, so commented-out code cannot raise findings.

• Color parsing catches up. oklch reads correctly in the contrast checks, and a hex tucked inside color-mix() no longer trips gradient contrast.

• Grid backgrounds calm down. Dashed single-direction rules stop reading as grid backgrounds.

• Monorepos resolve the right design system. DESIGN.md is inherited only from a root that actually owns the path, nested workspace packages own their own surfaces, and pnpm workspace globs with inline comments parse.

• Installs repair cleanly. Claude subagents install correctly, home-scoped agents refresh when stale, Grok hooks point at the global skill path, and Windows hook migration stops duplicating entries.

• Faster static scans. closest() selectors compile once per document instead of once per element.

• Monorepos find the right DESIGN.md. Nested workspace packages own their own surfaces, an explicit projectRoots wins over guessing, and a parent's design system applies only when that root actually owns the path.

• The design hook works on Grok Build again. Installs pointed project hooks at a path that broke on update, and Grok's camelCase payloads read as empty scans. Both fixed, and a clean scan now clears the finding cache instead of nagging.

• Codex hears the block. The Stop hook emits the decision shape Codex expects, so the design gate actually gates.

• Fewer detector false alarms. Dashed single-direction rules stop reading as grid backgrounds, comments are stripped before pattern matching, oklch parses in the contrast checks, and a hex tucked inside color-mix() no longer trips gradient contrast.

• Root-relative stylesheets get scanned. A page linking /styles.css used to be judged without its CSS by static detection; those links now resolve against the scan root, and .. escapes are refused with a warning.

• Installs repair cleanly. Claude subagents install correctly again, home-scoped agents refresh when they go stale, and hook migration on Windows stops duplicating entries.

• Windows setup output stops truncating. The context helper drains stdout and closes its sockets before exiting, so directives no longer vanish mid-boot.

• Live mode housekeeping. The preview server refuses symlinks that lead outside your workspace, page-controlled fields are stripped before they reach the agent, and the direction page no longer hangs after a re-roll.

• Comps keep their ground. Ground-color drift between the approved comp and the shipped page is caught on any palette now, not just cream, and the code-led fallback is deterministic.

• The review no longer passes on bad screenshots. Broken or missing captures get retaken and the review runs again on real evidence.

• Pushing back works. Show a finished build a screenshot of what looks wrong and the whole review reruns against it.

• No more fake cutouts. Circle masks pretending a photo was cut out are refused in favor of real cut-out assets.

• The quieter detector, in your browser. Ships the engine that measures real gradient and image-backed grounds instead of assuming white, accounts for elements hidden behind what sits above them, and stops flagging quoted JSX transition values and documented shadow tokens. The same 59 rules, with materially fewer false positives. Chrome and Firefox.

• Contrast findings stop assuming white. Text over a gradient, over an image, or under something else was scored against an assumed white ground, which manufactured low-contrast findings on perfectly legible pages. The engine now measures the real gradient body ground, accounts for image-backed text and for elements occluded by what sits above them, and declines to guess at all when a background genuinely cannot be read.

• Waivers you can scope. data-impeccable-ignore silences the element that carries it rather than a whole rule across the file, and ignore-file honors the scope flags you pass it.

• Two more providers. Hermes Agent and Google Antigravity install like the rest.

• Fewer false positives elsewhere. Quoted transition values in JSX no longer read as layout transitions, documented sidecar shadow colors are allowed inside shadow contexts, and broken-image findings stop firing on commented-out source.

• Installs and scans that behave. Explicitly selected providers install without --force, the post-install next step points at your agent chat instead of the terminal, Windows installs skip the POSIX hook guard, Blade files turn up in directory scans, and a missing static-HTML parser dependency warns instead of quietly scanning nothing.

• Paths with quotes or spaces stop breaking commands. Four places built shell commands by wrapping values in double quotes, which is not shell quoting. They now quote properly.

• DESIGN.md frontmatter reads correctly. Quote escapes in YAML scalars are unescaped, so a design system carrying quoted values parses instead of losing them.

• The roll argues with itself, in front of you. Every dealt world now carries a verdict, and the direction you are handed has already taken what the losing worlds did better. You choose from a hand that has been fought over.

• What you approve looks like a page. Full-fidelity comps replaced the old sketches, which came back too rough to decide from. Generation costs the same at any fidelity, so the draft quality was buying nothing.

• Steer the next hand instead of re-rolling blind. Safer and bolder aim the roll along the familiar-to-bold axis, and IMPECCABLE'S PICK shows the model's own favourite when the dice chose otherwise.

• The deck reads as a gradient of standing. Contenders, then the category standard, then the demoted row last. Stacked raise callouts became a compact cycler, so the assigned card stopped towering over its neighbours.

• Adding a page keeps the world you already have. Once identity is settled, cards differ in composition rather than character, and each comp anchors on a screenshot of a page you already shipped.

• The board still works with no image generation. A text-only card keeps its full read on the front, and art that fails to load collapses to a field painted from the card's own palette instead of a dark void.

• Verification knows what platform it is on. The comp side of the system was platform-aware while everything that checked the work assumed a browser. The verify-and-review pipeline now has a native leg, so an iOS or Android build is reviewed as an app.

• Polish gathers native evidence. Its classify, triage, and verify steps map per platform instead of asking for browser evidence that a native app cannot produce.

• The detector stops contradicting itself. Web-only checks no longer fire against native surfaces they were never written for.

• Comp-first or code-first is your call now. Comp-first buys bolder composition for time; code-first is leaner and writes the ambition into the contract instead. init asks once, with the trade stated.

• Change your mind mid-round. Every board carries the toggle: flip it and the open cards start generating comps without closing the round, flip back and anything already rendered stays.

• Existing projects never re-run setup. On a project that has recorded nothing, the first flip asks whether to keep it. One machine can differ from the team in .impeccable/config.local.json.

• Windows works. Installs no longer trip the POSIX hook guard, the runtime probe survives cmd.exe metacharacters, the decision page opens in your browser, and a successful roll stops aborting on the way out.

• Plugin subagents actually load. Marketplace installs shipped four subagents that Claude Code silently never loaded, because the generated manifest carried a key that suppressed them.

• Two more harnesses. Hermes Agent and Google Antigravity install and run natively, and pinned skills read correctly on Codex.

• Critique tells you what it found. The report is spoken to you rather than written into a file you never open, and the closing question comes last instead of swallowing the report.

• Live mode reaches the dev hosts it used to refuse. ddev, Valet, and any named host authorize by session token.

• Svelte variants render again. A printer upstream had been turning the type annotation in every generated variant into invalid JavaScript, so nothing mounted.

• The design hook stopped nagging. Agents record confident ignores themselves, waivers scope to the element that earned them, and files outside your project are left alone.

• Copy edits survive the trip. Live mode's copy-edit prompt is bounded so long pages stop overflowing it, and the Claude transport delivers what it was given.

• Motion guidance is back. Reduced-motion direction returned to the animation reference after going missing, and DESIGN.md's Layout and Shapes sections parse again.

• The detector sees whole pages again. Ships the engine that resolves versioned stylesheet links (styles.css?v=3) instead of going blind on them, catches standard-tracked kickers that slipped under the old 1px tracking floor, and retires the single-font rule.

• Documentation stops flagging itself. Fifteen page-level checks used to scan raw source, so prose about CSS, code samples, and comments could trip rules like gradient-text on sites that write about design. Each check is now scoped to what it actually means: real style carriers, class attributes, or rendered text. A changelog documenting a detector rule no longer triggers it, in the CLI and the browser paths both.

• Versioned stylesheets no longer blind the scan. A page linking styles.css?v=3 resolved the query string as part of the file path, so the lookup failed silently and every element-level check ran against unstyled markup: one finding on a page that carries eighteen. Stylesheet hrefs now strip query and hash before resolving.

• The kicker net catches standard tracking. The most common authored kicker, uppercase at 12px with 0.08em letter-spacing, computes to a fraction under the rule's old 1px tracking floor and slipped through. The floor is now proportional to font size, and the exact shape that escaped is pinned in the fixture suite.

• Retired: single-font. One family with weight and size contrast carrying the hierarchy is a legitimate type system, and in practice the rule mostly flagged pages that were doing exactly that. Configs that ignore it will surface as stale via doctor.

• Installs place the Copilot and Cursor agents. Project installs write .github/agents/ and .cursor/agents/; user-level installs go to ~/.copilot/agents/ and ~/.cursor/agents/, with a warning where Copilot's user-level copies would shadow a project's newer ones.

• The finish review grew a spine. It opens with a derived verdict, rebuild, fix, or ship, computed from its fidelity matrix rather than felt, and the build thread must report that word verbatim.

• It reviews the page, not the claims. The reviewer spawns fresh rather than inheriting the build thread's optimism, scores recaptured screenshots only, and re-reads the craft floor so a banned element is a finding even when the comp contains nothing like it.

• The comp survives translation. A photographic hero used to be written down as "silhouette in SVG". The implementation inventory now gates on medium: figures, objects, and lit material are raster whatever the stack, while geometry and motion stay vector.

• Three more refusals on the craft floor. A system display face as a page's display voice, unicode glyphs standing in for an icon system, and hard offset shadows outside a world that is actually neobrutalist.

• Comps are pages, not vignettes. Prompts lead with the surface's real structure, so the model designs the fish market's website instead of painting the fish market.

• The prompt travels with the asset. Generated images carry their own prompt in metadata, so an image moved between machines can still say what it is and why it exists.

• Approval is part of the record. The chosen comp's sidecar carries approved: true, so the pick survives sessions and machines. A build with comps and no recorded pick is a material finding.

• The surface owns its aspect. Native and mobile-first surfaces comp portrait at device viewport, desktop web comps landscape, and the decision board adapts to either.

• The direction can no longer be silently lost. Some build tools strip a component's leading comment, taking the contract with it. It now lives as the first child of the root layout's body, and the built output is checked for the seed key.

• Compositions leave the deal, for now. The surface roll still assigns which of your structures gets built, but the composition challengers are withdrawn until their catalog grows real axes.

• Sharper dice. Staging deals honour approval ratings the way world challengers do, so small per-surface pools stop repeating their weakest option.

• Native subagents on GitHub Copilot and Cursor. All four shipped roles emit in each harness's own custom-agent format from one source, with the reviewer correctly read-only on Cursor.

• The stack is your decision. On a greenfield project, init asks once: plain HTML/CSS, a named framework, or delegated, recorded in PRODUCT.md so later work can prove the choice was offered.

• The decision board survives sandboxes. A sandboxed session's permission error used to read as the server dying, which read as you closing the board. Liveness now leads with the page's own heartbeat.

• The updated detector, in your browser. The extension ships the current rule engine: the new kicker-above-heading ban, the radial-spotlight-glow rule, stylesheet stripe scanning, and the latest false-positive hardening for shadowed form ids, clipped-text gradients, and non-rendered text.

• Kickers are banned. New kicker-above-heading rule flags the first eyebrow label above any heading, replacing the old advisory that waited for three repeats. Breadcrumbs, datelines, card metadata, form labels, and document numbering all stay exempt.

• New rule: radial-spotlight-glow. The soft chromatic glow fading to transparent behind content, a favorite AI default, is now a named finding, distinct from the existing halo rule.

• Stripes hiding in stylesheets. Pseudo-element stripe patterns are now caught in standalone CSS files and style blocks, not just inline styles, and findings carry their source lines.

• Scans skip what they should. Hidden directories and vendored paths are out of the walk, while conventional UI source dirs like .vuepress stay in; scans get faster and quieter at once.

• Fewer false positives. Forms whose id shadows the DOM API no longer crash element checks, background-clip: text gradients stop tripping contrast, and non-rendered text is excluded from tiny-text findings.

• OpenCode installs land where OpenCode looks. Global skill installs write to the config directory OpenCode actually reads, with the legacy location migrated safely.

• The decision page grew up. Every direction card shares one anatomy: thesis, palette, materials, first viewport, honest risk, with the longer read behind a Details flip.

• Sketches stream in while you read. The page serves instantly and each card's sketch lands as it finishes, rendered through one deliberately unfinished shared frame.

• A sketch cannot invent facts. Only the product name and one real headline are legible; every other text region is greeked, so no sketch invents specs, prices, or dates.

• Catalog inspirations stay labeled. They ride picture-in-picture as inspiration and take over the frame on hover, rather than posing as your future design.

• The finish ends on a verdict. Every fix is scored resolved, partial, or unresolved against a same-viewport recapture. Open items earn one more round, and the final table reaches you as it stands.

• The review got eyes for style. Display lettering of a different character fails however well the layout matches, and flat CSS standing in for painted artwork fails regardless of placement.

• Kickers are banned. The eyebrow label above a heading leaves the craft floor entirely. The heading carries its own weight.

• DESIGN.md is written from the built page. A dedicated documenter subagent records what shipped rather than what was intended.

• Sturdier machinery. The concept roll survives output truncation and comment-stripping build pipelines, catalog challengers carry a breadth axis, and a failed decision-page start says why.

• Direction by dice, not by taste. The model no longer picks its own favorite. An outside seed names which of its grounded directions must be taken seriously and deals six challenger worlds beside it, so the same brief stops landing on the same three fonts over a cream background. Every roll prints a key that reproduces it, and a re-roll clears the table rather than rewording what you turned down.

• 188 reviewed worlds, dealt as challengers. These are not templates. A world competes against the directions the model derived from your product and wins only on merit, which is how it behaves in practice: strong cultural material beats the deck, thin categories lose to it. Ratings weight the draw, the category default never enters it, and the pool is served by a public roll API.

• No command to pick. Just say what you want. Impeccable now works out what kind of job it is on its own: a blank slate, a whole new page inside an existing product, a section added to a page that already works, a redesign, or a scoped refinement. Each one gets a different amount of freedom, which is the part that used to go wrong. A redesign treats the old look as evidence and replaces it, rather than polishing what you asked to be rid of. An addition inherits the surrounding page's world and decides only what it actually introduces, rather than quietly restyling your product around a new idea. /impeccable craft is deprecated because of this: describing the surface does the same thing, and it no longer matters whether you knew the command existed.

• Decide the direction in your browser. In an attended session Impeccable opens a decision page: the assigned direction leading, the dealt challengers as alternates with their quality-bar cards, and re-roll plus a one-line steer. It presents one committed direction rather than a ranked menu, because a lineup invites the safest card. You re-roll freely; the agent may only re-roll on named factual grounds, and a direction you pinned always wins.

• See it rendered before it is built. The chosen direction gets drawn as a design-system board and a first-surface mock, then the build is corrected against it. This no longer needs a harness with a native image tool: set OPENAI_API_KEY and the skill renders through gpt-image-2 instead, telling you it bills your own key before the first image.

• The build states its intent, then gets checked against it. Before code, the agent writes a five-block contract into the artifact's opening comment, 150 words at most: thesis, own world, story, first viewport, and form with the seed key. If a block reads like a mood, the direction is not decided yet. The finishing review then audits the render against it promise by promise, in its own agent where the harness allows.

• User-level installs no longer write project-relative hook paths that crash every turn in other projects; hooks are guarded so a missing file exits quietly instead of breaking your session.

• skills update names the install it is about to touch, honors --user and --project, and asks instead of silently picking when both exist.

• The em dash rule is now advisory: reported separately, never counted as a failure, skipped by hooks by default, and it only fires on genuine saturation. It also counts HTML entities, so encoded dashes no longer slip past.

• New rule: undersized-ui-text flags functional text below an 11px floor, even when the size is on the documented ramp. 59 rules total.

• detect resolves DESIGN.md from each scan target's own project, not the directory you ran it from.

• Direction by dice, not by taste. The model no longer picks its own favorite. An outside seed names which of its grounded directions must be taken seriously and deals six challenger worlds beside it, so the same brief stops landing on the same three fonts over a cream background. Every roll prints a key that reproduces it, and a re-roll clears the table rather than rewording what you turned down.

• 188 reviewed worlds, dealt as challengers. These are not templates. A world competes against the directions the model derived from your product and wins only on merit, which is how it behaves in practice: strong cultural material beats the deck, thin categories lose to it. Ratings weight the draw, the category default never enters it, and the pool is served by a public roll API.

• No command to pick. Just say what you want. Impeccable now works out what kind of job it is on its own: a blank slate, a whole new page inside an existing product, a section added to a page that already works, a redesign, or a scoped refinement. Each one gets a different amount of freedom, which is the part that used to go wrong. A redesign treats the old look as evidence and replaces it, rather than polishing what you asked to be rid of. An addition inherits the surrounding page's world and decides only what it actually introduces, rather than quietly restyling your product around a new idea. /impeccable craft is deprecated because of this: describing the surface does the same thing, and it no longer matters whether you knew the command existed.

• Decide the direction in your browser. In an attended session Impeccable opens a decision page: the assigned direction leading, the dealt challengers as alternates with their quality-bar cards, and re-roll plus a one-line steer. It presents one committed direction rather than a ranked menu, because a lineup invites the safest card. You re-roll freely; the agent may only re-roll on named factual grounds, and a direction you pinned always wins.

• See it rendered before it is built. The chosen direction gets drawn as a design-system board and a first-surface mock, then the build is corrected against it. This no longer needs a harness with a native image tool: set OPENAI_API_KEY and the skill renders through gpt-image-2 instead, telling you it bills your own key before the first image.

• The build states its intent, then gets checked against it. Before code, the agent writes a five-block contract into the artifact's opening comment, 150 words at most: thesis, own world, story, first viewport, and form with the seed key. If a block reads like a mood, the direction is not decided yet. The finishing review then audits the render against it promise by promise, in its own agent where the harness allows.

• A dozen new anti-pattern rules. The deterministic set now flags soft radial glow halos and accent spotlights, marquee scrollers, blinking terminal cursors, decorative dot and grid fields, text sitting under an overlay, first-viewport content that overflows its column, and hero art assembled from stock geometric shapes. That brings the count to 58.

• Context roots live in config, not your package manager. Declare where each product's PRODUCT.md and DESIGN.md sit in .impeccable/config.json, so detection and setup work in repos that are not laid out as package workspaces.

• Scope one rule to one file. impeccable ignores can now waive a rule for a single file with a wildcard value, so a domain-appropriate pattern in one component stops being reported without silencing the rule everywhere.

• Nested products honor --target. Scans of a nested app inside a non-monorepo repo now resolve the right context and source, instead of falling back to the repository root.

• Direction by dice, not by taste. The model no longer picks its own favorite. An outside seed names which of its grounded directions must be taken seriously and deals six challenger worlds beside it, so the same brief stops landing on the same three fonts over a cream background. Every roll prints a key that reproduces it, and a re-roll clears the table rather than rewording what you turned down.

• 188 reviewed worlds, dealt as challengers. These are not templates. A world competes against the directions the model derived from your product and wins only on merit, which is how it behaves in practice: strong cultural material beats the deck, thin categories lose to it. Ratings weight the draw, the category default never enters it, and the pool is served by a public roll API.

• No command to pick. Just say what you want. Impeccable now works out what kind of job it is on its own: a blank slate, a whole new page inside an existing product, a section added to a page that already works, a redesign, or a scoped refinement. Each one gets a different amount of freedom, which is the part that used to go wrong. A redesign treats the old look as evidence and replaces it, rather than polishing what you asked to be rid of. An addition inherits the surrounding page's world and decides only what it actually introduces, rather than quietly restyling your product around a new idea. /impeccable craft is deprecated because of this: describing the surface does the same thing, and it no longer matters whether you knew the command existed.

• Decide the direction in your browser. In an attended session Impeccable opens a decision page: the assigned direction leading, the dealt challengers as alternates with their quality-bar cards, and re-roll plus a one-line steer. It presents one committed direction rather than a ranked menu, because a lineup invites the safest card. You re-roll freely; the agent may only re-roll on named factual grounds, and a direction you pinned always wins.

• See it rendered before it is built. The chosen direction gets drawn as a design-system board and a first-surface mock, then the build is corrected against it. This no longer needs a harness with a native image tool: set OPENAI_API_KEY and the skill renders through gpt-image-2 instead, telling you it bills your own key before the first image.

• The build states its intent, then gets checked against it. Before code, the agent writes a five-block contract into the artifact's opening comment, 150 words at most: thesis, own world, story, first viewport, and form with the seed key. If a block reads like a mood, the direction is not decided yet. The finishing review then audits the render against it promise by promise, in its own agent where the harness allows.

• Codex loads the plugin design hook again. The plugin-packaged hook manifest carried a top-level description field that Codex's strict hook parser rejected, so the post-edit design check failed to register. That field is gone from the plugin artifact, and the hook now loads cleanly on Codex while staying identical for Claude Code.

• Decorative grid backgrounds are now a named tell. Impeccable refuses the two-axis CSS grid overlay built from hairline gradient lines and a repeating background-size, the pattern Codex reaches for on almost any empty surface. Actual canvases, maps, blueprints, and measurement tools still get their grid; everything else gets real product structure or a plain surface.

• /impeccable bolder stays inside your design system. When a project has a DESIGN.md, tokens, or established component styles, a bolder pass now makes the existing language more decisive through hierarchy, proportion, density, and copy instead of inventing new colors, gradients, or effects. If the system genuinely cannot express the direction, it names the exact additions and asks before expanding.

• Critique holds its independence on more harnesses. On harnesses other than Claude and Codex, the critique pass now runs in its own sub-agent more often, so the review reads the design with fresh eyes instead of inheriting the editing context that produced it.

• Bundled helpers run under strict-permission harnesses. The skill's bundled Node helpers now execute on harnesses that lock permissions down, so setup and detection work without extra approval prompts.

• Codex hook manifest fixed. Corrected the Codex hook manifest schema so the post-edit design check registers cleanly.