claude-code-workflow（Claude 代码工作流）

The key words "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL NOT", "SHOULD", "SHOULD NOT", "RECOMMENDED", "MAY", and "OPTIONAL" in this document are to be interpreted as described in RFC 2119.

Claude Code Workflow

Guidelines for effective AI-assisted development with Claude Code.

Task Value Matrix

Workflow Patterns

Explore-Plan-Code-Commit (EPCC)

The RECOMMENDED workflow for most development tasks:

1. Explore: Use Glob, Grep, Read to understand existing code

- MUST understand context before making changes - SHOULD identify related files and dependencies - MAY use subagents for parallel exploration

1. Plan: Outline changes before implementation

- SHOULD create TodoWrite items for multi-step tasks - MUST validate plan covers edge cases

1. Code: Implement changes incrementally

- MUST run tests after each significant change - SHOULD use Edit over Write for existing files - SHALL NOT introduce breaking changes without tests

1. Commit: Create logical, atomic commits

- MUST follow semantic commit conventions - SHALL NOT commit secrets or credentials

Test-Driven Development with AI

1. Write failing test → 2. Implement minimum to pass → 3. Refactor → 4. Repeat

• MUST run tests between each step
• SHOULD use targeted test execution during development

Spike-Then-Implement

For uncertain implementations: Create throwaway spike, validate, delete, implement properly with tests.

Context Management

Efficient Prompting

MUST: Provide specific file paths, include error messages verbatim, state expected vs actual behavior

SHOULD: Reference previous context, specify output format, include constraints upfront

SHOULD NOT: Repeat information in context, include unnecessary background, ask multiple unrelated questions

Conversation Structure

[Initial Context] → [Specific Task] → [Iterative Refinement]

• SHOULD front-load critical information
• MUST NOT bury important constraints at end of message

Context Window Optimization

• SHOULD use subagents for isolated subtasks
• MUST NOT paste entire files when snippets suffice

Subagent vs Direct Tool Usage

Use Subagents (Task tool) When:

• Parallel independent operations (multiple searches, test runs)
• Isolated subtasks not needing main conversation context
• Complex multi-step work (refactoring across many files)
• Risk isolation (exploratory changes that might fail)

Use Direct Tools When:

• Sequential dependencies (each step depends on previous)
• Context continuity needed (building on recent conversation)
• Simple operations (single file read/edit)
• Immediate feedback required (interactive debugging)

Model Selection

Opus (Complex Reasoning)

SHOULD use for: Architecture decisions, complex debugging, multi-file refactoring, novel problem solving, security-sensitive code review

Sonnet (Standard Tasks)

RECOMMENDED for: Routine code changes, test writing, documentation, code review, bug fixes with clear scope

Haiku (Quick Operations)

MAY use for: Simple queries, syntax checking, format conversions, quick lookups, commit message generation

IF deep reasoning OR high-stakes: USE Opus
ELSE IF routine development: USE Sonnet
ELSE IF simple/quick: USE Haiku

Quality Assurance

Automated Validation

MUST: Test execution after changes, linting/formatting, type checking, security scanning

SHOULD: Coverage thresholds, performance benchmarks, integration tests

Human Review Checkpoints

REQUIRED: Security-sensitive changes, production deployments, architecture modifications, public API changes

RECOMMENDED: Complex business logic, performance-critical code, external integrations

Prompt Engineering for Code Tasks

Specificity Patterns

Effective: "Refactor UserService in src/services/user.py to use dependency injection for database connection"

Ineffective: "Clean up the user code"

Constraint Specification

MUST specify: Language/framework versions, performance requirements, backward compatibility, error handling

Prompt Templates

Bug Fix:

File: [path] | Error: [exact message]
Expected: [behavior] | Actual: [behavior]
Relevant code: [snippet]

Feature:

Goal: [one sentence]
Criteria: [list] | Location: [file] | Constraints: [limits]

Session Context Management

Integration with Context Files

CURRENT.md - Active task state (SHOULD update when switching tasks, MUST reflect current focus)

STATUS.md - Project progress (SHOULD update at session end, MUST include blockers/next steps)

Session Lifecycle

[Start] → [Load CURRENT.md] → [Work + TodoWrite] → [End] → [Update STATUS.md]

Context Preservation

• MUST save context before long breaks
• SHOULD use /snapshot for complex multi-session work
• MAY use /pickup to resume efficiently

Skill Activation Optimization

Triggering Skills Efficiently

• MUST use specific keywords in descriptions
• SHOULD include file patterns for automatic activation
• MAY use manual invocation for specialized skills

Skill Composition

Skills SHOULD be: Single-purpose, composable, self-contained

Skills MUST NOT: Conflict with others, duplicate core rules, exceed context budget

Anti-Patterns to Avoid

Conversation Anti-Patterns

Tool Usage Anti-Patterns

Workflow Anti-Patterns

Prompting Anti-Patterns

Quick Reference

Effective Session

1. Start with clear goal
2. Load context (CURRENT.md)
3. Use EPCC workflow
4. Update TodoWrite in real-time
5. Run tests frequently
6. Save context before ending

Model Selection

• Opus: Architecture, security, complex bugs
• Sonnet: Daily development, tests, docs
• Haiku: Quick queries, formatting

Tool Selection

• Read: View file content
• Edit: Modify existing files
• Write: Create new files (rare)
• Glob: Find files by pattern
• Grep: Search file contents
• Task: Parallel/isolated work
• Bash: System operations only