planning — command + exec skill + hook:

cp plugins/planning/commands/make.md ~/.claude/commands/
cp -r plugins/planning/skills/exec ~/.claude/skills/
cp plugins/planning/hooks/plan-annotate.py ~/.claude/scripts/
chmod +x ~/.claude/scripts/plan-annotate.py
chmod +x ~/.claude/skills/exec/scripts/*.sh

Note: when installed manually, update ${CLAUDE_PLUGIN_ROOT} references inside exec/SKILL.md and prompt files to use ~/.claude/skills/exec instead.

Add the plan-annotate hook to ~/.claude/settings.json:

{
  "hooks": {
    "PreToolUse": [{
      "matcher": "ExitPlanMode",
      "hooks": [{
        "type": "command",
        "command": "~/.claude/scripts/plan-annotate.py",
        "timeout": 345600
      }]
    }]
  }
}

release-tools — skills + scripts:

cp -r plugins/release-tools/skills/new ~/.claude/skills/
cp -r plugins/release-tools/skills/last-tag ~/.claude/skills/
chmod +x ~/.claude/skills/release/scripts/*.sh

thinking-tools — skills:

cp -r plugins/thinking-tools/skills/ask-codex ~/.claude/skills/
cp -r plugins/thinking-tools/skills/dialectic ~/.claude/skills/
cp -r plugins/thinking-tools/skills/root-cause-investigator ~/.claude/skills/

skill-eval — hook:

cp plugins/skill-eval/hooks/skill-forced-eval-hook.sh ~/.claude/scripts/
chmod +x ~/.claude/scripts/skill-forced-eval-hook.sh

Add the skill-eval hook to ~/.claude/settings.json:

{
  "hooks": {
    "UserPromptSubmit": [{
      "hooks": [{
        "type": "command",
        "command": "~/.claude/scripts/skill-forced-eval-hook.sh"
      }]
    }]
  }
}

workflow — skills:

cp -r plugins/workflow/skills/learn ~/.claude/skills/
cp -r plugins/workflow/skills/clarify ~/.claude/skills/
cp -r plugins/workflow/skills/wrong ~/.claude/skills/
cp -r plugins/workflow/skills/md-copy ~/.claude/skills/
cp -r plugins/workflow/skills/txt-copy ~/.claude/skills/

Restart Claude Code for changes to take effect.

Updating plugins

The /plugin menu has two update paths, and they behave differently:

• /plugin → Marketplaces → Update marketplace — pulls the latest plugin catalog from the repo immediately. This is the reliable way to get updates.
• /plugin → Installed → Update now — uses a local cache that can be stale for a long time and may not reflect recent changes. Use this as a fallback after updating the marketplace.

To keep plugins current automatically, enable /plugin → Marketplaces → Enable auto-update. This updates the marketplace catalog on each session start.

Plugins

| Plugin | Description | |--------|-------------| | brainstorm | Collaborative design dialogue — idea to approaches to design to plan | | review | PR review + interactive git diff annotation review + writing style guide | | planning | Structured implementation planning, interactive annotation review, and autonomous plan execution | | release-tools | Release workflow — auto-versioning, release notes, changelog | | thinking-tools | Analytical thinking — dialectic analysis, root cause investigation, codex consultation | | skill-eval | Forces skill evaluation before every response | | workflow | Session helpers — knowledge capture, confusion handling, clipboard copy |

brainstorm

Collaborative design skill. Invoke with /brainstorm:do or trigger phrases like "brainstorm", "let's brainstorm", "help me design", "explore options for", etc.

| Component | Trigger | Description | |-----------|---------|-------------| | skill | /brainstorm:do | Collaborative design dialogue — idea → approaches → design → plan |

Guides a 4-phase dialogue to turn ideas into designs:

1. Understand — gathers project context, asks questions one at a time (multiple choice preferred)
2. Explore Approaches — proposes 2-3 options with trade-offs, leads with recommendation
3. Present Design — breaks design into sections of 200-300 words, validates each incrementally
4. Next Steps — offers to write a plan (/planning:make), enter plan mode, or start implementing

review

PR review, interactive git diff annotation review, and writing style tools. Install together — review-pr uses writing-style for drafting comments.

| Component | Trigger | Description | |-----------|---------|-------------| | skill | /review:pr <number> | PR review with architecture analysis, scope creep detection, and merge workflow | | skill | /review:git-review [ref] | Interactive git diff annotation review — editor overlay with feedback loop | | skill | /review:writing-style | Direct technical communication — anti-AI-speak, brevity, no filler |

review-pr — analyzes code quality, architecture, test coverage, and identifies scope creep:

• Phase 0 — detects PR vs issue (issues get a simpler comment-only flow)
• Phase 1 — fetches PR metadata, discussion history, merge status, and inline suggestions
• Phase 1.5 — asks review mode: Full (worktree + tests + linter + architecture) or Quick (diff-only)
• Phase 2 — sets up worktree and launches a subagent for deep analysis
• Phase 3-4 — presents findings, resolves open design questions
• Phase 5 — drafts review comment using /review:writing-style, posts as formal review
• Post-approve — recommends merge strategy (rebase vs squash vs merge)

Uses gh CLI for all GitHub operations and git worktrees to avoid disrupting the current checkout.

git-review — interactive annotation-based code review. Generates a cleaned-up diff, opens it in $EDITOR via tmux popup, kitty overlay, or wezterm split-pane. You annotate directly in the diff, and the script returns your changes as a git diff. Claude reads annotations, fixes code, regenerates the diff, and loops until you close the editor without changes. Supports auto-detection of uncommitted changes or branch diffs.

Run tests: python3 plugins/review/skills/git-review/scripts/git-review.py --test

writing-style — enforces direct, brief writing for tickets, PRs, code reviews, and commit messages. Core principles: brevity, honest feedback, problem-solution structure, technical precision, anti-AI-speak. Does NOT apply to README.md, public docs, or blog posts.

planning

Structured implementation planning with interactive annotation review and autonomous plan execution.

| Component | Trigger | Description | |-----------|---------|-------------| | command | /planning:make <desc> | Structured implementation plan with interactive review loop | | skill | /planning:exec [plan-file] | Autonomous plan executor — task loop, multi-phase review, optional finalize | | hook | PreToolUse / CLI | Plan annotation in $EDITOR with diff-based feedback loop | | agent | plan-review | Automated plan quality review — completeness, over-engineering, testing |

plan command — creates a plan file in docs/plans/yyyymmdd-<task-name>.md through interactive context gathering:

• Step 0 — parses intent and explores codebase for relevant context
• Step 1 — asks focused questions one at a time (goal, scope, constraints, testing approach, title)
• Step 1.5 — proposes 2-3 implementation approaches with trade-offs (skipped if obvious)
• Step 2 — creates the plan file with tasks, file lists, test requirements, and progress tracking
• Step 3 — offers interactive review (opens plan in $EDITOR via plan-annotate), auto review, start implementation, or done

plan-annotate.py — interactive plan annotation tool. Opens plans in your $EDITOR via a terminal overlay (tmux popup, kitty overlay, or wezterm split-pane), lets you annotate directly, and feeds a unified diff back to Claude so it revises the plan. Two modes:

• Hook mode (default) — intercepts ExitPlanMode, opens plan in editor, denies tool call with diff if changes made, forcing revision loop
• File mode (plan-annotate.py <plan-file>) — outputs unified diff to stdout for integration with custom workflows

Requirements: tmux, kitty, or wezterm terminal, $EDITOR (defaults to micro). Kitty users mus