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

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

Creating src/services/user-service.test.ts:

[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 natural language:

"switch to implementation mode" "just code it" "execute the plan"


---

## 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 |

---

## Tool Usage

### Built-in Tools (Primary)

Use Claude Code built-in tools for file operations:

Read to check existing code
Write to create new files
Edit for modifications
Grep/Glob to find patterns to follow


### MCP Integration

#### Context7

For accurate library usage:

Fetch current API documentation
Get correct patterns and examples


#### Memory

Recall implementation context:

Remember established patterns
Recall user preferences
Store decisions for consistency


## Combines Well With

- `executing-plans` skill (structured plan execution)
- `test-driven-development` skill (TDD workflow)
- Token-efficient mode (for maximum efficiency)
- After brainstorm/planning phases

2.4 KiB Raw Blame History