executing-plans

# Executing Plans

## Overview

Load plan, review critically with Shannon's quantitative lens, execute tasks in batches, run validation gates, report for review between batches.

**Core principle**: Batch execution with checkpoints + Shannon validation gates = systematic quality.

**Announce at start**: "I'm using the executing-plans skill to implement this plan."

## The Process

### Step 1: Load and Review Plan with Shannon Analysis

**1. Read plan file** (use forced-reading-protocol if >3000 lines)

**2. Extract Shannon metadata**:
```python
metadata = {
    "complexity": extract_complexity_score(plan),  # 0.00-1.00
    "total_tasks": count_tasks(plan),
    "estimated_duration": extract_duration(plan),
    "validation_tiers": extract_validation_tiers(plan),
    "mcp_requirements": extract_mcps(plan),
    "domain_distribution": extract_domains(plan)
}
```

**3. Review critically**:
- Identify any questions or concerns about the plan
- Check if Shannon metadata is present
- Verify validation gates are specified
- Confirm MCP requirements are available

**4. If concerns**: Raise them with your human partner before starting

**5. If no concerns**: Create TodoWrite and proceed

**Shannon tracking**: Save plan review to Serena:
```python
serena.write_memory(f"execution/{execution_id}/review", {
    "plan_id": plan_id,
    "metadata": metadata,
    "concerns": [],
    "ready_to_execute": True,
    "timestamp": ISO_timestamp
})
```

### Step 2: Calculate Batch Size (Shannon Enhancement)

**Complexity-based batch sizing**:

```python
def calculate_batch_size(plan_complexity: float) -> int:
    """
    Shannon formula: More complex = smaller batches
    
    complexity=0.1 → batch=5 (simple, can do many)
    complexity=0.5 → batch=3 (moderate, typical)
    complexity=0.9 → batch=1 (complex, one at a time)
    """
    base_size = max(1, min(5, int(10 * (1 - plan_complexity))))
    return base_size

# Example:
plan_complexity = 0.62  # From plan header
batch_size = calculate