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.

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

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

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.

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.

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

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.

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

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.

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 a Gemini-led multi-model frontend workflow for component design, responsive layout, UI animations, and style polish, coordinating Claude, Gemini, and Codex.

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 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.

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

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

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

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

Manages eval-driven development workflow with subcommands to define, check, report, and list evals. Tracks capability and regression criteria with pass rates.

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.

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.

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.

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.

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.

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

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.

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

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

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

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

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.

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

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

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

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.

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

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.

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

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

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 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.

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

Cancels an active Ralph Wiggub loop by removing its marker file and reporting the iteration count.

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

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

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

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

Initializes a Ralph Wiggum-style iterative loop that feeds the same prompt back to the user after each attempt, encouraging repeated refinement. Supports max-iterations and completion-promise options.

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.

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

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.

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.

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.

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

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

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

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

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.

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.

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.

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

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

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

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.

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 and runs Playwright end-to-end tests for user flows across browsers, capturing screenshots/videos/traces and uploading reports/artifacts.

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.

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

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.

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.

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

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.

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.

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

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.

Syncs documentation from package.json scripts and .env.example, generating docs/CONTRIB.md (dev workflow, scripts, env, testing) and docs/RUNBOOK.md (deployment, monitoring, issues, rollback). Identifies obsolete docs and shows diff.