Explore commands

Analyzes the current session to identify reusable patterns—error fixes, debugging techniques, workarounds, or project conventions—and saves them as skill files for future sessions.

Creates, verifies, or lists named checkpoints in a development workflow after running verification checks. Also supports clearing old checkpoints.

Configures preferred package manager (npm/pnpm/yarn/bun) for project or globally via detection script, config files, and environment variables.

Analyzes local git history to detect coding patterns like commit conventions and workflows, generating SKILL.md files for Claude Code skills. Supports --commits, --output, --instincts flags.

Syncs documentation from source-of-truth files (scripts, schemas, routes, exports) generating reference tables, contributing guides, runbooks, and env docs with staleness checks.

Analyzes a project to detect frontend, backend, and database services, then generates PM2 ecosystem config files and scripts for starting, stopping, and monitoring each service.

Exports instincts from project/global/all scopes to YAML file or stdout, filtered by domain and min-confidence with custom output path.

Scans project structure and generates token-optimized architecture codemaps documenting backend routes, frontend hierarchy, data models, and dependencies with diff detection.

Recommends the best model tier (haiku, sonnet, opus) for a task based on complexity, risk, and budget constraints, with optional --budget flag.

Lists registered projects from ~/.claude/homunculus/projects.json with name, id, root, remote, personal/inherited instinct counts, observation events, last seen timestamps, and global totals.

Starts a managed autonomous loop pattern with configurable mode and safety defaults. Creates a loop plan and runbook with explicit stop conditions.

Promotes project-scoped instincts to global scope. Auto-detects cross-project candidates meeting confidence threshold or promotes specific instinct-id. Supports --dry-run and --force.

Analyzes project and global instincts, clusters by trigger patterns, and suggests evolutions into commands, skills, or agents. Use --generate to create files in evolved directories.

Shows learned instincts for the current project and global ones, grouped by domain with confidence bars and observation stats.

Incrementally fixes Gradle build and compilation errors for Android and Kotlin Multiplatform projects by detecting issues, applying minimal fixes, verifying with re-builds, and summarizing results.

Runs ECC quality pipeline on a file or project scope, running formatter, lint, and type checks then reporting remediation steps. Accepts optional path and --fix/--strict flags.

Runs a multi-model backend workflow (Research → Ideation → Plan → Execute → Optimize → Review) for APIs, algorithms, data, and business logic tasks.

Executes a multi-model implementation plan: external models generate prototypes (unified diffs only), Claude refactors and writes files, then multi-model audit validates the result.

Runs a Gemini-led multi-model frontend workflow for component design, responsive layout, UI animations, and style polish, coordinating Claude, Gemini, and Codex.

Runs comprehensive Rust code review: cargo check/clippy/fmt/test/audit, security scan, ownership/lifetimes analysis, severity-categorized report.

Orchestrates a 6-phase multi-model dev workflow (research → review) routing frontend to Gemini and backend to Codex, with quality gates and session reuse.

Guides feature implementation: explores codebase with agents, asks clarifying questions on ambiguities, designs architecture, and applies code changes.

Detects the project's build system and incrementally fixes build and type errors one at a time with minimal safe changes.

Inspects active loop state, progress, checkpoints, failures, drift, and recommends interventions. Optional --watch mode refreshes status periodically.

Enforces TDD workflow for Go: define interfaces, write table-driven tests first (RED), implement minimally (GREEN), refactor, and verify 80%+ coverage.

Runs comprehensive codebase verification including build, types, lint, tests, console.log audit, and git status. Produces PASS/FAIL report. Supports quick, full, pre-commit, pre-pr modes.

Manages eval-driven development workflow — define, check, report, and list evals with pass-rate tracking and recommendations.

Delete pending instincts older than 30 days that were never promoted. Supports --max-age <days> for custom threshold and --dry-run to preview.

Runs comprehensive PR review using specialized agents for code quality, tests, errors, types, comments, and simplification. Produces categorized issues summary with critical, important, suggestions, strengths, and action plan.

Stages unstaged changes based on git status and diff analysis, then creates a commit with a generated message. Uses current branch and recent commit history for context.

Reviews uncommitted changes via git diff for security vulnerabilities, code quality issues, and best practices; generates severity-based report with fixes and blocks commits on critical/high issues.

Interactively creates and sets up a new Claude Agent SDK application in TypeScript or Python, gathering requirements and initializing project with configs and dependencies.

Loads the most recent or specified session file from ~/.claude/session-data/ and displays a structured briefing on project, state, progress, blockers, and next steps.

Reviews C++ git changes for memory safety, modern idioms, concurrency, and security via clang-tidy and cppcheck, producing a severity-categorized issue report with fixes.

Safely identifies and removes dead code with test verification after each deletion. Runs language-specific analysis tools, categorizes findings by risk, and atomically deletes with rollback on test failure.

Cancels an active Ralph loop by reading the current iteration from a marker file and removing it, then reporting the iteration number.

Answers a quick side question mid-task without interrupting context or modifying files, then resumes the active task automatically.

Extracts reusable patterns from the session, self-evaluates quality with checklist and verdict, determines Global or Project save location, and saves approved skills.

Generates detailed feature implementation plan from description or PRD file path, with codebase analysis, pattern extraction, user story, and complexity assessment.

Commits current changes (staged/unstaged) to a new branch if on main, pushes to origin, and creates a GitHub pull request via gh.

Analyzes test coverage, identifies under-covered files, and generates missing tests to reach a target threshold (default 80%).

Imports instincts from local file or HTTP(S) URL into project or global scope. Previews changes, resolves duplicates by confidence, prompts for confirmation unless --force. Supports --dry-run, --min-confidence, --scope flags.

Enforces TDD workflow for Kotlin: scaffolds interfaces, writes failing Kotest tests (RED), implements code (GREEN), refactors, and verifies 80%+ Kover coverage.

Saves current session state to a dated Markdown file in ~/.claude/session-data/ capturing progress, issues, and context for resuming later.

Performs comprehensive Kotlin code review on modified .kt files via git diff: runs gradlew build/test, detekt, ktlintCheck; checks null safety, coroutines, security; generates severity-categorized report.

Reviews modified Go files via git diff for idiomatic patterns, concurrency safety, error handling, security. Runs go vet, staticcheck, golangci-lint, govulncheck; generates report categorized by severity.

Runs adversarial dual AI code review loop: two independent reviewers (Claude Opus + external model) must both approve changes before commit, with up to 3 fix-review cycles.

Informs user that the command is deprecated, will be removed in next major release, and directs to use superpowers:writing-plans skill instead.

Starts an iterative development loop that repeatedly feeds the same prompt back to Claude, enabling incremental improvement across iterations. Supports --max-iterations and --completion-promise flags.

Cleans up local Git branches marked [gone] (deleted on remote) by removing associated worktrees and deleting branches. Lists branches/worktrees first and reports results.

Informs user that this command is deprecated and will be removed soon; use the superpowers:brainstorming skill instead.

Notifies that this command is deprecated, will be removed in next major release, and directs to use superpowers:executing-plans skill instead.

Creates hookify rules to prevent unwanted behaviors by analyzing conversation or explicit instructions, interactively confirming via questions on selection, block/warn, and patterns.

Enforces TDD workflow for Rust: write tests first (RED), implement minimally (GREEN), refactor, and verify 80%+ coverage with cargo-llvm-cov.

Runs a generator-evaluator build loop that iteratively improves an application against a rubric until it passes a score threshold or plateaus.

Enforces TDD workflow for C++: scaffolds interfaces, writes GoogleTest tests first (RED), implements minimal code (GREEN), refactors, and verifies 80%+ coverage with gcov/lcov.

Runs a generator/evaluator design loop for frontend or visual work with bounded iterations and scoring.

Fixes Rust build errors, borrow checker issues, and dependency problems incrementally. Runs cargo check, clippy, fmt diagnostics and applies minimal verified fixes.

Lists all configured Hookify rules from .claude/hookify.*.local.md files in a summary table with name, enabled status, event, pattern, file path, plus message previews and management footer.

Interactively toggle enabled/disabled state of existing hookify rules in .claude/hookify files, updating them and confirming changes.

Displays Hookify plugin help: hook events, markdown config files with regex patterns, creation via /hookify or manual files, subcommands, and examples for safe behaviors.

Executes a Markdown plan file step-by-step: detects package manager, prepares git branch, implements tasks with pattern mirroring, validates after every change.

Generates a collaborative multi-model implementation plan by retrieving project context and running parallel analysis from Codex and Gemini, outputting step-by-step plan files without modifying code.

Guides feature development through structured phases: discovery, codebase exploration, architecture design, implementation with TDD, quality review, and summary.

Explains Ralph Wiggum technique for iterative AI development loops via repeated prompts and self-reference, and lists commands /ralph-loop and /cancel-ralph.

Reviews Flutter/Dart code changes via git diff for idiomatic patterns, best practices, state management, performance, accessibility, security; outputs severity-grouped findings with fix guidance.

Runs deterministic harness audit on repo or scopes (hooks/skills/commands/agents), producing prioritized scorecard with 7 category scores, findings, failed checks, top actions. Supports --format text/json, --root.

Runs multi-perspective PR review using specialized agents for code, comments, tests, errors, types, and simplification. Aggregates, dedupes, ranks findings by severity.

Reviews local uncommitted changes or GitHub PRs (pass PR number/URL) for security vulnerabilities, code quality issues, and best practices. Generates severity-based report with file locations, descriptions, and fixes.

Lists all configured Hookify rules from .claude/hookify.*.local.md files in a formatted table with name, enabled status, event, pattern, and file path. Shows rule count and config reminder.

Interactively toggle hookify rules on or off: lists .claude/hookify.*.local.md files with status, prompts for selection, updates enabled field, and confirms changes.

Reviews modified Go files via git diff for idiomatic patterns, concurrency safety, error handling, and security using static analysis; generates severity-categorized report with fixes.

Analyzes test coverage, detects frameworks like Jest/Vitest/Pytest, identifies gaps below 80%, generates missing tests, verifies improvements, and reports before/after comparison.

Creates hook rules to prevent unwanted Claude Code behaviors by analyzing conversations or explicit instructions, generating YAML files in .claude/.

Fixes Go build errors, go vet warnings, and linter issues incrementally with minimal changes, verifying each fix and providing a summary.

Safely detects and removes dead code using tools like knip, ts-prune, vulture; verifies each deletion with full test suite; categorizes by risk and reports summary.

Displays Hookify system overview covering event types (bash, file, stop, prompt, all), rule file format, commands (/hookify, /hookify-list, /hookify-configure), and regex pattern tips.

Displays skill portfolio health dashboard with success rate sparklines, failure pattern clustering, pending amendments, and version history. Supports --panel and --json flags.

Starts NanoClaw v2 REPL: persistent zero-dependency AI agent session with model routing, skill hot-loading, branching, compaction, export, and metrics.

Generates and runs Playwright end-to-end tests for user flows across browsers, capturing screenshots/videos/traces and uploading reports/artifacts.

Reviews Python code changes via git diff for PEP 8, type hints, security issues, and idioms using ruff, mypy, bandit. Generates severity-categorized report.

Generates interactive, problem-first Product Requirements Document (PRD) via phased questioning, market research, and hypothesis validation.

Creates GitHub PR from current branch with unpushed commits. Discovers templates, analyzes changes/files, pushes branch, fills body. Optional base-branch (default: main).

Stages Git files via natural language (e.g., 'auth changes'), globs (e.g., '*.ts'), or keywords (e.g., 'except tests'), crafts conventional commit message, and commits. Blank stages all.

Imports instincts from local file or HTTP(S) URL into project/global scope. Previews new instincts, duplicates/conflicts, and updates; merges with confirmation unless --force, supports --dry-run and --min-confidence.

Fixes C++ build errors, CMake, and linker issues incrementally with minimal changes. Runs diagnostics like cmake --build and static analyzers, applies fixes one-by-one, verifies each, and reports a summary.

Creates step-by-step implementation plan: restates requirements, assesses risks, identifies dependencies and blockers, estimates complexity, and waits for user confirmation.

Fixes Kotlin/Gradle build errors, compiler warnings, detekt/ktlint violations, and dependency issues incrementally with minimal changes, verifying each fix and reporting a summary.

Fixes Go build errors, go vet warnings, and linter issues incrementally. Runs diagnostics like go build/vet/staticcheck/golingci-lint, applies minimal fixes one by one, verifies each, and reports summary.

Reviews modified Python files via git diff for PEP8, type hints, security issues, and idioms using ruff, mypy, bandit, producing a severity-categorized report.

Incrementally fixes build and type errors with minimal safe changes by detecting build system, fixing one error at a time, verifying fixes, and summarizing results.

Generates step-by-step implementation plan via dual-model (Codex/Gemini) collaborative analysis after context retrieval and optional prompt enhancement.

Manages Claude Code session history and metadata: lists sessions with ID, date, branch, worktree, alias (filtering/pagination), loads content by ID, sets aliases, shows info. Supports list|load|alias|info subcommands.

Triggers brainstorming to explore requirements and design before creating features, building components, adding functionality, or modifying behavior.

Creates a detailed implementation plan broken into bite-sized tasks by invoking the superpowers:writing-plans skill.

Enforces TDD workflow: scaffolds interfaces, generates failing tests first, implements minimal passing code, refactors, and verifies 80%+ coverage.