plan

# Writing Implementation Plans

## Overview

Create comprehensive implementation plans assuming the engineer has zero context.
Document everything: which files to touch, complete code snippets, how to test.
Break work into bite-sized tasks. DRY. YAGNI. TDD. Frequent commits.

**Core principle:** Each task is 2-5 minutes of work. Test first, implement second.

**Announce at start:** "I'm using the plan skill to create the implementation plan."

**Save plans to:** `docs/plans/YYYY-MM-DD-<feature-name>.md`

## Bite-Sized Task Granularity

**Each step is ONE action (2-5 minutes):**

```
Task N: Add validation function

Step 1: Write the failing test
Step 2: Run it to verify it fails
Step 3: Implement minimal code to pass
Step 4: Run tests to verify they pass
Step 5: Commit
```

**NOT acceptable:**
- "Implement validation with tests" (too vague)
- "Add function and write tests" (multiple actions)

## Plan Document Structure

**Every plan MUST start with this header:**

```markdown
# [Feature Name] Implementation Plan

> **For Claude:** Use kodo:execute skill to implement this plan task-by-task.

**Goal:** [One sentence describing what this builds]

**Architecture:** [2-3 sentences about approach]

**Tech Stack:** [Key technologies/libraries]

**GitHub Issue:** [Link if exists, or "Create with `kodo track issue`"]

---
```

## Task Structure Template

```markdown
### Task N: [Component Name]

**Files:**
- Create: `exact/path/to/file.rs`
- Modify: `exact/path/to/existing.rs:123-145`
- Test: `tests/exact/path/to/test.rs`

**Step 1: Write the failing test**

```rust
#[test]
fn test_specific_behavior() {
    let result = function(input);
    assert_eq!(result, expected);
}
```

**Step 2: Run test to verify it fails**

Run: `cargo test test_specific_behavior`
Expected: FAIL with "cannot find function `function`"

**Step 3: Write minimal implementation**

```rust
pub fn function(input: Input) -> Output {
    // Minimal implementation
    expected
}
```

**Step 4: Run test to ve