Claude Code Command Selection Guide

This skill helps you choose the most appropriate command, agent, or skill for different scenarios.

Quick Decision Flowchart

graph TD
    A[User Request] --> B{Request Type?}
    B -->|New Feature| C[/plan]
    B -->|Bug Fix| D[/tdd or build-error-resolver]
    B -->|Code Review| E[/code-review or code-reviewer agent]
    B -->|Testing| F[/e2e or tdd-guide agent]
    B -->|Context Too Long| G[/compact]
    B -->|Documentation| H[/docs or docs-lookup agent]
    B -->|Looping Task| I[/loop]
    B -->|Security Review| J[security-reviewer agent]

    C --> K[planner agent]
    D --> L{Build Failed?}
    L -->|Yes| M[build-error-resolver]
    L -->|No| N[tdd-guide]
    E --> O[code-reviewer]
    F --> P[e2e-runner]

1. Built-in Slash Commands

Session Management Commands

Command	Use Case	Example
/compact	Context too long (>150K tokens), slow response, task phase transition	/compact or auto-trigger
/clear	Start fresh conversation, clear history	/clear
/loop	Periodic task execution, automated looping work	/loop 5m check build status
/help	View help, learn commands	/help
/fast	Need faster response (Opus 4.6 only)	/fast
/model	Switch model	/model sonnet

Development Workflow Commands

Command	Use Case	Activation Timing
/plan	Start new feature, architecture refactor, complex tasks	Enter Plan Mode
/tdd	Write tests, TDD development workflow	When test guidance needed
/e2e	E2E testing, critical user flow verification	When browser testing needed
/code-review	Code quality review	After writing code
/build-fix	Build failure, type errors	When build fails
/learn	Extract patterns from session, learning	Before session ends
/skill-create	Create new skill from git history	When repeating patterns found

Documentation & Query Commands

Command	Use Case	Example
/docs	Update project documentation	/docs
/update-codemaps	Update code maps	/update-codemaps
/remember	Save memory to memory system	/remember user prefers concise output
/tasks	View task list	/tasks

---

2. Agents Selection

Development Workflow Agents

Agent	Trigger Condition	Purpose
planner	Complex feature request, architectural decision	Create implementation plan
architect	System design, tech stack selection	Architecture analysis and decisions
tdd-guide	New feature, bug fix	TDD workflow guidance
code-reviewer	Invoke immediately after writing code	Code quality review
security-reviewer	Handling auth, API, sensitive data	Security vulnerability detection

Problem Solving Agents

Agent	Trigger Condition	Purpose
build-error-resolver	Invoke immediately when build fails	Fix build/type errors
e2e-runner	Critical user flows, before PR	E2E test execution
refactor-cleaner	Code maintenance, dead code cleanup	Dead code detection and cleanup
doc-updater	Update docs, codemaps	Documentation sync

Research & Exploration Agents

Agent	Trigger Condition	Purpose
Explore	Codebase exploration, file finding	Quick codebase exploration
general-purpose	Complex multi-step tasks	General task handling
docs-lookup	Query library/framework docs	Get latest API documentation

---

3. Skills Selection

Workflow Skills

Skill	Trigger Timing	Purpose
tdd-workflow	Developing new feature/fixing bug	Complete TDD workflow guidance
verification-loop	After feature completion, before PR	Comprehensive verification (build/test/lint/security)
strategic-compact	Long session, context pressure	Guide when to manually /compact

Architecture & Pattern Skills

Skill	Trigger Timing	Purpose
frontend-patterns	Frontend development	React/Next.js/Vue best practices
backend-patterns	Backend development	API/service architecture patterns
api-design	API design	RESTful/API design standards
mcp-server-patterns	MCP server development	MCP configuration and patterns

Testing Skills

Skill	Trigger Timing	Purpose
e2e-testing	E2E testing needs	Playwright test generation
security-review	Security review needs	OWASP Top 10 detection

Research Skills

Skill	Trigger Timing	Purpose
deep-research	Need deep research	Multi-round search and research
exa-search	Need web search	Web content search
documentation-lookup	Query library docs	Context7 documentation query

---

4. Scenario Decision Matrix

By Task Phase

Phase	Recommended Tool Combination	Reason
Requirements Analysis	planner + Explore	Plan first, explore later
Architecture Design	architect + api-design skill	Professional architecture guidance
Pre-Development	tdd-guide + tdd-workflow skill	Test first
During Development	Direct edit + quick iteration	Stay in flow
Post-Development	code-reviewer + verification-loop	Quality gate
Testing Phase	e2e-runner + e2e-testing skill	Complete test coverage
Before PR	security-reviewer + verification-loop	Final verification
Build Failure	build-error-resolver	Focused fix

By Problem Type

Problem	Invoke Immediately	Note
Build failure	build-error-resolver	Minimal changes, quick fix
Type error	build-error-resolver	TypeScript specialist
Bug fix	tdd-guide	Write test then fix
Security vulnerability	security-reviewer	OWASP detection
Poor code quality	code-reviewer	Immediate review
Missing documentation	doc-updater	Auto update
Dead code	refactor-cleaner	Safe cleanup

By Development Type

Development Type	Skills Combination
Frontend feature	frontend-patterns + tdd-workflow
Backend API	backend-patterns + api-design + tdd-workflow
MCP server	mcp-server-patterns + tdd-workflow
Database	database-reviewer agent
Security feature	security-reviewer + security-review skill

---

5. Parallel Execution Strategy

Parallelizable Scenarios

Recommended: Launch multiple independent tasks simultaneously

Scenario: Preparing PR after code completion

• Agent 1: code-reviewer (code quality)
• Agent 2: security-reviewer (security review)
• Agent 3: e2e-runner (E2E tests)

Scenario: Large refactor analysis

• Agent 1: architect (architecture analysis)
• Agent 2: Explore (code exploration)
• Agent 3: refactor-cleaner (dead code detection)

Sequential Execution Required

Cannot parallelize: Dependencies exist

Scenario: Fixing build error

• Sequence: build-error-resolver -> test verification -> code-reviewer

Scenario: New feature development

• Sequence: planner -> tdd-guide (write tests) -> implementation -> code-reviewer

---

6. Auto-Trigger Rules

Invoke Without User Request

Situation	Auto Action
Code written/modified	Immediately invoke code-reviewer
Build fails	Immediately invoke build-error-resolver
Complex feature request	Immediately invoke planner
Handling auth/sensitive data	Immediately invoke security-reviewer
New feature/bug fix	Immediately invoke tdd-guide
Architectural decision	Immediately invoke architect

---

7. Context Management Timing

Indicator	Trigger /compact
Token > 150K	Immediately compact
Slow response	Suggest compact
Task phase switch	Compact at boundary
Major milestone completed	Compact then continue
Debugging ends -> new task	Clear debug traces

Best Practices:

• Compact after research, before implementation (preserve plan)
• Compact after milestone completion (clear intermediate state)
• Don't compact mid-implementation (lose variables/paths)

---

8. Command Cheat Sheet

Development Workflow:
/plan        -> Enter planning mode (complex tasks)
/tdd         -> TDD workflow
/e2e         -> E2E testing
/code-review -> Code review
/build-fix   -> Fix build

Session Management:
/compact     -> Compact context
/clear       -> Clear session
/loop        -> Looping task
/fast        -> Fast mode

Documentation & Memory:
/docs        -> Update docs
/remember    -> Save memory
/tasks       -> View tasks

Help:
/help        -> View all commands

---

9. Usage Examples

Example 1: New Feature Development

User: Add user authentication feature

Workflow:

1. /plan -> planner agent creates plan
2. tdd-guide -> write tests
3. Implementation -> edit code
4. code-reviewer -> code review
5. security-reviewer -> security review (auth sensitive)
6. e2e-runner -> E2E tests
7. /compact -> compact after milestone completion

Example 2: Build Failure

User: npm run build failed

Workflow:

1. build-error-resolver -> analyze error, minimal fix
2. Verify build success
3. code-reviewer -> check fix quality

Example 3: Code Refactoring

User: Refactor authentication module

Workflow:

1. architect -> architecture analysis
2. planner -> implementation plan
3. refactor-cleaner -> dead code detection
4. tdd-guide -> ensure test coverage
5. Implementation -> refactor code
6. verification-loop -> comprehensive verification

---

Core Principles:

1. Plan first, implement later - Use /plan for complex tasks
2. Test first - Use tdd-guide for new features
3. Review immediately after coding - Use code-reviewer when code complete
4. Fix build immediately when failed - Use build-error-resolver
5. Review sensitive code - Use security-reviewer for auth/API
6. Verify comprehensively before PR - Use verification-loop