hooks-b7be7d— hook

<p align="center"> <img src="assets/og-image.png" alt="LogicLeap Labs — Make AI output actually good." width="820"> </p>

<h1 align="center">Claude Code plugins</h1>

<p align="center"> Open tooling for shipping AI output that's actually good.<br> By <a href="https://x.com/logicleaplabs">Josh Matthews</a> · <a href="https://logic-leap.co.uk">LogicLeap Ltd</a> </p>

Most AI coding failures aren't capability failures — they're looking failures. The model can spot the blank sidebar item, the dead empty band, the same row rendered seven times… it just doesn't check. These plugins add the forcing functions that make it check.

Install

# add this marketplace once
claude plugin marketplace add logicleap-labs/claude-plugins

# then install any plugin
claude plugin install visual-quality

Restart Claude Code so hooks load. Disable any time with claude plugin disable <name>.

Plugins

visual-quality

A hard quality gate for anything with pixels. Built because Claude kept doing compile → screenshot → "looks good" → done and shipping UI with defects a human catches in two seconds.

• Skill `visual-self-review` — the method. One rule does the work: you don't get to judge a screen until you've transcribed it. Read every element, account for every region, read every list in full → then sweep a 12-class defect taxonomy → performance pass → fix & re-screenshot → hard Definition of Done. Works in Xcode/SwiftUI, iOS/macOS, web, Electron, generated mockups.
• Stop hook — refuses to let a turn end if UI was edited/screenshotted but never reviewed. No-op on non-UI turns, fails open, loop-capped, kill switch (touch .visual-quality-off).
• `/visual-quality:visual-review` and `/visual-quality:visual-qc` — run the review / a full automated QC sweep on demand.
• `visual-reviewer` subagent — a second pair of eyes that didn't write the code.

→ full docs

verify-before-done

Forces evidence before "done" on any code change. Built because "clean compile" and "updated the handler" kept shipping without a test, build, or smoke run.

• Skill `verify-before-done` — pick the smallest proof → run it → record output → sentinel line.
• Stop hook — blocks end-of-turn when code was edited but nothing verified. Fails open, kill switch (touch .verify-before-done-off).
• `/verify-before-done:verify` — on-demand verification checklist.

→ full docs

scope-guard

Keeps an agent in its lane. Built because the most expensive edits are the ones nobody asked for — the "while I'm here" refactor, the reformatted file two directories away, one agent clobbering another's work on a shared tree.

• Skill `scope-guard` — declare the narrowest set of files a task may touch, then decide deliberately (never widen silently) when you hit the edge.
• PreToolUse hook — blocks any Edit/Write outside the declared scope (.scope-guard file, SCOPE_GUARD_PATHS env, or a SCOPE-GUARD: sentinel). Silent no-op until you opt in, fails open, kill switch (touch .scope-guard-off).
• `/scope-guard:scope` — declare scope on demand.

→ full docs

no-stub

Refuses to let a turn end with half-written code. Built because "scaffold the function → leave a # TODO: implement → done" quietly moves the work back to the human, who finds it at runtime instead of in the reply.

• Skill `no-stub` — catch the placeholder reflex, finish the path (the answer is usually already in the repo), and declare genuinely intentional stubs out loud instead of leaving leftovers.
• Stop hook — blocks end-of-turn when code edited this turn still contains stub markers: TODO/FIXME/XXX/HACK, NotImplementedError/todo!()/throw new Error("not implemented"), empty ... bodies, "your code here". Only scans added code, ignores docs, dodges JS spreads and type-hint ellipses, fails open, kill switch (touch .no-stub-off). Override a true intentional stub with NO-STUB: INTENTIONAL — <reason>.
• `/no-stub:no-stub` — on-demand scan-and-finish sweep of your session's edits.

→ full docs

secret-guard

Stops a live secret from ever landing in source. Built because a hardcoded key is a leaked key — the moment it hits a tracked file it gets committed, pushed, and mirrored, and you can't un-publish it.

• Skill `secret-guard` — the method: secrets go in .env (gitignored) and are read at runtime, a placeholder goes in .env.example, and if a key ever touched a file you rotate it.
• PreToolUse hook — scans the new content of every Edit/Write and blocks the write when it carries a live-looking credential into a non-env source file: AWS (AKIA…), GitHub (ghp_…), OpenAI/Anthropic (sk-…/sk-ant-…), Stripe live (sk_live_…/pk_live_…), Google (AIza…), Slack (xox…), -----BEGIN PRIVATE KEY-----, and hardcoded api_key = "…" literals. Allows .env/*.example files, env reads (process.env/os.environ), and placeholders; fails open; kill switch (touch .secret-guard-off). Override one fake-but-shaped fixture with SECRET-GUARD: ALLOW — <reason>.
• `/secret-guard:secret-guard` — on-demand scan of your session's edits for secrets.

→ full docs

no-slop

Refuses to let a turn end with AI-tell "slop" prose. The writing complement to no-stub — built because "write the README → pad it with delve into and a testament to → done" ships copy that loses the reader's trust the moment they spot the tells.

• Skill `no-slop` — find the tell, cut it, keep the plain claim underneath (the rewrite is always shorter), one idea per sentence, no throat-clearing.
• Stop hook — blocks end-of-turn when prose edited this turn (.md/.mdx/.txt/.rst) carries 2+ distinct high-precision AI tells: delve into, it's worth noting that, in today's fast-paced world, navigate the complexities, rich tapestry, a testament to, unlock the full potential, seamlessly integrate, elevate your, furthermore + moreover stacked, em-dash pile-ups. Only scans added prose, ignores code, never fires on bare common words ("leverage"/"robust"), one stray cliché never blocks, fails open, kill switch (touch .no-slop-off). Override deliberate slop (quoting it as an example) with NO-SLOP: INTENTIONAL — <reason>.
• `/no-slop:no-slop` — on-demand scan-and-rewrite sweep of your session's prose.

→ full docs

no-debug

Refuses to let a turn end with leftover debug noise. Built because "add a console.log to check the value → forget it's there → done" ships internals to stdout and tells the next reader the code was never cleaned up.

• Skill `no-debug` — sweep the prints you added while working it out, delete the one-offs, and promote anything you actually want logged to a real logger instead of a stray console.log.
• Stop hook — blocks end-of-turn when code edited this turn still contains high-signal debug markers: console.log/console.debug/console.trace/console.dir/debugger, pdb.set_trace()/breakpoint()/import pdb, binding.pry/binding.irb/byebug, var_dump()/print_r()/dd()/dump()/error_log(), dbg!(), and debug-ish print/fmt.Println/System.out.println lines. Never flags console.error/console.warn or real loggers (logger.info, winston, pino, slog, logging.getLogger), skips commented-out lines, only flags ambiguous prints when the line carries debug content (DEBUG/here/===/an emoji), fails open, kill switch (touch .no-debug-off). Override an intentional CLI print with NO-DEBUG: INTENTIONAL — <reason>.
• `/no-debug:no-debug` — on-demand scan-and-strip sweep of your session's edits.

→ full docs

no-swallow

Refuses to let a turn end with a silently-swallowed error. Built because "wrap it in a try so it stops crashing → leave the catch empty → done" deletes the evidence of a failure that still happened, leaving the next person no log, no stack trace, no signal.

• Skill `no-swallow` — find every handler you added, then pick one of four real outcomes: handle the error, log it, re-raise it, or return a real fallback. An empty pass/{} is none of those.
• Stop hook — blocks end-of-turn when code edited this turn contains a caught error whose body does nothing: Python except: pass / except X: pass / multi-line except bodies that are only pass/.../continue/break; JS/TS empty catch (e) {} / catch {} and trivial .catch(() => {}) / .catch(() => null) / .catch(function(){}); empty catch (...) {} in Java/Kotlin/C#/C++/Swift; and the clearly-empty Go if err != nil {}. Never flags a handler that logs (logger.error/console.error), re-raises (raise/throw), returns, sets error state (setError(e)), or calls a real handler (.catch(handleError)); Swift try? and fallback imports pass. Heuristic, so it fails open on any ambiguity, kill switch (touch .no-swallow-off). Override a deliberate best-effort swallow with NO-SWALLOW: INTENTIONAL — <reason>.
• `/no-swallow:no-swallow` — on-demand scan-and-fix sweep of your session's edits.

→ full docs

What this is

The start of a longer-term project: open-sourcing the tools and techniques behind how I actually use AI to build production software. More plugins, comparisons, and write-ups coming — follow along on X (and a YouTube channel soon).

License

MIT © Josh Matthews / LogicLeap Ltd. See LICENSE.