compound-workflows

(deprecated) Use /do:brainstorm instead

(deprecated) Use /do:compact-prep instead

(deprecated) Use /do:compound instead

(deprecated) Use /do:deepen-plan instead

(deprecated) Use /do:plan instead

(deprecated) Use /do:review instead

(deprecated) Use /do:setup instead

(deprecated) Use /do:start instead

(deprecated) Use /do:work instead

Researches and synthesizes external best practices, documentation, and examples for any technology or framework. Use when you need industry standards, community conventions, or implementation guidance.

Searches all project knowledge — solutions, brainstorms, plans, memory, and resources — for relevant context. Tags results by source type and validation status. Use before implementing features, making decisions, or starting brainstorms to surface institutional knowledge across the full knowledge base, not just docs/solutions/.

Gathers comprehensive documentation and best practices for frameworks, libraries, or dependencies. Use when you need official docs, version-specific constraints, or implementation patterns.

Performs archaeological analysis of git history to trace code evolution, identify contributors, and understand why code patterns exist. Use when you need historical context for code changes.

Searches docs/solutions/ for relevant past solutions by frontmatter metadata. Use before implementing features or fixing problems to surface institutional knowledge and prevent repeated mistakes.

Conducts thorough research on repository structure, documentation, conventions, and implementation patterns. Use when onboarding to a new codebase or understanding project conventions.

Reviews code to ensure agent-native parity — any action a user can take, an agent can also take. Use after adding UI features, agent tools, or system prompts.

Analyzes code changes from an architectural perspective for pattern compliance and design integrity. Use when reviewing PRs, adding services, or evaluating structural refactors.

Final review pass to ensure code is as simple and minimal as possible. Use after implementation is complete to identify YAGNI violations and simplification opportunities.

Reviews database migrations, data models, and persistent data code for safety. Use when checking migration safety, data constraints, transaction boundaries, or privacy compliance.

Validates data migrations, backfills, and production data transformations against reality. Use when PRs involve ID mappings, column renames, enum conversions, or schema changes.

Produces Go/No-Go deployment checklists with SQL verification queries, rollback procedures, and monitoring plans. Use when PRs touch production data, migrations, or risky data changes.

Reviews JavaScript and Stimulus code for race conditions, timing issues, and DOM lifecycle problems. Use after implementing or modifying frontend controllers or async UI code.

Analyzes code for design patterns, anti-patterns, naming conventions, and duplication. Use when checking codebase consistency or verifying new code follows established patterns.

Analyzes code for performance bottlenecks, algorithmic complexity, database queries, memory usage, and scalability. Use after implementing features or when performance concerns arise.

Reviews Python code with an extremely high quality bar for Pythonic patterns, type safety, and maintainability. Use after implementing features, modifying code, or creating new Python modules.

Detects unrelated schema.rb changes in PRs by cross-referencing against included migrations. Use when reviewing PRs with database schema changes.

Performs security audits for vulnerabilities, input validation, auth/authz, hardcoded secrets, and OWASP compliance. Use when reviewing code for security issues or before deployment.

Reviews TypeScript code with an extremely high quality bar for type safety, modern patterns, and maintainability. Use after implementing features, modifying code, or creating new TypeScript components.

Systematically reproduces and validates bug reports to confirm whether reported behavior is an actual bug. Use when you receive a bug report or issue that needs verification.

Classifies deepen-plan findings as genuine vs edit-induced and produces a convergence recommendation

Performs 5 semantic analysis passes on a plan: contradictions, unresolved-disputes, underspecification, accretion, external-verification

Fixes plan readiness issues with evidence-based auto-fixes and guardrailed user decisions

Aggregates and deduplicates plan readiness check outputs into a work-readiness report

Addresses PR review comments by implementing requested changes and reporting resolutions. Use when code review feedback needs to be resolved with code changes.

Dispatches red team review requests to external model providers (Gemini, OpenAI) via MCP tools and persists responses to disk. Pure relay — no reasoning applied.

Analyzes specifications and feature descriptions for user flow completeness and gap identification. Use when a spec, plan, or feature description needs flow analysis, edge case discovery, or requirements validation.

Browser automation via agent-browser CLI — browse, fill forms, screenshot, scrape

Design autonomous agents, MCP tools, and agent-native applications

Explore intent, approaches, and design decisions before planning

Classify stats entries with complexity and output_type labels

Capture solved problems as categorized docs with YAML frontmatter

Create and improve Claude Code skills and slash commands

Pattern for subagents that write outputs to disk, keeping parent context lean

Capture session knowledge before abandoning — runs compact-prep in abandon mode

Explore requirements and approaches before planning

Prepare for context compaction — save memory, commit, queue next task

Document a solved problem to compound team knowledge

Retry a deferred worktree merge — used when compact-prep's merge couldn't complete

Transform feature descriptions into implementation plans

Multi-agent code review with parallel analysis

Set up compound-workflows for your project

Manage session worktrees — resume, cleanup, rename, switch, create

Execute work plans using subagent dispatch

Refine brainstorm or plan documents before the next workflow step

File-based todo tracking — create, triage, manage status and dependencies

Create distinctive, production-grade frontend interfaces and components

Generate and edit images via Gemini API — text-to-image, style transfer, logos

Manage Git worktrees — create, list, switch, and clean up

Manage memory files — persist facts, preferences, and project context across sessions

Orchestrate multi-agent swarms — parallel reviews, pipelines, task queues

Run QA checks on the compound-workflows plugin

Recover context from a dead or exhausted session

Resolve PR review comments in parallel

Configure review agents and stack detection for your project

Guide for creating and updating Claude Code skills

Check plugin version status — source vs installed vs release