wai

Plugin wai from marketplace wai in mlitre/wai. Commands read from the repo's manifest — 1 month ago.

Skills (32)

• caveman

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

• cleanup-worktrees

  Remove git worktrees whose branches already merged via a closed GitHub PR, surfacing uncommitted changes, unpushed commits, and untracked notes before deleting anything. Use when the user asks to clean up or prune worktrees, or which are safe to remove after PRs land. Prefer it over hand-rolled `git

• codebase-design

  Shared vocabulary for designing deep modules. Use when designing or improving a module's interface, deciding where a seam goes, finding deepening opportunities, making code more testable, or when another skill needs the deep-module vocabulary.

• commit

  Commit the session's changes as Conventional Commits. Use when the user says commit, save my work, or asks for a commit message. Pass `--message-only` to print the message without staging or committing.

• create-plan

  Build a detailed implementation plan as a DAG of tasks (`T<n>` headings + `depends_on:` lines + checkbox steps). Parses cleanly into `/implement-plan` (DAG walk).

• create-standards-checker

  Generate a domain-specialized standards-compliance-checker agent for this repo and seed its spec registry. Use when the user wants a compliance checker, standards auditor, or spec-compliance agent for a domain (EV charging, payments, HTTP, OAuth, internal RFCs), or wants code audited against normati

• describe-pr

  Generate a PR description from the diff using the repo's PR template (or a default fallback). Writes to `.claude/pr-descriptions/<branch-slug>.md`, then offers to open the PR with `gh pr create`, but only when a user is present to confirm. NEVER pushes. Does NOT call `gh pr edit` without asking.

• diagnose

  Disciplined diagnosis loop for hard bugs and performance regressions. Output is a Diagnosis Report; edits no code. Takes a bug description, or `--from-ci <pr>` to ingest a PR's failing GitHub Actions logs. Use when the user reports a bug, says something is broken, throwing, or failing, or describes

• ds

  Launch Diffscape, a browser-based code review for changes. Default: diff against HEAD. Optional: /ds main, /ds <commit>

• fix-findings

  Execute a flat findings list item-by-item. Parses a numbered list out of a handoff doc, a `code-reviewer` output, or a diagnosis report, then dispatches `wai-implementer` (freeform) → `wai-spec-reviewer` → `code-reviewer` per item, fully parallel up to `.claude/wai.json`'s `parallel_cap`. Retry-once

• git-guardrails-claude-code

  Set up Claude Code hooks to block dangerous git commands (push, reset --hard, clean, branch -D, etc.) before they execute. Use when user wants to prevent destructive git operations, add git safety hooks, or block git push/reset in Claude Code.

• grill-me

  Interview the user relentlessly about a plan or design until every branch of the decision tree is resolved, one question at a time. Challenges the repo's glossary and offers ADRs when `CONTEXT.md` and `docs/adr/` exist. Use when the user wants a plan or design stress-tested, or says grill me, interv

• handoff

  Compact the current conversation into a handoff document for another agent to pick up. Saves to the OS temp directory so it doesn't pollute the workspace.

• implement-plan

  Execute a wai DAG plan task-by-task. Walks the `T<n>` / `depends_on:` graph, dispatches `wai-implementer` → `wai-spec-reviewer` → `code-reviewer` per task, parallel up to `.claude/wai.json`'s `parallel_cap`. Retry-once on reviewer rejection; quarantine on second failure. End-of-walk report lists gre

• improve-codebase-architecture

  Find deepening opportunities in a codebase, informed by the domain language in CONTEXT.md and the decisions in docs/adr/. Use when the user wants to improve architecture, find refactoring opportunities, consolidate tightly-coupled modules, or make a codebase more testable and AI-navigable.

• iterate-plan

  Update an existing implementation plan with new feedback. Researches only if the change requires new technical understanding, then makes surgical edits.

• local-review

  Set up a worktree for reviewing a colleague's branch, adds their fork as a remote, fetches, creates the worktree.

• pr-triage

  Single action-oriented table of the user's open GitHub PRs, authored plus review-assigned, with a per-PR "action on me?" verdict. Use when the user asks about their PR queue, what is blocked, what is ready to land, or what reviews they owe. Prefer it over hand-rolled `gh` commands.

• resolving-merge-conflicts

  Resolve an in-progress git merge or rebase conflict hunk by hunk. Use when a merge or rebase stops with conflicts, when `git status` shows unmerged paths, or when the user says they are stuck in a rebase, mid-merge, or have conflict markers in a file.

• resume-handoff

  Resume work from a handoff document, read it, verify the codebase state still matches, propose a plan, then start.

• rigorous-pr-review

  The review standard, applied inline in the current conversation with no subagent. Read-only, high-bar pass over a PR or diff for correctness, maintainability, structure, and test strategy. Use whenever the user asks for a review, a strict or rigorous pass, or a quality check on a diff. For an indepe

• setup

  One-time per-repo setup for the wai workflow. Detects repo state, writes `.claude/wai.json` config, opt-in scaffolds `CONTEXT.md` and `docs/adr/`, writes a pointer block into `CLAUDE.local.md` and excludes wai personal files via `.git/info/exclude`. Re-run with `--update` to refresh the pointer and

• spec-registry

  Inspect, validate, or propose changes to the spec registry consumed by standards-compliance-checker agents. Reads run freely; writes are proposed for the user to approve. Use when a spec alias is missing, stale, or needs looking up mid-audit.

• tdd

  Canonical TDD reference, red-green-refactor loop, Iron Law (no production code without a failing test), verify-fail / verify-pass gates, vertical-slice rule, anti-patterns. Auto-applied inside `/implement-plan` via the `wai-implementer` agent invariant. Also auto-fires on explicit "use TDD" / "red-g

• teach

  Teach a subject across multiple sessions using a stateful workspace outside the repo. Use when the user wants to learn a large body of material over time (a protocol, a spec, an unfamiliar subsystem) rather than get one question answered now.

• to-questionnaire

  Turn a decision you can't answer alone into a Markdown questionnaire for the one person who can. Use when a decision is blocked on someone else's knowledge, when a grilling session hits a branch the user can't resolve, or when the user says they need to ask a colleague, a vendor, or another team.

• to-spec

  Produce a spec for a feature/bug/refactor. Two interaction modes, interview (ask questions, build the spec collaboratively) or synthesize (compress existing conversation context into a spec). Output is a local file at `specs/<YYYY-MM-DD>-<slug>.md`. Use when user says "spec this out", "write a PRD",

• using-subagents

  Primer for dispatching subagents, how to craft focused prompts, pick the right model, avoid common mistakes, and verify what came back. Use whenever you're about to dispatch a Task/Agent subagent for any purpose. `/implement-plan` (DAG walker), `/fix-findings` (flat-list walker), and `/create-plan`

• wait-what

  Re-pitch a message that didn't land. Use the moment the user says they don't follow, asks what something means, says a explanation was confusing, or types "wait, what".

• wizard

  Generate an interactive bash wizard that walks a human through steps only they can perform. Use when a task needs credentials, a third-party dashboard, infrastructure provisioning, CI secrets, hardware setup, or a one-off migration or cutover that the agent cannot execute itself.

• writing-for-agents

  Writing any document an agent consumes. Use when creating or editing a skill, an agent, a command, CLAUDE.md, AGENTS.md, or a reference doc reached by a pointer.

• writing-native-hooks

  Write Claude Code native hooks (settings.json `PreToolUse` / `PostToolUse` / `UserPromptSubmit` / `Stop` / `SessionStart` / `Notification` / `SubagentStop` / `PreCompact`). Use when the user wants to add a hook to block, warn on, or augment a tool call, or wants to enforce a checklist before stoppin

Subagents (10)

• cavecrew-builder

  Surgical 1-2 file editor for bounded, obvious changes: typo fixes, single-function rewrites, mechanical renames, format-preserving tweaks. Hard refuses 3+ file scope. Returns a caveman-compressed diff receipt so the calling thread pays no verbose narration.

• code-reviewer

  Independent, thorough review in its own context: fans out to specialists (`silent-failure-hunter`, `pr-test-analyzer`, `comment-analyzer`, `type-design-analyzer`, `wai-spec-reviewer`) and returns two verdicts, Standards and Spec, side by side and never merged. Dispatch when a review should not consu

• codebase-analyzer

  Explains HOW specific code works. Reads files, traces data flow, documents control flow with precise file:line references. Use when you need a technical map of an existing component, not where it lives, but how it behaves. Does not critique or suggest changes.

• comment-analyzer

  Audits code comments for accuracy, completeness, and long-term value. Use after generating large docstrings, before finalizing a PR that adds or modifies comments, or when reviewing existing comments for rot. Read-only, advisory.

• pr-test-analyzer

  Reviews a PR's test coverage for behavioral completeness and regression resistance. Use after a PR is created or updated to ensure tests cover new functionality and critical edge cases. Focused on what would catch real bugs, not academic line coverage.

• silent-failure-hunter

  Hunts for silent failures, inadequate error handling, and inappropriate fallback behavior in PR changes. Use after writing error handling, catch blocks, fallback logic, or any code that could suppress errors. Zero tolerance for swallowed errors.

• type-design-analyzer

  Reviews type design for encapsulation, invariant expression, and practical usefulness. Use when introducing a new type, during PR creation to review added types, or when refactoring existing types. Returns qualitative feedback plus 1-10 ratings on four dimensions.

• wai-implementer

  Writes and fixes code, with tests. Two input modes: freeform ("investigate this and fix it", a bug report, a review finding, a failing test) or a single `T<n>` task from a wai plan. Use instead of `general-purpose` for anything that edits source files. TDD invariant: no production code without a fai

• wai-spec-reviewer

  The spec axis. Reviews a change against the spec it came from, and nothing else. Pass/fail verdict + 1-2 line reason. No quality nitpicks (that's `code-reviewer`'s job). Dispatched by `/implement-plan` after each implementer run, and by `code-reviewer` on standalone reviews.

• web-search-researcher

  Researches modern or niche topics using web search and fetch. Use when the answer needs information past the model's training cutoff, vendor-specific docs, or current best practices. Returns findings with direct quotes, source links, and publication dates.

Hooks (4)

• SessionStart

  bash ${CLAUDE_PLUGIN_ROOT}/hooks/session-start.sh

• UserPromptSubmit

  node ${CLAUDE_PLUGIN_ROOT}/hooks/check-review.js

• PreToolUse

  bash ${CLAUDE_PLUGIN_ROOT}/hooks/nudge-general-purpose.sh

• PostToolUse

  node ${CLAUDE_PLUGIN_ROOT}/hooks/suggest-review.js

Similar plugins