ce

Create a well-formatted git commit for current changes

Start systematic debugging session for a bug

Audit and upgrade project dependencies

Create or improve documentation (routes to appropriate doc agent)

Execute an implementation plan from the plans folder

Explain code in detail with examples

Fix a GitHub issue by number

Initialize or audit Claude Code configuration for a repository

Find and fix performance issues in code

Create a detailed implementation plan for a feature or task

Review a session or task to assess execution and extract improvements

Create a pull request with auto-generated description

Refactor code following best practices

Comprehensive code review using the code-reviewer agent

Run tests and analyze failures

Expert at comprehensive code review for merge requests and pull requests from technical, product, and DX perspectives. Use this agent when the user has completed work on a feature branch and needs review before merging. Analyzes all changes between branches, evaluates user impact, assesses developer experience, enforces project standards, and provides structured feedback organized by severity.

Use this agent when you want someone to poke holes in a plan, design, or idea before committing. Examples: <example> Context: User has a plan they want validated user: "Here's my plan for the new caching layer. What's wrong with it?" assistant: "I'll look for real flaws, risks, and unstated assumptions." <commentary> User wants rigorous critique. This agent looks harder for problems than a typical reviewer, but only raises genuine issues. </commentary> </example> <example> Context: User is considering a major decision user: "We're thinking of switching to DuckDB. Play devil's advocate." assistant: "I'll examine this critically and surface any real concerns." <commentary> User wants thorough scrutiny before committing. The goal is catching genuine issues, not arguing against the decision. </commentary> </example> <example> Context: User wants to find gaps in a spec user: "Review this spec and tell me what I'm missing" assistant: "I'll identify gaps, edge cases, and unstated assumptions." <commentary> Finding what's missing requires assuming something IS missing and looking for it. </commentary> </example>

Lightweight Haiku agent for delegated tasks. Receives detailed instructions from commands like /ce:commit, /ce:test, and /ce:pr. Not typically invoked directly by users.

Specialist at efficiently reading and analyzing large log files using targeted search and filtering. Optimized to avoid loading entire logs into context by using grep-style workflows, time and severity filters, and iterative refinement across arbitrary log formats.

Guides clean, scalable system architecture during the build phase. Use when designing modules, defining boundaries, structuring projects, managing dependencies, or preventing tight coupling and brittleness as systems grow.

Fixes flaky tests by replacing arbitrary timeouts with condition polling. Use when tests fail intermittently, have setTimeout delays, or involve async operations that need proper wait conditions.

Best practices for writing Claude Code skills, rules, and CLAUDE.md instructions. Use when creating SKILL.md files, authoring .claude/rules, writing CLAUDE.md project or user instructions, or configuring Claude behavior for a project or team.

Enforces precise, minimal design for dashboards and admin interfaces. Use when building SaaS UIs, data-heavy interfaces, or any product needing Jony Ive-level craft.

Standards for self-documenting code and minimal comments. Use when auditing inline documentation or deciding when comments add value vs clutter.

Creates task-oriented technical documentation with progressive disclosure. Use when writing READMEs, API docs, architecture docs, or markdown documentation.

Executes implementation plans with smart task grouping. Groups related tasks to share context, parallelizes across independent subsystems.

Diagnose and fix tests that pass in isolation but fail when run concurrently. Covers shared state isolation and resource conflicts. References condition-based-waiting for timing issues.

Prevents silent failures and context loss in error handling. Use when writing try-catch blocks, designing error propagation, reviewing catch blocks, or implementing Result patterns.

Guides database architecture decisions for PostgreSQL, DuckDB, Parquet, PGVector, and Neo4j. Use when designing schemas, choosing storage strategies, optimizing queries, tuning maintenance, configuring vector search, modeling graph data, or diagnosing performance issues across OLTP, OLAP, similarity search, and graph workloads.

Guides CI/CD pipeline architecture, security hardening, and deployment strategies for GitHub Actions. Use when designing workflows, securing supply chains, optimizing build performance, configuring deployments, managing infrastructure as code pipelines, or setting up pipeline observability.

Safe code migrations with backward compatibility and reversibility. Use when upgrading dependencies, changing database schemas, API versioning, or transitioning between technologies.

Measure-first performance optimization that balances gains against complexity. Use when addressing slow code, profiling issues, or evaluating optimization trade-offs.

Review a completed session to extract actionable improvements. Identifies DX friction, documentation gaps, architectural confusion, anti-patterns, process failures, and skill/config improvements. Uses progressive disclosure for targeted investigation types.

Detect and run project linters, formatters, and type checkers before committing or claiming completion. Auto-detects tools from project config files.

Analyzes logs efficiently through targeted search and iterative refinement. Use when investigating errors, debugging incidents, or analyzing patterns in application logs.

Improves code structure while preserving behavior through test verification. Use when cleaning up code, reducing duplication, simplifying complexity, or reorganizing modules.

Produces executive-quality strategic documents in The Economist/HBR style. Use when writing strategy memos, market analysis, business cases, customer research reports, or any document for Product, Design, and Business leaders. Customer-led, evidence-based, narrative-driven.

Four-phase debugging framework that finds root causes before proposing fixes. Use when investigating bugs, errors, unexpected behavior, failed tests, or when previous fixes haven't worked.

Run verification commands before claiming work is complete or fixed. Use before asserting any task is done, bug is fixed, tests pass, or feature works.

Creates professional Mermaid diagrams with semantic styling and visual hierarchy. Use when creating flowcharts, sequence diagrams, state machines, class diagrams, or architecture visualizations.

Writing style and tone guide for human-sounding content. Use when writing documentation, READMEs, commit messages, PR descriptions, blog posts, or any user-facing content.

Create implementation plans with tasks grouped by subsystem. Related tasks share agent context; groups parallelize across subsystems.

Writes behavior-focused tests using Testing Trophy model with real dependencies. Use when writing tests, choosing test types, or avoiding anti-patterns like testing mocks.

2 hooks across 2 events