codebrain

API documentation researcher and implementation advisor. Use when working on API routes, integrating third-party APIs, or implementing SDK methods. Reads official docs via Context7 and web sources before ANY implementation begins. Validates API usage patterns, checks for deprecated methods, and ensures correct HTTP semantics. Never writes production code — only returns implementation guidance.

Epic orchestrator agent. Uses knowledge graph and impact analysis to maintain the global worldview across specs, tickets, and execution history. Determines task ordering, detects drift, recommends spec updates. Never writes code.

Read-only codebase research and implementation plan generation. Uses knowledge graph, LSP, and blast radius analysis. Enforces constitution, flags ambiguities with [NEEDS CLARIFICATION] markers, uses EARS notation for requirements. Never writes code.

Verification agent that checks implementation against specs and plans. Uses knowledge graph for impact analysis, runs build/test/lint, checks spec compliance, SOLID principles, and hard limits. Also handles code review and quality scanning. Read-only — reports but never fixes.

Use when checking for stale artifacts, spec-code divergence, missing requirements, inconsistencies between specs and implementation, or cross-artifact conflicts. Detects drift, staleness, and gaps across all codebrain artifacts.

Use for fire-and-forget execution via Remote Control. Wraps YOLO mode with Remote Control session bridging, pre-flight checks, phone-readable pause summaries, and completion reports. Start a task at your desk, monitor and approve from your phone. Inspired by Stripe's Minions fire-and-forget pattern.

Browser-based verification of UI changes. Checks that pages load, elements render correctly, no console errors. Triggers after dev server start or accumulated UI file changes. Use when visual verification is needed — blank pages, broken layouts, missing elements.

Use when something is broken, failing, hanging, erroring, or behaving unexpectedly. Systematic debugging workflow: reproduce → isolate → hypothesize → fix → verify. Prevents guessing and shotgun fixes. Also triggers on frustration signals like 'why isn't this working', 'it's broken', 'stuck'.

Deployment orchestration and environment management. Handles deploy commands, env vars, CI/CD pipelines, promote/rollback procedures. Platform-agnostic: supports Vercel, Docker, Fly.io, Railway, and custom CI/CD. Use when deploying, setting up pipelines, or managing environments.

Use when creating UI mockups, wireframes, design systems, or visual prototypes before implementing frontend code. Uses Pencil.dev MCP to create designs in .pen files, validate visually with screenshots, then generate code from approved designs. Design-first workflow for UI features.

Use BEFORE writing a PRD. Structured problem discovery that validates whether a feature is worth building. Asks who has the problem, how painful it is, what alternatives exist, and what success looks like. Outputs an opportunity statement. Prevents building things nobody wants.

Use when starting a large feature, managing multi-ticket work, or tracking specs/tickets/decisions. Subcommands: create (specs + tickets with EARS requirements and Given/When/Then acceptance criteria), work (next ticket), status (progress).

Deep multi-system investigation for complex issues. Traces problems across boundaries: frontend -> API -> database -> external services. Builds evidence timeline and identifies root cause. Use for intermittent failures, race conditions, data inconsistencies, and issues that span multiple components.

Use when a feature is implemented and verified but not yet shipped. Generates a stack-aware pre-launch checklist covering performance, security, accessibility, error handling, monitoring, and rollback. Validates Definition of Done. Creates a rollout plan with feature flags. Prevents shipping broken features.

Use after /codebrain:prd to enumerate ALL user paths through a feature — happy paths, sad paths, edge cases, and error states. Uses state machine modeling to make impossible states impossible. Generates Mermaid diagrams. Runs a pre-mortem to catch failure modes before coding. The MVP hell killer.

Use when initializing a project for codebrain, loading project context, updating memory after work, or resetting project knowledge. Subcommands: reset (initialize .codebrain/ with constitution), load (display memory), update (refresh from recent work).

Orchestrated debugging coordinator. Triggers on frustration signals (stuck, hung, broken) and systematically triages: runtime logs -> server health -> test output -> build status. Reports findings at every step. Use when something is not responding, hanging, timing out, or producing no output.

Use when implementing a feature, fixing a bug, refactoring, or making any code change. Generates a structured plan with EARS criteria and [NEEDS CLARIFICATION] markers, executes it, then auto-verifies with spec reconciliation. The core Plan → Execute → Verify loop.

Use after /codebrain:discover to write a Product Requirements Document. Generates a structured PRD (<1200 words) with P0/P1/P2 requirements, user stories, success metrics, and non-goals. Validates against anti-patterns. Every P0 requirement traces to a user need. Outputs machine-readable acceptance criteria for AI agents.

Use when scanning for dead code, unused imports, stub functions, duplicate logic, or general code quality issues. Runs automated detection tools and AI-powered analysis to find problems that linters miss.

Use when restructuring code without changing behavior — extracting functions, splitting files, renaming, reorganizing modules, reducing complexity, or cleaning up debt. Ensures behavior is preserved through snapshot testing before and after. Not for bug fixes or features.

Use after shipping a feature to run a structured retrospective. Gathers metrics (what shipped, what was cut, time spent), identifies what went well and what didn't, updates the PRD with learnings, and plans the next iteration. Prevents 'ship once and forget' — the root cause of MVP hell.

Use when reviewing code for bugs, performance issues, security vulnerabilities, or quality problems. Deep agentic review that reads full files and traces imports, not just diffs. Categorizes by severity.

Use when checking if implementation matches a plan or spec, after completing code changes, before claiming work is done, or when you need to run build/test/lint checks. Checks EARS acceptance criteria, runs automated checks, detects spec deviations, categorizes issues by severity.

Use when you want fully automated Plan → Execute → Verify with auto-commit. Uses task recitation to prevent drift, circuit breakers for safety, and fresh context per task. Pauses on Critical issues and unresolved [NEEDS CLARIFICATION] markers.

5 hooks across 5 events