Explore commands

Analyzes current session for reusable patterns like error resolutions, debugging techniques, workarounds, and drafts a markdown skill file for user confirmation before saving to ~/.claude/skills/learned/.

Create or verify git checkpoints for workflow progress: stash/commit state, log timestamp/SHA, compare files/tests/coverage/build; also lists or clears.

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.

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

Analyzes project to detect services (Next.js, Nuxt, Vite, Express, FastAPI, Go), generates PM2 ecosystem config and Claude slash commands for managing them (start/stop/restart/logs/status/monit).

Generates and syncs documentation from source-of-truth files like package.json, .env.example, OpenAPI specs, Dockerfiles. Updates CONTRIBUTING.md, RUNBOOK.md, checks staleness, shows summary.

Recommends optimal Claude model tier (Haiku, Sonnet, Opus) for current task by complexity and optional budget. Outputs model, confidence, rationale, fallback.

Analyzes codebase structure and generates or updates token-lean codemaps documenting architecture, backend, frontend, data layer, and dependencies with diff detection.

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

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.

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 managed autonomous loop patterns like sequential or continuous-pr with safe/fast modes. Confirms repo state, creates plan and runbook in .claude/plans/, prints start/monitor commands.

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.

Runs ECC quality pipeline on file or project scope, detecting language/tooling to execute formatter, lint, and type checks, producing a concise remediation list. Supports [path|.] [--fix] [--strict].

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

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 feature evals, check pass/fail status, generate reports, list all. Supports define/check/report/list subcommands.

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

Orchestrates Gemini-led frontend UI/UX workflow across Research, Ideation, Plan, Execute, Optimize, Review phases for tasks like component design and responsive layouts.

Executes multi-model coding workflow: generates prototype unified diff from plan via Codex/Gemini, Claude refactors to production code, performs multi-model audit, delivers changes.

Orchestrates Codex-led multi-phase backend workflow (Research → Ideation → Plan → Execute → Optimize → Review) for API design, algorithms, DB optimization, and business logic.

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.

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

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.

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.

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.

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

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

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

Orchestrates 6-phase multi-model development workflow (Research→Ideation→Plan→Execute→Optimize→Review) routing frontend tasks to Gemini and backend to Codex for given task description.

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

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

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

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

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

Cancels active Ralph Wiggum loop by checking .claude/ralph-loop.local.md existence, reading iteration if present, removing file, and reporting status.

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

Incrementally fixes build and type errors with minimal safe changes across JS/TS, Rust, Go, Python, Java projects, verifying each fix and summarizing results.

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

Starts Ralph Loop to iteratively refine a task from PROMPT using file and git history across iterations, until completion promise met or max iterations reached.

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

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.

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 plugin help: hook events, markdown config files with regex patterns, creation via /hookify or manual files, subcommands, and examples for safe behaviors.

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

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.

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

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.

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

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

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

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.

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

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.

Analyzes test coverage for detected frameworks (Jest, Vitest, Pytest, Rust, Java, Go), identifies gaps below 80%, generates missing tests, verifies, and reports before/after coverage.

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

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

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.

Safely identifies and removes dead code via analysis tools and test verification at each step, categorizing findings by safety and producing a cleanup summary.

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

Guides end-to-end creation of Claude Code plugins: discover requirements, plan components like skills/agents/hooks, implement, validate, and test. Optional plugin description.

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.

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

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.

Executes the plan in batches with review checkpoints between them, invoking the superpowers:executing-plans skill for step-by-step processing.

Retrieves project context, performs parallel dual-model (Codex/Gemini) analysis, and generates step-by-step implementation plan with pseudo-code.

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.

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

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

Analyzes test coverage via npm/pnpm test --coverage, generates unit/integration/E2E tests for files below 80%, verifies them, and reports before/after metrics to achieve 80%+ coverage.

Runs GAN-style two-agent loop (Generator + Evaluator) to iteratively create and refine frontend designs from a brief until passing weighted rubric on design quality, originality, craft, and functionality. Sets up gan-harness/ directory.

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.

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.

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

Generates and runs Playwright end-to-end tests for user journeys. Produces test code, executes across browsers, captures artifacts, generates reports, and quarantines flaky tests.

Orchestrates GAN-style iterative build: plans spec from brief, loops generator-evaluator (playwright eval default) until pass threshold, produces spec.md, feedback, score report.

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.

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

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

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.

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.

Analyzes codebase structure via imports/exports/dependencies, generates codemaps for architecture/backend/frontend/data, computes diffs from prior versions, updates with approval if >30% changed, and saves diff report.

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

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

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

Analyzes a draft prompt using 6-phase pipeline (project detection, intent/scope assessment, ECC matching), outputs optimized ECC-enriched full/quick versions with recommendations. Advisory analysis only—no execution.

Generates and runs Playwright E2E tests for user flows, producing test files, screenshots, reports, and failure analysis.

Optimizes provided prompts for Claude Code without task execution, recommending ECC components and returning a ready-to-run prompt. Legacy shim; prefer prompt-optimizer skill.

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

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.