Skip to main content
Commands are slash commands (like /plan or /tdd) that provide quick access to common development workflows. They invoke specialized agents and reference relevant skills to accomplish specific tasks.

​
What Are Commands?

Commands are markdown files with YAML frontmatter that define:
  • Description - What the command does
  • Agent invocation - Which agent(s) to use
  • Skill references - Which skills provide methodology
  • Usage examples - How to use the command effectively

​
Command Structure

Here’s an example from the /tdd command:
~/workspace/source/commands/tdd.md
---
description: Enforce test-driven development workflow. Scaffold interfaces, generate tests FIRST, then implement minimal code to pass. Ensure 80%+ coverage.
---

# TDD Command

This command invokes the **tdd-guide** agent to enforce test-driven development methodology.

## What This Command Does

1. **Scaffold Interfaces** - Define types/interfaces first
2. **Generate Tests First** - Write failing tests (RED)
3. **Implement Minimal Code** - Write just enough to pass (GREEN)
4. **Refactor** - Improve code while keeping tests green (REFACTOR)
5. **Verify Coverage** - Ensure 80%+ test coverage

## When to Use

Use `/tdd` when:
- Implementing new features
- Fixing bugs (write test that reproduces bug first)
- Refactoring existing code

​
Available Commands (33)

ECC provides 33 slash commands across six categories:

​
Development Commands

/plan

Agent: plannerPurpose: Create implementation plan before writing codeUsage:
/plan "Add Stripe subscription billing"
Output:
  • Requirements restatement
  • Step-by-step implementation phases
  • Risk identification
  • Dependency mapping
  • WAITS for confirmation before proceeding

/tdd

Agent: tdd-guidePurpose: Enforce test-driven development workflowUsage:
/tdd "Calculate market liquidity score"
Workflow:
  1. Define interfaces
  2. Write failing tests (RED)
  3. Implement minimal code (GREEN)
  4. Refactor (REFACTOR)
  5. Verify 80%+ coverage

/code-review

Agent: code-reviewerPurpose: Review code for quality, security, maintainabilityUsage:
/code-review
Checks:
  • Code quality issues
  • Security vulnerabilities
  • Performance concerns
  • Maintainability problems
  • Severity ratings: CRITICAL, HIGH, MEDIUM, LOW

/build-fix

Agent: build-error-resolverPurpose: Fix build and type errors incrementallyUsage:
/build-fix
Process:
  • Run build command
  • Analyze errors
  • Fix highest-priority errors first
  • Verify after each fix

/e2e

Agent: e2e-runnerPurpose: Generate Playwright E2E tests for critical flowsUsage:
/e2e "User signup and first market creation"
Output:
  • Page object classes
  • Test scenarios
  • Assertions for critical steps

/refactor-clean

Agent: refactor-cleanerPurpose: Remove dead code and clean up technical debtUsage:
/refactor-clean
Actions:
  • Identify unused code
  • Remove dead imports
  • Clean up commented code
  • Simplify complex logic

​
Testing & Verification

/test-coverage

Purpose: Analyze test coverage and identify gapsUsage:
/test-coverage
Output:
  • Coverage percentages (unit, integration, E2E)
  • Uncovered lines and branches
  • Recommendations for additional tests

/verify

Purpose: Run verification loop (build, test, lint, typecheck, security)Usage:
/verify
Stages:
  1. Build check
  2. Test execution
  3. Linting
  4. Type checking
  5. Security scan

/checkpoint

Purpose: Save verification state for later comparisonUsage:
/checkpoint "before-refactor"
Use case: Before major refactoring to ensure no regressions

/eval

Purpose: Evaluate code against specific criteriaUsage:
/eval "Ensure all API endpoints have rate limiting"
Output: Pass/fail assessment with evidence

​
Learning & Evolution

/learn

Purpose: Extract patterns from current sessionUsage:
/learn
Output: Patterns identified and saved to instincts

/learn-eval

Purpose: Extract and evaluate patterns before savingUsage:
/learn-eval
Process:
  1. Extract patterns from session
  2. Evaluate quality and confidence
  3. Ask user to confirm before saving

/instinct-status

Purpose: View learned instincts with confidence scoresUsage:
/instinct-status
Output: All instincts sorted by confidence

/instinct-import

Purpose: Import instincts from file or URLUsage:
/instinct-import path/to/instincts.md

/instinct-export

Purpose: Export instincts for sharingUsage:
/instinct-export
Output: Markdown file with all instincts

/evolve

Purpose: Cluster related instincts into skillsUsage:
/evolve
Process:
  • Analyze instinct patterns
  • Group related instincts
  • Generate skill files

​
Language-Specific Commands

/go-review

Agent: go-reviewerPurpose: Go code review with idiomatic Go patternsChecks:
  • Proper error handling
  • Goroutine leak prevention
  • Interface design
  • Testing patterns

/go-test

Agent: tdd-guidePurpose: Go TDD workflow with table-driven testsFeatures:
  • Table-driven test generation
  • Benchmark tests
  • Coverage reports

/go-build

Agent: go-build-resolverPurpose: Fix Go build errorsHandles:
  • Import errors
  • Type mismatches
  • Missing dependencies

​
Orchestration

/orchestrate

Purpose: Multi-agent coordination for complex workflowsUsage:
/orchestrate "Refactor authentication system"
Process:
  • Decompose into subtasks
  • Assign agents to subtasks
  • Coordinate execution
  • Synthesize results

/multi-plan

Purpose: Multi-model collaborative planningUsage:
/multi-plan "Add real-time notifications"
Features:
  • Multiple planning perspectives
  • Consensus building
  • Risk triangulation

/multi-execute

Purpose: Multi-model collaborative executionUsage:
/multi-execute plan.md
Process:
  • Parallel implementation
  • Cross-validation
  • Conflict resolution

/pm2

Purpose: Auto-generate PM2 service commandsUsage:
/pm2
Output:
  • PM2 ecosystem.config.js
  • Start/stop/restart commands
  • Log management

​
Documentation & Utilities

/update-docs

Agent: doc-updaterPurpose: Update documentation after code changesUsage:
/update-docs

/update-codemaps

Purpose: Regenerate code architecture mapsUsage:
/update-codemaps

/setup-pm

Purpose: Configure package manager (npm, pnpm, yarn, bun)Usage:
/setup-pm
Interactive: Prompts to select preferred package manager

/skill-create

Purpose: Generate skills from git historyUsage:
/skill-create
/skill-create --instincts  # Also generate instincts

/sessions

Purpose: Manage session historyUsage:
/sessions

/projects

Purpose: List known projects and instinct statsUsage:
/projects

/promote

Purpose: Promote project instincts to global scopeUsage:
/promote pattern-name

​
Common Workflows

​
Starting a New Feature

# 1. Create implementation plan
/plan "Add OAuth authentication"

# 2. Confirm plan, then implement with TDD
/tdd

# 3. Review code quality
/code-review

# 4. Run verification loop
/verify

​
Fixing a Bug

# 1. Write failing test that reproduces bug
/tdd "Fix race condition in market resolver"

# 2. Implement fix
# (Agent guides through TDD process)

# 3. Verify no regressions
/test-coverage

​
Preparing for Production

# 1. Security audit
/code-review  # Includes security checks

# 2. E2E tests for critical flows
/e2e "User signup and first trade"

# 3. Full verification
/verify

# 4. Coverage check
/test-coverage

​
Refactoring

# 1. Save checkpoint
/checkpoint "before-refactor"

# 2. Plan refactoring
/plan "Extract market resolution logic"

# 3. Execute refactoring with TDD
/tdd

# 4. Verify no regressions
/verify

​
Command Best Practices

Always plan complex features before implementation. The planner agent will identify risks and dependencies.
Use /tdd instead of writing code directly. Test-driven development catches edge cases early.
Run code review immediately after writing/modifying code. Don’t wait until PR time.
/plan → /tdd → /code-review → /verify is a common sequence for features.
/go-review, /python-review provide language-specific checks beyond generic code review.

​
Creating Custom Commands

You can create project-specific commands:
~/.claude/commands/my-command.md
---
description: What this command does and when to use it
---

# My Command

This command invokes the **agent-name** agent to accomplish [task].

## Usage
/my-command [arguments] 

## What This Command Does

1. Step 1
2. Step 2
3. Step 3
Commands with namespaced plugin syntax: /everything-claude-code:planCommands from manual install: /plan

​
Next Steps

Explore Hooks

Learn about event-driven automations

Commands Reference

Full catalog of all 33 commands

TDD Command

Deep dive into test-driven development command

Plan Command

Learn about implementation planning