skills

Drive a goal to a merge-ready endpoint by orchestrating the offload architect loop: run contextual plan reviews, dispatch a configured builder harness slice-by-slice, wait for each slice via a backgrounded bridge (no Claude-side polling), judge raw gates plus an independent `review` pass per slice, and run a final integration `review`. STOPS at the edge of merge by default and hands to the human — only merges when the goal text explicitly authorizes it. You stay the ARCHITECT and never write implementation code. Use when the user says "complete", "drive this to done", "take this to merge-ready", "run the whole loop", or invokes /complete.

Make this Claude session the ARCHITECT and offload implementation to a configured builder harness (codex, claude, opencode, pi, grok, or a custom command) you can watch. Reads the session handoff, arbitrates the builder's disagreements, judges raw gate results against frozen criteria plus an independent `review` pass on each slice, specs the next one-PR slice, and emits + dispatches a builder block. The architect never writes implementation code. Use when the user says "offload", "hand this to codex", "hand this to a builder", "architect mode", "have codex build this", or invokes /offload.

Compact the current conversation into a handoff document for another agent to pick up.

Systematic debugging with root cause investigation. Phases: context detection, investigate, analyze, hypothesize, implement, verify. Iron Law: no fixes without root cause. Supports quick-pass for obvious bugs and full investigation for mysteries. Evidence log tracks what's been checked and ruled out. Use when asked to "debug this", "fix this bug", "why is this broken", "investigate this error", or "root cause analysis". Proactively suggest when the user reports errors, unexpected behavior, or is troubleshooting why something stopped working.

Deep plan review with four modes: SCOPE EXPANSION (dream big), SELECTIVE EXPANSION (hold scope + cherry-pick expansions), HOLD SCOPE (maximum rigor), SCOPE REDUCTION (strip to essentials). Supports Standard (per-section) and Batched (grouped) pacing. Detects review context (git/PR, plan document, or hybrid). Challenges premises, maps failure modes and concurrency risks, reviews architecture/security/performance/cost/deployment, evaluates API contracts, and produces structured outputs with error registries, diagrams, and a go/no-go readiness verdict.

Designer's eye plan review — interactive, like the deep and eng reviews. Rates each design dimension 0-10, explains what would make it a 10, then fixes the plan to get there. Covers information architecture, interaction states, motion/micro-interactions, user journey, AI slop risk, content/copy quality, design system alignment, responsive/a11y, perceived performance, theming, and unresolved decisions. Supports Standard (per-pass) and Quick-pass (grouped) pacing. Detects review context (git/PR, plan document, or hybrid). Produces a go/no-go design readiness verdict. Works in plan mode. For live site visual audits, use /design-review. Use when asked to "review the design plan" or "design critique". Proactively suggest when the user has a plan with UI/UX components that should be reviewed before implementation.

Developer experience plan review for developer-facing products (APIs, CLIs, SDKs, libraries, platforms, docs). Investigates developer personas, benchmarks against competitors, designs magical moments, traces friction points, then scores 8 DX dimensions 0-10. Three modes: DX EXPANSION (competitive advantage), DX POLISH (bulletproof every touchpoint), DX TRIAGE (critical gaps only). Use when asked to "DX review", "developer experience audit", "devex review", or "API design review". Proactively suggest when the user has a plan for a developer-facing product.

Eng manager-mode plan review. Lock in the execution plan — architecture, security, data flow, concurrency, diagrams, edge cases, test coverage, performance, observability, deployment. Supports Standard (per-section) and Quick-pass (grouped) pacing. Detects review context (git/PR, plan document, or hybrid). Walks through issues interactively with opinionated recommendations and produces a go/no-go readiness verdict. Use when asked to "review the architecture", "engineering review", or "lock in the plan". Proactively suggest when the user has a plan or design doc and is about to start coding — to catch architecture issues before implementation.

Pre-landing PR review. Analyzes diff against the base branch for SQL safety, migration safety, auth/permission gaps, error handling anti-patterns, API contract breaks, LLM trust boundary violations, conditional side effects, and other structural issues. Includes adversarial subagent review, design review for frontend changes, and a landing verdict (SAFE TO LAND / LAND WITH CAUTION / DO NOT LAND). Use when asked to "review this PR", "code review", "pre-landing review", or "check my diff". Proactively suggest when the user is about to merge or land code changes.

Ultra-compressed communication mode. Cuts token usage ~75% by speaking like caveman while keeping full technical accuracy. Supports intensity levels: lite, full (default), ultra, wenyan-lite, wenyan-full, wenyan-ultra. Use when user says "caveman mode", "talk like caveman", "use caveman", "less tokens", "be brief", or invokes /caveman. Also auto-triggers when token efficiency is requested.

Remove signs of AI-generated writing from text or a file. Use when editing or reviewing prose to make it sound more natural and human-written. Accepts either inline text or a file path; for files, applies the rewrite back to the file in place. Based on Wikipedia's comprehensive "Signs of AI writing" guide. Detects and fixes patterns including: inflated symbolism, promotional language, superficial -ing analyses, vague attributions, em dash overuse, rule of three, AI vocabulary words, negative parallelisms, hollow rhythm punches, verdict openers, cliched openings, and excessive signpost transitions.

A strict editorial reviewer that checks writing principles inspired by George Orwell's "Politics and the English Language" rules and Matthew Butterick's Practical Typography. Use this skill whenever the user says "red pen", "check my prose", "edit this for clarity", "typography check", "tighten this up", "review this draft for style", or wants a rigorous line-edit focused on cutting flab, killing dead metaphors, fixing passive voice, and correcting typographic errors like straight quotes, wrong dashes, and double spaces. Also use when the user asks you to be a "tough editor", "strict editor", or "copy editor", or wants feedback on prose quality rather than content or structure.

Assess whether compacting or clearing the current session is worth it right now, and whether a reinit-ready handoff that survives /clear would carry real value. Not a threshold nag — it X-rays context composition (how much is stale vs. still load-bearing), which only the agent can see. Use when the user says "session budget", "should I compact", "should I clear", "is this session getting heavy", "token budget", invokes /session-budget, or when the budget hook requests a proactive assessment.

Use when writing any plan document — project plans, PRDs, proposals, implementation plans, or design docs. Applies as a writing style layer alongside other planning skills like superpowers:writing-plans.

Use when writing, editing, reviewing, or discussing any SQL in the project. Triggers: SQL query, SELECT, INSERT, UPDATE, DELETE, CREATE TABLE, ALTER TABLE, migration, schema, database query, raw query, prepared statement, PDO, query builder, $wpdb, DB::, ->prepare(), ->query(), SQL formatting, inline SQL in PHP, CTE, subquery, window function, UNION, EXISTS. Applies to raw .sql files, migration DDL, inline queries in PHP adapters/repositories, and any code review involving SQL. Enforces project SQL formatting conventions — no exceptions for short queries.

Audit and trim AI agent instruction files (AGENTS.md, CLAUDE.md, CONVENTIONS.md, .cursorrules, etc.) by testing which facts an AI agent can discover from code alone. Use when asked to lint, audit, optimize, prune, or trim any agent instruction file in a repository. Removes redundant documentation that wastes context tokens. Supports a dry-run mode that reports findings without modifying files.

Use this skill to create git commits and write commit messages. Invoke it for ANY of these user goals: committing code changes, crafting or suggesting commit messages, describing diffs for commit purposes, or formatting commits in conventional/angular style. Common triggers: 'commit this', 'commit them', 'write a commit message', 'what should the commit message be', 'help me with the commit', or any variant where the user has finished coding and wants to record their changes in git. Also invoke when users mention pushing code and need the commit authored first, when they ask to split changes into separate commits, or when they ask to summarize what changed for a commit. Exclude: pull requests, code review, changelogs, reverting commits, git log analysis, writing docs about commit conventions.

Scopes a coding task before implementation — names the handful of files actually relevant (read/edit these), the areas to leave alone, and any open scope questions, so work doesn't start by reading the whole repo. Fires proactively at the start of substantive, multi-file, or unfamiliar-area work; stays silent on single-file edits, one-line fixes, questions, and continued work in an area already scoped this session. Use when beginning a feature, bug fix, or refactor that could plausibly touch several files or an area not yet seen this session.

Apply a structured judgment and discernment framework to any high-stakes decision, recommendation, or AI-generated output. Use this skill whenever the user wants to think more carefully before committing to something — a people decision, a strategic call, a piece of writing they're about to send, or an AI output they're not sure whether to trust. Trigger on phrases like "is this right?", "am I confident about this?", "help me think this through", "run the discernment framework", "judgment check", "calibration check", "am I being overconfident", "should I trust this output", "premortem", or any time someone is wrestling with whether their thinking is sound. Also trigger proactively when someone appears to be accepting a claim, recommendation, or AI-generated output without questioning it — especially on high-stakes topics like hiring, restructuring, or communications that will reach many people.

Use when assessing an idea, plan, strategy, product direction, public decision, creative concept, or proposal from multiple perspectives. Triggers: council, debate this, assess this idea, challenge my plan, stress-test, devil's advocate, ethical review, pragmatic next step, visionary take, creative reframing, pre-mortem, trade-offs, values alignment, long-term implications.

Deep security review of a diff or a specific file, grounded in 20 evidence-based pattern libraries extracted from 400+ real-world bugs in major open-source projects (Linux kernel, OpenSSL, Chromium, Firefox, curl, Go, Rust, Kubernetes, Next.js, etc.). Use when the user says "security review", "security audit", "audit this for vulnerabilities", "threat model this", "check for CVEs", "check for injection/auth/crypto issues", or when a diff touches buffer handling, parsers, authentication, authorization, cryptography, state machines, CI/CD, dependencies, or trust boundaries. Also usable as a reference library — `/review` links here when a diff touches a security-sensitive area.

Design consultation: understands your product, researches the landscape, proposes a complete design system (aesthetic, typography, color, layout, spacing, motion), and generates font+color preview pages. Creates DESIGN.md as your project's design source of truth. For existing sites, use /plan-design-review to infer the system instead. Use when asked to "design system", "brand guidelines", or "create DESIGN.md".

Designer's eye QA: finds visual inconsistency, spacing issues, hierarchy problems, AI slop patterns, and slow interactions — then fixes them. Iteratively fixes issues in source code, committing each fix atomically and re-verifying with before/after screenshots. For plan-mode design review (before implementation), use /plan-design-review. Use when asked to "audit the design", "visual QA", "check if it looks good", "design polish", "does this look AI-generated", or "review the UI".

Product design session — structured questioning that ensures the problem is understood before solutions are proposed. Explores demand, status quo, target users, and the narrowest useful wedge. Produces a design document, not code.

Report-only QA testing. Systematically tests a web application and produces a structured report with health score, screenshots, and repro steps — but never fixes anything. Use when asked to "just report bugs", "qa report only", or "test but don't fix". For the full test-fix-verify loop, use /qa instead.

Systematically QA test a web application and fix bugs found. Runs QA testing, then iteratively fixes bugs in source code, committing each fix atomically and re-verifying. Use when asked to "qa", "QA", "test this site", "find bugs", "test and fix", or "fix what's broken". Three tiers: Quick (critical/high only), Standard (+ medium), Exhaustive (+ cosmetic). Produces before/after health scores, fix evidence, and a ship-readiness summary.