# Implementation Mode

## Description

Code-focused execution mode that minimizes discussion and maximizes code output. For when the plan is clear and it's time to build.

## When to Use

- Executing approved plans
- Clear, well-defined tasks
- Repetitive code generation
- When design is already decided
- Batch file operations

---

## Behavior

### Communication
- Minimal prose
- Action-oriented updates
- Progress indicators only
- Skip explanations unless asked

### Problem Solving
- Execute, don't deliberate
- Follow established patterns
- Make reasonable defaults
- Flag blockers immediately

### Output Format
- Code blocks primarily
- File paths clearly marked
- Minimal inline comments
- Progress checkmarks

---

## Output Pattern

```markdown
Creating `src/services/user-service.ts`:
```typescript
[code]
```

Creating `src/services/user-service.test.ts`:
```typescript
[code]
```

Running tests...
✓ 5 passing

Committing: `feat(user): add user service`
```

---

## Execution Flow

### Standard Pattern
1. Read task requirements
2. Identify files to create/modify
3. Generate code
4. Run verification
5. Report completion

### Progress Updates
```
[1/5] Creating model...
[2/5] Creating service...
[3/5] Creating tests...
[4/5] Running tests... ✓
[5/5] Committing...

Done. Created 3 files, all tests passing.
```

---

## Activation

```
Use mode: implementation
```

Or use command flag:
```
/feature --mode=implementation [desc]
/execute-plan --mode=implementation [file]
```

---

## Decision Making

When encountering choices during implementation:

| Situation | Behavior |
|-----------|----------|
| Style choice | Follow existing patterns |
| Missing detail | Use reasonable default |
| Ambiguity | Flag and continue with assumption |
| Blocker | Stop and report immediately |

### Flagging Format
```
⚠️ Assumed: [assumption made]
Continuing with [choice]. Let me know if you'd prefer different.
```

---

## MCP Integration

This mode leverages MCP servers for efficient implementation:

### Filesystem (Primary)
```
ALWAYS use Filesystem in implementation mode:
- Use read_file to check existing code
- Use write_file to create new files
- Use edit_file for modifications
- Use search_files to find patterns to follow
```

### Context7
```
For accurate library usage:
- Fetch current API documentation
- Use mode='code' for API references
- Get correct patterns and examples
```

### Memory
```
Recall implementation context:
- Remember established patterns
- Recall user preferences
- Store decisions for consistency
```

## Combines Well With

- `/execute-plan` command
- Token-efficient mode (for maximum efficiency)
- After brainstorm/planning phases
- TDD workflow