patterns-vertical-tdd

# Vertical Slicing with TDD

**Violating the letter of the rules is violating the spirit of the rules.**

## Overview

Transform requirements into implementation tasks organized as vertical slices with strict TDD discipline. Each slice (called a "cycle") delivers observable, testable value and follows test-first principles.

This is a discipline-enforcing skill. The test-first structure exists because tests written after code verify implementation, not requirements. Skipping or reordering undermines the entire purpose.

## When to Use

- Transforming user stories into implementation tasks
- Creating task-mapping.md from a specification
- Structuring tasks.md with proper TDD ordering
- When implementation approach needs vertical slice organization
- Breaking down large features into testable increments
- When Task Architect generates implementation artifacts

## When NOT to Use

- **Bug fixes** - Single-task fixes don't need cycle structure
- **Documentation-only tasks** - No TDD needed for docs
- **Spike/research tasks** - Exploration doesn't follow TDD
- **Refactoring without behavior change** - Existing tests suffice
- **When tests already exist** - Don't duplicate test-first for covered code

## Core Principles

### 1. Vertical Over Horizontal

**Wrong** (horizontal slicing):
```
Phase 1: All models
Phase 2: All services
Phase 3: All endpoints
Phase 4: All tests
```

**Right** (vertical slicing):
```
Cycle 1: User creation (model + service + endpoint + test)
Cycle 2: User authentication (model + service + endpoint + test)
Cycle 3: User profile management (model + service + endpoint + test)
```

### 2. Test-First at Task Level

Every cycle structures tasks so tests come before implementation:

```
Cycle N: [Feature]
├── Task N.1: Write failing test
├── Task N.2: Implement to pass
├── Task N.3: Refactor and verify
└── Task N.4: Demo and validate
```

### 3. Foundation + Parallel

```
Foundation Cycles (sequential)
├── C1: Core data model + basic CRUD
├── C2: Authen