kitchen-sink

Everything but the kitchen sink

A grab bag of skills to automate the boring parts out of your hair and into your robot.

Requirements

GitHub CLI: Several skills and commands use gh to interact with GitHub issues and pull requests. Install it and authenticate with gh auth login.

Superpowers plugin: Most skills and commands rely on obra/superpowers for workflows like brainstorming, verification, and subagent-driven development. Install it first:

claude plugin marketplace add obra/superpowers

Installation

Add from the Claude Code plugin marketplace:

claude plugin marketplace add oalders/kitchen-sink &&
  claude plugin install kitchen-sink

Contents

Commands

Code review

Command	Description
/agent-instructions-review	Reviews changes to agent-instruction files (CLAUDE.md, AGENTS.md, .cursor/rules, copilot-instructions, .claude/**, plugin commands/skills/agents) for accuracy, placement, duplication, cost, removability, and instruction quality
/code-review-intense-flow	Heavyweight fan-out that dispatches every applicable specialist reviewer (security, frontend, seo, geo, playwright, design-handoff, agent-instructions, test-value, embedded-script) in parallel and aggregates the findings
/design-handoff-review	Reviews a design-handoff implementation for character-level text drift and orphaned input bindings against the design source
/embedded-script-review	Flags shell and other logic embedded in CI/tool config (GitHub Actions run: blocks, package.json scripts, TOML command strings) that belongs in a standalone, testable script
/frontend-review	Frontend expert review catching accessibility gaps, responsive design issues, and CSS anti-patterns
/geo-review	Generative Engine Optimization review—two modes: per-PR extraction checks (diff) and cross-page entity consistency (site) for LLM-citation visibility
/playwright-review	Playwright test review enforcing ARIA labels, detecting UI layout issues, and optimizing performance
/request-review	Get code review feedback without permission prompts stalling the workflow
/responsive-audit	Drives Playwright MCP to load live URLs at 320/375/768/1280 and report responsive breakage (overflow, occluded controls, tiny touch targets/text) static review can't see
/security-review	OWASP-based security review catching session fixation, PII logging, and timing attacks
/seo-review	SEO review for meta tags, structured data, Open Graph, headings, and crawlability
/test-value-review	Flags tests that pad the count without proving behavior—config files parsed and asserted against themselves, regex-on-HTML, source-scraping, mock-only assertions

GitHub issues & PRs

Command	Description
/address-gh-review	A robot that does the urgent repairs now and books appointments for the rest
/codex-review	Shows or switches this repo's Codex review mode (on = local loop plus a mandatory @codex review bot gate, local, off, default) via git config --local kitchen-sink.codexReview
/review-config	Walks you through this repo's Codex bot wait, timeout action and review round caps, and writes them with git config --local
/break-into-gh-issues	Maybe split big issues into smaller ones—so you get a code review and not an intervention
/new-gh-issue	Researches a problem and offers to file it as an issue—writing it down, not fixing it
/draft-pr	Creates a draft PR that closes the GitHub issue inferred from your branch name
/fix-gh-issue	Point your robot at a GitHub issue and let it start beeping and booping
/fix-gh-issues	Point your robot at the whole backlog, go to bed, and wake up to merged PRs
/shepherd-pr	Carries one of your own PRs (or a finished fix-NNN branch, via /fix-gh-issue) to merged without asking: rebases it when it conflicts or is behind, checks the Codex gate, marks it ready, enables auto-merge, watches the checks and the merge queue, and repairs failed checks or Codex findings
/shepherd-prs	Runs /shepherd-pr over each of your own open PRs in this repo, one at a time, and reports a one-line status per PR
/triage-backlog	Grooms open GitHub issues—finds completed work, updates task lists, and suggests labels, one issue at a time

Repo & CI maintenance

Command	Description
/audit-claude-md	Audit CLAUDE.md files for token efficiency, clarity, and accuracy against actual codebase
/codebase-health	Systematic health check optimizing codebase for AI consumption—dead code, token waste, and discoverability
/fix-linter-warnings	Linter busywork in bite-sized chunks—your robot's idea of a good time, not yours
/git-rebase	Rebase without the cruel and unusual punishment of solving your own merge conflicts
/poll-ci	Polls the current branch's CI run and reports pass/fail/in-progress (generic gh fallback for /monitor-ci)

Skills

General

Skill	Description
adversarial-review	Two subagents compete under a scoped incentive to find real, reproducible defects—enforces scope discipline so findings count doesn't inflate across rounds
codex-review-loop	Runs OpenAI Codex locally on the branch and loops fix → re-review until P0–P2 are gone, then (in github mode) gates readiness on the Codex GitHub bot and resolves its threads
code-review-flow	Streamlined code review workflow that avoids permission prompts
fix-gh-issue-autonomous	Unattended-run rules for /fix-gh-issue autonomous; /fix-gh-issue loads it on demand
fix-gh-issue-design-review	How /fix-gh-issue reviews its design doc or pre-flight block (step 5.5); loaded on demand
shepherd-pr-repair	How /shepherd-pr rebases a conflicting or behind PR, or fixes a failed check or Codex findings, reviews the result and pushes it; loaded on demand
implement-design-handoff	Wires a design-system / component-export handoff into an app's real templates and CSS faithfully, forcing a property-by-property visual-parity check and protecting untouched surfaces
over-engineer-no-more	Prevents your robot from building a spaceship when you asked for a bicycle
stacking-prs	Decides which PRs to stack and which to open against the default branch, links stacks with gh stack, and tells you only the merge order

Perl & repo tuning

Skill	Description
perl-review	Flags Perl code that strays from your project standards — quoting, core-module use, URL building, test hygiene — reading a living rules doc you edit freely
tune-dependabot-config	Groups minor/patch Dependabot updates per ecosystem and adds a 7-day cooldown; optionally auto-merges minor/patch PRs
tune-perl-ci	Seven idempotent transforms to modernize Dist::Zilla-style Perl GitHub Actions CI
tune-precious	Migrates a Perl repo from Code::TidyAll to precious (or sets up precious from scratch) — config, .perltidyrc, dist.ini, CI lint job
working-with-dist-zilla	Stops your robot from committing 100 lines of regenerated META.json and other dzil faceplants

Hooks

Hooks live in hooks/hooks.json at the plugin root.

Hook	Description
suggest-review-after-commit	Smart PostToolUse hook that runs after a successful git commit. On fix-NNN branches it points only at /code-review-intense-flow (required by fix-gh-issue before the PR); elsewhere it offers /code-review-intense-flow first as the default, plus the relevant specialists (/frontend-review, /playwright-review, /security-review, /agent-instructions-review, or /request-review) based on file types and patterns
require-review-before-pr	On fix-NNN branches, denies gh pr create / gh pr ready until /code-review-intense-flow has been invoked on the current HEAD SHA or on an identical branch diff, so clean rebases pass (recorded via PostToolUse Skill and UserPromptSubmit). Fail-open; user-only bypass via KITCHEN_SINK_ALLOW_UNREVIEWED_PR=1

Commands Overview

Code review

/agent-instructions-review

Focused review for changes to agent-instruction files—the docs an AI agent loads into context on every session or invocation (CLAUDE.md, AGENTS.md, .cursor/rules/**, .cursorrules, .github/copilot-instructions.md, .claude/**/*.md, and commands//skills//agents/ markdown in a Claude Code plugin, i.e. next to .claude-plugin/plugin.json):

• Accuracy—verifies every factual claim (paths, flags, commands, behavior) against the code at HEAD rather than trusting the text
• Placement—mechanism/rationale belong in code comments; instruction files hold the cross-cutting rule plus a pointer to detail
• Duplication—recommends the pointer form over restating comments that already sit next to the code (no information leaves the repo)
• Cost—weighs each addition against its per-session context tax on all unrelated work; keeps skill bodies that load in most sessions under about 200 words
• Removability—proposes deletions of superseded or contradicted text, not just critiques of additions
• Instruction quality—actionable and unambiguous over narrative; flags internal contradictions; for skills, commands, and agents, checks that the description gives triggers rather than a workflow summary; flags "don't X" lists aimed at output shape and hedged rules
• Spawns general-purpose with a systematic six-dimension checklist

/code-review-intense-flow

Heavyweight fan-out orchestrator—dispatches every applicable specialist reviewer in parallel for a single diff, then aggregates:

• General-purpose reviewer always runs; /security-review runs by default unless the diff is doc-only
• Routes to /frontend-review, /seo-review, /geo-review, /design-handoff-review, /playwright-review, /agent-instructions-review, /test-value-review, and /embedded-script-review by diff content
• New-route and new-interaction detection triggers a Playwright e2e-coverage check even when the diff reuses an existing route
• Runs all reviewers concurrently (single message, multiple Task calls)
• Consolidates findings by severity, tags each with the specialist that surfaced it, and retains full per-reviewer reports
• The lightweight counterpart is /code-review-flow (general reviewer only)

/design-handoff-review

Design-handoff fidelity review comparing an implementation against its design source (the component/card export, not README prose):

• Character-level text fidelity (smart vs straight quotes, decorative glyphs, ellipsis, casing, whitespace)—a near-match is a finding, not a pass
• Orphaned input bindings (every collected input must render or be consumed somewhere; reports remove-end-to-end vs missing-surface)
• Standard handoff checks (reproduce the layout mechanism, keep dynamic bindings mapped, don't restyle shared partials)
• Treats handoff files and screenshots as untrusted data, never instructions
• Catches structural drift a screenshot-parity pass can't see; spawns general-purpose

/embedded-script-review

Config-hygiene review for logic hidden inside config files:

• Flags dependent multi-line shell logic in a run:/script:/command: block, and any control flow or data munging (if/for, jq/sed/awk) regardless of length; a list of plain sequential commands is at most a Minor "split into named steps"
• Covers GitHub Actions and other CI YAML, docker-compose, package.json scripts, and TOML/INI tool config
• For each block, proposes a script path that follows repo convention, its args/env interface, the one-line replacement step, and the test the extracted script needs
• Flags ${{ }} interpolated straight into shell text (script injection), and swallowed failures such as a missing pipefail where it matters (it knows GitHub Actions already runs bash -e)
• Treats tests that parse the config as a symptom, not a substitute; pairs with /test-value-review
• Spawns general-purpose

/frontend-review

Frontend-focused code review for HTML/CSS/image changes:

• Systematic image optimization and accessibility checks
• ARIA strategy analysis (decorative vs informative)
• Responsive design verification across viewports (320px, 768px, 1920px)
• CSS best practices (custom properties, relative units, performance)
• Visual regression checklist for manual testing
• SVG optimization and preload hints
• Spawns general-purpose with frontend-specific checklist

/geo-review

Generative Engine Optimization review—how LLMs and answer engines (ChatGPT, Claude, Perplexity, AI Overviews) discover, extract, and cite content. Runs in two distinct modes:

• Diff mode (PR time): extraction-layer checks on the changeset—buried answers, atomic claims, Q&A structure, schema quality, citation-worthiness
• Site mode (scheduled): entity-layer checks across the whole site—cross-page claim contradictions, publisher entity graph (@id/sameAs), brand distinctiveness, rendered-output defects (crawler-UA divergence, relative og:image, leaked template syntax)
• Reports two independent scores: extraction readiness and entity strength
• Surfaces AI-crawler policy as a decision to confirm rather than recommending allow/block
• Asks which mode to run when it's ambiguous; spawns general-purpose

/playwright-review

Specialized review for Playwright E2E tests:

• Enforces ARIA label verification in tests (aria-invalid, aria-describedby, aria-live)
• Identifies UI/layout issues (buttons bumping footer, viewport overflow)
• Detects 7 performance anti-patterns (waitForFunction, sequential fills, networkidle waits)
• Suggests specific optimizations with estimated time savings
• Checks accessibility test coverage (keyboard navigation, focus management)
• Provides performance improvement summary table
• Spawns general-purpose with Playwright-specific checklist

/request-review

Request code review during development (before creating PR):

• Gets git SHAs from conversation context (no permission prompts)
• Fetches issue details for fix-* branches
• Invokes general-purpose with structured template
• Returns categorized feedback (Critical/Important/Minor)
• Allows unattended execution - can leave window while review runs

/responsive-audit

Live-discovery responsive audit that drives the Playwright MCP against already-serving URLs:

• Sweeps each URL at four viewport widths (320px, 375px, 768px, 1280px)
• Detects horizontal overflow (scrollWidth > clientWidth) and names the offending selectors
• Flags interactive controls that are occluded (via elementFromPoint, not raw box overlap)
• Flags sub-44×44px standalone touch targets and sub-12px text at mobile widths
• Captures a full-page screenshot per viewport for what measurements can't express
• Discovery/reporting only — no dev server, no test files, no source edits; requires a working Playwright MCP
• Drives Playwright MCP tools directly rather than spawning general-purpose (deliberate departure)

/security-review

OWASP-based systematic security review:

• Authentication & session management (session fixation, regeneration)
• Authorization & access control (vertical/horizontal privilege escalation)
• Input validation & injection (SQL, XSS, command injection)
• Sensitive data exposure (PII logging, cleartext transmission)
• Security misconfiguration (CSRF, CORS, security headers)
• Business logic flaws (race conditions, timing attacks)
• LLM/AI integration (prompt injection, insecure output handling, tool-call abuse) — gated to diffs that touch model calls
• Uses Opus model for comprehensive security analysis
• Spawns general-purpose with OWASP Top 10 checklist

/seo-review

SEO-focused review for changes affecting search visibility and social sharing:

• Meta tags (unique titles, descriptions, robots directives)
• Open Graph and Twitter Card completeness (og:image dimensions, canonical og:url)
• Heading hierarchy (single <h1>, logical h1→h6 order)
• URL structure, internal linking, and canonical URLs
• Structured data (JSON-LD schema type, required properties, valid JSON)
• Crawlability (sitemap entries, robots.txt, server-rendered content)
• Spawns general-purpose with a systematic SEO checklist
• Run alongside /geo-review for full search + answer-engine coverage

/test-value-review

Test-quality review that judges what each test proves, not how many tests there are:

• Applies two litmus questions to every new or changed test: would it fail if the behavior broke, and would it stay green through a behavior-preserving refactor?
• Flags config-mirror tests that parse YAML/JSON/TOML and assert the file's own keys and values, but exempts cross-file policy invariants such as SHA-pinned actions and required timeouts
• Flags HTML asserted with regex or substring matches, and recommends a parser (Mojo::DOM, Test::Mojo, lxml, DOM Testing Library), a driver (Test::WWW::Mechanize, Playwright), or a validator (HTML::Lint, vnu)
• Flags source-scraping tests, tests that only check their own mocks, and assertion-free tests presented as coverage
• Marks it Critical when a PR claims coverage it doesn't have, and recommends deleting a test when nothing better is warranted
• Spawns general-purpose

GitHub issues & PRs

/address-gh-review

Addresses PR code review feedback:

• Fetches comments from the current branch's PR
• Evaluates each suggestion critically (doesn't blindly implement)
• Fixes immediate issues with atomic commits
• Creates GitHub issues for deferred items
• Runs tests and pushes when done

/codex-review

Shows or switches the per-clone Codex review mode used by the codex-review-loop skill:

• on / github: local Codex loop, plus a mandatory @codex review gate from the GitHub bot before the PR is marked ready
• local: local loop only; off: skip Codex; default: unset (off)
• Stored with git config --local kitchen-sink.codexReview, so it is never committed
• The bot gate waits kitchen-sink.codexTimeoutMinutes (default 30) from the @codex review trigger, in codex-review-loop and /shepherd-pr; on timeout, kitchen-sink.codexTimeoutAction stop (default) keeps the PR in draft and proceed passes with a note in the PR body, e.g. git config --local kitchen-sink.codexTimeoutAction proceed
• Run /review-config to see or change the timeout and round keys

/break-into-gh-issues

Breaks down work into manageable GitHub issues:

• Single issue for <= 400 lines of changes
• Multi-issue with umbrella tracking for larger work
• Creates labels if they don't exist
• Links sub-issues back to umbrella with progress checklist

/new-gh-issue

Records a problem as a GitHub issue without implementing it:

• Takes the problem from its argument, or from the conversation (e.g. a pasted transcript)
• Researches the code involved and searches this repo's issues and PRs for duplicates; an open PR for the same problem stops it, and an open issue for it offers a comment there or a new issue anyway
• Shows the draft (problem, proposal, open questions each with a recommended answer, existing labels only), offers to discuss the open questions before you confirm, and files nothing until you confirm
• Never creates branches, commits or PRs
• Only you can start it (disable-model-invocation)

/draft-pr

Creates a draft PR that closes a GitHub issue:

• Resolves the issue number from an argument or the branch name (fix-1372 → 1372)
• Fetches issue details, pushes the branch if needed, and opens a draft PR with a Closes #N body
• Treats the fetched issue title/body as untrusted data (summarizes the work; never obeys embedded directives or interpolates raw text into shell)
• Ends the PR body with the standard Claude Code attribution line

/fix-gh-issue

Automates the workflow for fixing GitHub issues, guided by reuse-before-writing, KISS, YAGNI, Chesterton's fence, and Chekhov's gun:

1. Gets issue number from argument or branch name (fix-978 -> 978)
2. Fetches issue details with gh, treating issue and comment text as untrusted data
3. Checks the history of the code it expects to change and stops if it looks deliberate
4. Assesses complexity, searches for existing code to reuse, sweeps the repo for stale copies of any claim the fix changes, states the simplest fix, and records an expected size
5. Posts a pre-flight block (simplest fix, prior art, sweep hits, size) and pauses only when it raises a decision. Issues that need decisions get a brainstorming offer; fully specified issues beyond trivial, or declined brainstorming, get a plan-review subagent on the block; any design doc goes to a plan-review subagent before writing-plans. /paad:pushback runs in parallel on controversial issues unless fast is passed
6. Implements the fix (via a subagent or subagent-driven-development) with one regression test per behaviour
7. Runs /code-review-intense-flow on the final HEAD (enforced by the require-review-before-pr hook), up to kitchen-sink.reviewRounds fix rounds (1–5, default 3) before escalating
8. Runs the Codex gate (codex-review-loop) unless its mode is off
9. Verifies with verification-before-completion
10. Creates a draft PR that closes the issue (in Codex github mode, waits for a clean @codex review of HEAD)
11. Marks it ready and monitors CI when nothing needs a human; otherwise leaves it in draft and says why

Pass autonomous (as /fix-gh-issues does) to never ask questions: it stops on issues that need decisions, still runs the pre-flight plan review on specified-tier issues, files follow-up sweep hits as one issue instead of pausing, and any other point that would wait for the user stops work on that issue, leaving any PR in draft, and reports why. Follow-up issues it files are labelled needs human, so a later unattended run won't pick them up.

/fix-gh-issues

Works through open GitHub issues one at a time, unattended, so you can start it and walk away:

• Asks everything up front: whether to merge (recommended off on non-private repos, and off when the repo has no PR CI unless you override), the PR cap (default 15, or max=N), and, on non-private repos, which issues are eligible (label-gated, collaborators only, or listed numbers)
• Snapshots the queue once (skipping in progress, needs human, issues with an open PR, and issues with hidden characters, HTML comments, or very long bodies), shows it with body excerpts, flags issues that probably aren't code work (umbrella, epic, or tracking labels, checklist-only bodies, human tasks) so you can drop them, and confirms before starting
• Per issue: hands it to a human if its title or body changed since you confirmed, labels it in progress, creates a worktree under $TMPDIR from the fresh default branch, and runs /fix-gh-issue <N> autonomous
• Merges only its own PR for the issue (same repo, default base, head matching the worktree), marked ready by fix-gh-issue, with green CI (every test workflow you pick up front must pass, not just a bot check), closing only its own issue, every file under directories you approve, no protected paths (dotfiles, agent instructions, build files, dependency manifests), and no symlinks or mode changes; never with --admin, and it confirms the merge landed. Anything else is labelled needs human
• Checks up front whether pushed branches could reach Actions secrets, a write token, OIDC, or self-hosted runners (on non-private repos it recommends stopping), stops after three gh failures in a row, keeps a ledger in $TMPDIR (a read-only, checksummed policy file plus a run log) so long runs survive context compaction, leaves worktrees in place, and ends with a report: merged, needs a human (with reasons), skipped, not reached

/shepherd-pr

Carries one of your own open PRs (same repo, default base) to merged; with no number, the current branch's PR, or, on a committed fix-NNN branch with no PR, a draft it has /fix-gh-issue open. Running it is your consent: it asks no questions, and where it needs you it reports and stops. Each run reads the PR and picks up where it stands, so re-running is safe:

• When the PR conflicts with or is behind the base, rebases it first, once per run: stops (aborting the rebase) on a sensitive or unsure conflict, regenerates a conflicted lockfile, stops on failing tests, reviews only if the PR diff changed, and force-pushes with a lease pinned to the head it read
• In Codex github mode, gates on a clean bot review of the head commit: without one it posts (or reuses) your own @codex review trigger for that head and waits the configured bot wait, then honours codexTimeoutAction
• Shows the PR's merge state, review decision and changed files (flagging sensitive ones), then marks a draft ready (even if a pull_request_target workflow would then run) and enables auto-merge
• Enables auto-merge with --match-head-commit (enqueues with a merge queue), never merges directly, then watches gh pr checks; on a failed check or a new head commit it turns auto-merge off and stops, and its report gives you /shepherd-pr <n> to re-run (for a failing check it couldn't repair, with the head unchanged, the gh run rerun commands to try first)
• With every check green, keeps watching the merge queue (or auto-merge) until the PR merges or is ejected, reporting an ejection's reason and the finished checks that didn't succeed; the deadline follows GitHub's merge-time estimate, with fixed fallbacks
• On a failed check or Codex findings, makes one repair per run: fixes in your PR checkout, runs the /fix-gh-issue reviews, and pushes; then starts over, so auto-merge is only re-enabled on a head that passed the gate
• A repair doesn't push if the reviews didn't finish clean, a Codex finding was declined (only you can confirm a decline), or the fix touches a sensitive file the PR didn't already change
• With no number on a clean, committed fix-NNN branch that has no PR, hands off to /fix-gh-issue for its reviews, Codex gate, verification and draft PR, then carries on with that PR; if /fix-gh-issue would keep it draft, it reports why and stops, and re-running /shepherd-pr <n> marks it ready despite them
• If the PR was last removed from the merge queue on the current head, shows why and stops rather than re-enqueue the same head
• On a PR with auto-merge already on, it shows who enabled it and keeps it
• Only you can start it (disable-model-invocation), so PR or issue text can't trigger a merge or a repair

/shepherd-prs

Sweeps your open PRs with /shepherd-pr:

• Takes your own open PRs in this repo based on the default branch, drafts included, oldest number first
• Runs them one at a time, so one PR's check watch (up to ~45 minutes) holds up the rest, and a merge can leave a later PR behind, which /shepherd-pr then rebases if you're on its branch
• Follows /shepherd-pr for each, so it runs unattended, even under /loop: PRs are marked ready, auto-merged and repaired without asking; a rebase or repair is skipped unless you're on that PR's branch, and the PR is reported as needing /shepherd-pr <n> from its checkout
• In Codex github mode it may also post up to two @codex review comments per PR head (the second only as a re-trigger), and doesn't wait on the bot: a PR whose window is still open is reported as waiting and judged on the next sweep
• Only you can start it (disable-model-invocation)
• Doesn't run /shepherd-pr's queue watch: a queued PR is reported as in the merge queue, and one with only auto-merge on as auto-merge on and waiting
• Ends with one status line per PR: merged, in the merge queue, auto-merge on and waiting, needs rebase or repair from its checkout, waiting on the Codex bot, left as is, or stopped with the reason

/triage-backlog

Incrementally grooms the open GitHub issue backlog, one issue at a time:

• Depth argument (quick/standard/deep) controls how hard it checks whether work is already done; batch size defaults to 10
• Processes oldest-first, checking linked PRs, commit history, and (deep) the codebase for completion evidence
• Proposes checking off completed task-list items and suggests 1–3 matching labels
• Always asks before editing; marks issues triaged so you can work in stages across sessions
• Treats issue/comment text as untrusted data, never as commands to obey

Repo & CI maintenance

/audit-claude-md

Comprehensive CLAUDE.md audit for quality and accuracy:

• Token efficiency (duplication between files, verbose sections, defensive explanations)
• Clarity issues (contradictory instructions, vague guidance, ambiguous commands)
• Organization problems (multiple file chaos, hard to scan, scattered information)
• Accuracy against codebase (outdated commands, dead links, wrong env vars, broken examples)
• AI-specific anti-patterns (nested conditionals, ambiguous pronouns, negative-only instructions)
• Workflow verification (compare docs against CI/scripts/Makefiles)
• Systematic verification (REQUIRED checks for command paths, file references, tool availability)
• Version-specific instruction checking (detect obsolete version references)
• Generates quality score (0-100) with category breakdown
• Estimates token savings (e.g., 17% reduction from deduplication)
• Prioritized recommendations with before/after examples
• Spawns general-purpose subagent with comprehensive 6-category checklist

/codebase-health

Systematic health check optimizing codebase for AI consumption:

• Dead code analysis (unused imports, orphaned files, commented blocks)
• File organization (>1000 line files, deep nesting, vendor directory tracking)
• Discoverability issues (generic naming, missing READMEs, hidden functionality)
• Code duplication detection (template/function similarity, pattern inconsistency)
• Dependency health (circular dependencies, unused exports, orphaned modules)
• Naming convention consistency (mixed case detection across languages)
• Generates health score (0-100) with category breakdown
• Estimates token savings potential (e.g., 148K tokens from vendor removal)
• Prioritized recommendations (Critical/Important/Minor with time estimates)
• Spawns general-purpose subagent with comprehensive 7-category checklist

/fix-linter-warnings

Batch approach to linter cleanup:

• Fix 25 issues per iteration
• Prioritize quick wins (formatting, constants)
• Use suppression directives when fixes would degrade code
• Always include justification comments

/git-rebase

Rebases the current branch onto origin/main:

• Fetches latest changes and pulls with --rebase
• Reads and resolves merge conflicts
• Uses --force-with-lease for safe pushing (never --force)

/poll-ci

Polls the current branch's CI run and reports back when it finishes:

• Generic gh-based fallback for when a project-specific /monitor-ci isn't present
• Finds the latest run for the branch, warns if HEAD hasn't triggered a run yet
• Prefers gh run watch --exit-status, falling back to manual polling (~20s interval, ~30 min cap)
• Reports pass/fail/needs-attention/in-progress, surfacing failing jobs and offering --log-failed

Skills Overview

General

adversarial-review

Two subagents review the same work in parallel, competing under an incentive that rewards in-scope defects with working repros and penalizes nit-padding and feature-proposal drift:

• Hard-gates on a scope preamble (invariants, threat model, out-of-scope list)—aborts rather than improvising defaults
• Round-number gate warns at round 3+ that fixes create new surface, and to simplify the patch instead of adding rounds
• Pastes a verbatim reviewer brief with anti-splitting and test-falsification rules
• Mandatory triage step classifies findings in-scope / out-of-scope / wontfix before anything reaches you
• Presents actionable findings, hypotheses checked clean, rejected out-of-scope items, and tests flagged as theatre

codex-review-loop

Catches what Claude's self-review misses, without spending CI minutes on it:

• Runs codex exec review --base origin/<default> locally and classifies findings; P0–P2 block, P3 is advisory
• Triage → fix → self-review → re-run, capped at kitchen-sink.codexRounds rounds (1–5, default 3); declined findings need evidence and the user's confirmation
• In github mode: requests @codex review on the draft PR and waits for the bot's review of HEAD, timed from the trigger (a timeout stops the gate unless the user set codexTimeoutAction to proceed), then replies on and resolves the threads it fixed
• codex_loop.py helper (mode, local-review, gh-wait, gh-threads, gh-resolve), unit-tested in test_codex_loop.py
• Called by /fix-gh-issue (step 8.5 and the step 10 bot gate)

code-review-flow

Wrapper around superpowers:requesting-code-review that eliminates permission prompts during code reviews:

• Gets git SHAs from conversation context or separate git commands (not compound commands)
• Invokes general-purpose subagent with proper template
• Allows code reviews to run unattended without blocking on permission prompts

Benefits:

• No interruptions during code review workflow
• Can leave the window while review runs
• Uses information already in context when available

implement-design-handoff

Wires a design-system / component-export handoff into an app's real templates and CSS, ordered so the cheap mistakes die first:

• Treats the rendered card as the source of truth for appearance (not the README); extracts exact tokens/px values rather than eyeballing
• Reads the component source, not just the card, and reproduces the design's layout mechanism instead of reinventing one
• Keeps content dynamic—maps the card's sample text/numbers/hrefs back to existing template bindings; flags design-implied data the template lacks rather than fabricating it
• Scopes shared partials safely (grep consumers, per-page flag + section-scoped CSS) so restyling one page can't leak to others
• Delegates the read-heavy investigation to a subagent that returns conclusions, not file dumps
• Enforces a visual-parity gate: read the rendered screenshots yourself, property by property, at desktop and ~390px, across every state—including the most-skipped menu-open view
• Catches char-level text drift and orphaned input bindings that pass functional tests and screenshots yet still miss the design
• Second mode: write a GitHub issue that points a later implementing agent at a design (by path, not by copying files)

over-engineer-no-more

Prevents over-engineering by evaluating whether a task needs heavyweight processes:

• Checks indicators: adding constants? < 100 lines? < 3 files?
• Announces decision with reasoning
• Routes to direct implementation or subagent workflow

stacking-prs

Stacks PRs only when one needs another's unmerged code, so you only have to know the merge order:

• Tries each branch on the default branch first; stacks only if it doesn't apply or the tests fail
• Links stacks by PR number with gh stack link so merging the bottom PR retargets the next one
• Reports which PRs are stacked, in what merge order, and which are independent; never merges
• After a merge, checks the next PR's base and diff, and asks before any gh stack rebase/sync force-push
• Referenced by /fix-gh-issue (step 10) and /draft-pr; needs the gh stack extension and won't install it

Perl & repo tuning

perl-review

Flag-only reviewer that applies the living standards in STANDARDS.md to changed Perl (.pm, .pl, .t) files:

• Reads whatever rules are in STANDARDS.md at runtime—add or change a rule with no edit to the skill
• Reviews the branch's committed changes against the base by default, or named paths when given
• clear rules report as violations; judgment rules report as suggestions the author may have a reason for
• Makes no edits and no commits—you apply the fixes; groups the report by rule with file:line — detail hits
• Dispatches to a general-purpose subagent so the token-heavy read doesn't fill the caller's context

tune-dependabot-config

Groups Dependabot minor/patch updates per ecosystem (majors stay individual) and adds a 7-day cooldown so churning releases settle before a PR opens:

• Idempotent edits to .github/dependabot.yml
• Preserves user-customized schedules, labels, reviewers
• Adds groups: block with update-types: [minor, patch] per ecosystem
• Sets cooldown.default-days: 7 to absorb release-day churn
• Optional, opt-in per repo: a workflow that auto-merges minor/patch Dependabot PRs once required checks pass

tune-perl-ci

Seven idempotent transforms applied to Dist::Zilla-style Perl GitHub Actions workflows under .github/workflows/:

• fail-fast: false on every matrix job
• Extends Linux + macOS matrices through Perl 5.44
• Bumps build + coverage jobs to perldocker/perl-tester:5.44
• Restricts the push: trigger to the default branch
• Adds a workflow-level concurrency: cancel-in-progress block
• Replaces each install-with-cpm/install-with-cpanm step with setup-cpm@v1 + an explicit cpm install run step (version: compat pins cpm for Perls ≤ 5.22)
• Drops pre-5.24 macOS/Windows matrix cells
• Each transform lands as its own commit; re-running is a no-op

tune-precious

Lands precious as the canonical tidy/lint driver for a Perl repo via five idempotent transforms:

• Generates (or refreshes) precious.toml with perltidy, perlvars, omegasort-gitignore, omegasort-stopwords, and optionally perlcritic
• Consolidates the perltidy profile to the hidden .perltidyrc and strips -b
• Deletes Code::TidyAll config (.tidyallrc, tidyall.ini, .tidyall.d/ ignore line)
• Edits dist.ini to drop Test::TidyAll and its prereqs via PluginRemover + [RemovePrereqs]
• Adds a .github/workflows/lint.yml job running precious lint — incrementally (--git-diff-from the PR base) on pull requests, --all on every other event

Handles three modes: migrate (tidyall present), greenfield (no precious yet), tune (precious already configured). Each transform commits separately; re-running on a tuned repo is a no-op.

working-with-dist-zilla

Captures the non-obvious patterns that trip up first-pass Dist::Zilla work:

• Decide PluginRemover vs [RemovePrereqs] (and the -remove vs remove syntax gotcha)
• Revert build artifacts (META.json, Makefile.PL, README.md) in non-release PRs to avoid diff noise
• Phase-scoped re-adds via [Prereqs / DevelopRequires]
• Fix Git::Contributors warnings with .mailmap
• Verify with dzil test --release --author
• Sandbox notes for ~/.dzil symlink targets and network-bound author tests

Triggers when the repo contains a dist.ini file or the user mentions dzil, Dist::Zilla, or @Author::* bundles.

Hooks Overview

suggest-review-after-commit

Automatically suggests the most relevant review command(s) after you commit changes, with interactive multi-select to choose one or more reviews to run immediately. It is a deterministic command hook that stays completely silent on every Bash call except a successful git commit, so it never interrupts unrelated commands or in-flight workflows.

On fix-NNN branches (the /fix-gh-issue workflow) it skips the menu and points only at /code-review-intense-flow, which that workflow requires before the PR (see require-review-before-pr). Elsewhere the menu lists Intense-flow (/code-review-intense-flow) first as the default — it routes to the general reviewer, security, and the path-matched specialists below automatically — followed by the specialists whose files are present:

Frontend Review (/frontend-review)

• Triggered by: .tsx, .jsx, .vue, .css, .scss, .html
• Directories: components/, pages/, styles/
• Files: tailwind.config.*, globals.css

Playwright Review (/playwright-review)

• Triggered by: .spec.ts, .spec.js, .test.ts
• Directories: e2e/, tests/, playwright/
• Files: playwright.config.*, *.e2e.*

Security Review (/security-review)

• Triggered by: Files with auth, login, password, token, session, api/ in path
• Files: .env.example, authentication modules, API endpoints

Agent-Instructions Review (/agent-instructions-review)

• Triggered by: CLAUDE.md, AGENTS.md, .cursorrules, .github/copilot-instructions.md
• Directories: .cursor/rules/, .claude/ (any .md under it), and commands/, skills/, agents/ (any .md) that sit next to a .claude-plugin/plugin.json (in a marketplace repo, each plugin's own subdirectory)

Generic Review (/request-review)

• Always offered as a fallback option
• Recommended for general-purpose code changes

Example:

I notice you just committed 3 file(s):

🎨 Frontend: Header.tsx, globals.css
🎭 Playwright: header.spec.ts

Which review(s) would you like to run?
□ Intense-flow Review (default) - General + security + path-matched specialists, routed automatically
□ Frontend Review - Images, accessibility, responsive design, CSS patterns
□ Playwright Review - Accessibility, UI issues, performance optimization
□ Generic Review - Comprehensive code review of all changes

Select multiple reviews with checkboxes, and they'll run sequentially with a combined summary at the end.

require-review-before-pr

A multi-event hook (hooks/require-review-before-pr.py) that mechanically enforces the /fix-gh-issue rule "run /code-review-intense-flow before opening the PR":

• Record — PostToolUse on Skill (code-review-intense-flow or kitchen-sink:code-review-intense-flow) and UserPromptSubmit (a prompt starting with /code-review-intense-flow) write a marker for the current HEAD SHA at $(git rev-parse --git-common-dir)/kitchen-sink/reviewed/<sha>, shared across worktrees.
• Gate — PreToolUse on Bash: on branches matching fix-NNN, gh pr create and gh pr ready (not gh pr ready --undo) are denied unless a marker exists for the current HEAD. Any new commit moves HEAD, so review-fix commits need a re-review.
• Rebases — recording also stores the git patch-id --stable of the branch's diff against its merge-base with the default branch (origin/HEAD, then origin/main, origin/master, main, master) at reviewed/patch/<branch>/<patch-id>. When HEAD has no marker, the gate allows the command if the current diff's patch-id was reviewed on the same branch (another branch with an identical diff does not inherit the review). A clean rebase, squash or reword keeps the diff and passes; a resolved conflict changes it and needs a re-review. Upstream edits adjacent to a hunk change the context lines, and so the patch-id, too. A single command that both runs git commit and gh pr create/ready is always denied, because HEAD at PreToolUse time is the pre-commit SHA.
• Bypass — only via KITCHEN_SINK_ALLOW_UNREVIEWED_PR=1 in the environment Claude Code was launched from; an inline VAR=1 gh pr create prefix in the command does not bypass.

It fails open (allows silently) on bad input, non-git directories, git errors/timeouts, detached HEAD, and other branches. Known gaps: the marker records that intense-flow was invoked, not that it passed clean; aliases, wrapper scripts, gh invoked by path, or gh api can evade the regex detection; the marker is a plain file, so this is a drift guardrail, not a security boundary. A patch-id match proves the diff is textually unchanged, not that it still behaves the same after upstream changes (semantic conflicts are CI's job).

License

MIT

Image Credit

"Mog & the kitchen sink adventure #01" by ju5ti is licensed under CC BY-SA 2.0.