ai-dlc-backpressure

# AI-DLC Backpressure

Backpressure is automated enforcement that blocks progress until quality standards are met. Instead of prescribing process steps, backpressure creates natural incentives for quality.

## The Problem with Prescription

Traditional development processes prescribe steps:

```markdown
1. Write tests first
2. Run linter before commit
3. Get code review approval
4. Deploy to staging before production
```

These become checkbox exercises:
- Teams learn to game the process
- Quality checks become formalities
- "Did you run the linter?" → "Yes" (actually: no)

## The Backpressure Alternative

Backpressure makes quality gates **blocking**:

```bash
# You cannot proceed until tests pass
bun test || exit 1

# You cannot proceed until lint is clean
biome check || exit 1

# You cannot proceed until types check
tsc --noEmit || exit 1
```

The AI learns to satisfy these constraints naturally because it **cannot complete work** until they pass.

## How Backpressure Works

### The Feedback Loop

```
AI writes code
      ↓
Stop hook runs backpressure checks
      ↓
┌─────────────────────────────────┐
│ Tests pass?                      │
│ Lint clean?                      │
│ Types check?                     │
└─────────────────────────────────┘
      ↓                    ↓
   PASS                  FAIL
      ↓                    ↓
 Proceed            Fix and retry
```

### Behavioral Learning

Over iterations, the AI learns:
- "If I don't write tests, I'll be blocked"
- "If I introduce type errors, I'll have to fix them"
- "Lint errors mean more work for me"

This creates intrinsic motivation for quality, not extrinsic compliance.

## Types of Backpressure

### 1. Test Backpressure

```yaml
# han-plugin.yml
hooks:
  test:
    command: bun test
    event: Stop
```

**Effect:** AI cannot complete work if tests fail.

**AI learns to:**
- Write tests for new code
- Fix broken tests immediately
- Consider test implications of changes

### 2. Type Backpressure

```yam