Three-Phase Workflow

## Core Workflow
 
### 1. Research Phase (RESEARCH)
 
**Must do before starting any task:**
 
- Use Glob to search for related files: `*.ts`, `*.tsx`, `*.service.ts`, etc.
- Use Grep to search for keywords: function names, class names, related business terms
- Check the codebase for similar existing implementations
- Read READMEs or comments in related modules
- Understand the project's architecture and dependencies
 
**Search online when uncertain:**
- Best practices for new technologies/frameworks
- Latest API docs for specific libraries
- Solutions for error messages

### 2. Plan Phase (PLAN)
 
**Must output the following:**
 
1. **File list**: All files to be modified or created
2. **Implementation approach**: Key steps and rationale for technology choices
3. **Risk identification**: Potential issues and edge cases
4. **Questions to confirm**: Items that need clarification from the user
 
**Important: Do not start coding until the user confirms**
 
- Only proceed to implementation if the user says "go ahead", "start", "OK", etc.
- If the plan has significant changes, request confirmation again
- Do not assume consent — wait for an explicit confirmation signal

### 3. Implement Phase (IMPLEMENT)
 
**Coding requirements:**
 
- Follow the project's existing code style (naming, indentation, organization)
- Complete error handling (never skip)
- Write tests alongside the implementation
- Add comments where needed (complex logic, key decisions)
 
**Must run after completion:**
 
- Linter: zero warnings, zero errors
- Formatter: consistent code format
- Type check: type-safe
- Tests: all passing
 
**Never allowed:**
 
- Committing code that fails any check
- Using TODO/FIXME in final code
- Skipping error handling
- Hardcoding sensitive information

## Core Workflow
 
**Important: Every task must follow this process — no phase may be skipped**
 
### 1. Research Phase (RESEARCH)
 
Before starting any task:
 
- Check the codebase for similar existing implementations
- Use Glob/Grep to search for related code
- Understand the project's architecture and dependencies
- Read comments and docs in related files
 
**Search online when uncertain:**
- Best practices for new technologies/frameworks
- Latest API docs for specific libraries
- Solutions for error messages
 
### 2. Plan Phase (PLAN)
 
After research, output:
 
- **File list**: Files to be modified/created
- **Implementation approach**: Key steps and technology choices
- **Risk identification**: Potential issues and edge cases
- **Questions to confirm**: Items that need user clarification
 
**Important: Do not start coding until the user confirms**
 
### 3. Implement Phase (IMPLEMENT)
 
After confirmation, execute the plan:
 
- Follow the project's existing code style
- Complete error handling (never skip)
- Write tests alongside the implementation
- Run linter/formatter/type-checker
 
**Done criteria:**
- Linter: zero warnings, zero errors
- All tests passing
- Type check passing
- Code formatted
 
---
 
**For complex architecture questions: think deeply first, then propose a plan**

## Handling Complex Tasks
 
For the following types of tasks, deep thinking is required during the plan phase:
 
- Architecture changes spanning multiple modules
- Introducing a new technology or framework
- Performance optimization plans
- Database schema design
 
**Deep thinking requirements:**
1. List at least 2–3 viable approaches
2. Analyze the pros and cons of each
3. Explain why the recommended approach is preferred
4. Identify potential technical debt

## Scenario-Based Workflow
 
### Bug Fix Flow
1. **Research**: Reproduce → Find root cause → Check related code
2. **Plan**: Explain root cause → Fix approach → Affected scope
3. **Implement**: Minimal change → Add regression tests → Verify fix
 
### New Feature Flow
1. **Research**: Understand requirements → Find reuse opportunities → Confirm tech stack
2. **Plan**: Module design → Interface definition → Test strategy
3. **Implement**: Progressive development → Parallel testing → Update docs
 
### Refactoring Flow
1. **Research**: Analyze current state → Identify problems → Assess impact
2. **Plan**: Refactoring approach → Step-by-step plan → Rollback strategy
3. **Implement**: Small incremental steps → Keep tests green → Commit frequently

## Research Phase (MANDATORY)
 
**Skipping the research phase is never allowed**
 
Before outputting any code, you must first show:
- Which files/keywords you searched
- Which related code you found
- The relevant technologies/patterns the project uses
 
Writing code without showing the above is a workflow violation.

## Plan Phase Output Format
 
The plan must include the following sections:
 
### File Change List
| File path | Action | Change description |
|---------|------|---------|
| src/xxx | Create | ... |
| src/yyy | Modify | ... |
 
### Implementation Steps
1. Step one: ...
2. Step two: ...
 
### Risk Assessment
- Risk 1: ...
- Risk 2: ...
 
### Questions to Confirm
- [ ] Question 1
- [ ] Question 2

## Implement Phase Done Criteria
 
Before committing, all of the following must be satisfied:
 
- [ ] Linter passes (zero warnings)
- [ ] Type check passes (TypeScript strict mode)
- [ ] All tests pass
- [ ] New code has corresponding tests
- [ ] No leftover TODO/FIXME
- [ ] No hardcoded config/secrets