Speculative Pipeline

Speculative-pipeline Strategy

Run pipeline stages with staggered timing instead of sequentially. The leader starts first; followers start after a configurable delay and build from whatever upstream output exists at that point. Combined with convergence loops, followers self-correct as upstream artifacts arrive and stabilize.

Core Principle

Start downstream work early with partial upstream output. Convergence loops correct the errors introduced by working from incomplete input.

The insight is that waiting for perfect upstream output is wasteful. A follower working from 80% of the upstream artifacts will produce output that is ~60-70% correct on the first pass. But with convergence loops running, the follower re-reads the upstream artifacts on each iteration and corrects course. By the time the leader finishes, the follower is already most of the way done.

The Pattern

Sequential (Traditional)

Stage 1: Specs     ████████████████████                          (5 hours)
Stage 2: Plans                         ████████████████          (4 hours)
Stage 3: Implement                                     ████████  (3 hours)
                   ─────────────────────────────────────────────
                   Total: 12 hours

Speculative-pipeline (Staggered)

Stage 1: Specs     ████████████████████                          (5 hours)
Stage 2: Plans            ████████████████                       (4 hours, started 1.5h after Stage 1)
Stage 3: Implement              ████████████                     (3 hours, started 3h after Stage 1)
                   ─────────────────────────────────────────────
                   Total: ~7 hours

Why It Works

1. Stage 2 starts after a 1.5-hour offset. By then, Stage 1 has produced a meaningful set of partial specs.
2. Stage 2 generates plans from whatever specs are available. Some plans will be built on incomplete information.
3. Stage 1 keeps refining specs. When Stage 2 loops back for its next pass, it picks up the newly completed specs and adjusts its plans accordingly.
4. Stage 3 starts after a 3-hour offset. By then, both specs and plans exist in draft form.
5. All stages self-correct through iteration. Each pass re-reads the latest upstream artifacts. Mistakes caused by working from partial input are washed out on subsequent passes.

The key mechanism is convergence -- the iterative loop that re-reads inputs each pass. Without convergence loops, speculative-pipeline would produce garbage. With them, early errors wash out over iterations.

Example: 3-Stage Pipeline

Directory Structure

context/
├── specs/              # Stage 1 output: implementation-agnostic specs
├── plans/              # Stage 2 output: framework-specific plans
├── impl/               # Stage 3 output: implementation tracking
└── prompts/
    ├── 001-generate-specs.md       # Stage 1 prompt
    ├── 002-generate-plans.md       # Stage 2 prompt
    └── 003-implement.md            # Stage 3 prompt

Terminal Commands

Open three terminal windows (or use tmux panes):

# Terminal 1: Specs from reference materials (leader -- starts immediately)
{LOOP_TOOL} context/prompts/001-generate-specs.md -n 5 -t 2h

# Terminal 2: Plans from specs (follower -- starts after 1-hour delay)
{LOOP_TOOL} context/prompts/002-generate-plans.md -n 5 -t 2h -d 1h

# Terminal 3: Implementation from plans (follower -- starts after 2-hour delay)
{LOOP_TOOL} context/prompts/003-implement.md -n 10 -t 1h -d 2h

Parameter reference:

• -n 5 -- Run up to 5 convergence iterations
• -t 2h -- Time budget per iteration (max total time = iterations x budget)
• -d 1h -- Delay before starting (speculative-pipeline offset)

Replace {LOOP_TOOL} with your convergence loop runner (any script or tool that repeatedly executes a prompt against the codebase, committing between iterations).

What Happens Chronologically

Result: ~7 hours total versus ~12 hours sequential.

Choosing Delay Values

The delay determines how much upstream work exists when the follower starts. Too short and the follower wastes iterations on garbage input. Too long and you lose the time savings.

Guidelines

Rules of Thumb

1. Delay >= 1 upstream iteration. The follower should not start until the leader has completed at least one full iteration and committed results.
2. Delay < 50% of upstream duration. If the delay is longer than half the upstream time, the time savings are marginal.
3. More follower iterations compensate for shorter delays. If you start the follower early (aggressive delay), give it more iterations to converge.

Multi-Stage Pipelines (4+ Stages)

For pipelines with more than 3 stages, stagger each stage relative to Stage 1:

# 5-stage pipeline example
{LOOP_TOOL} {PROMPT_001} -n 5 -t 2h           # Stage 1: starts immediately
{LOOP_TOOL} {PROMPT_002} -n 5 -t 2h -d 1h     # Stage 2: 1h delay
{LOOP_TOOL} {PROMPT_003} -n 8 -t 1h -d 2h     # Stage 3: 2h delay
{LOOP_TOOL} {PROMPT_004} -n 8 -t 1h -d 3h     # Stage 4: 3h delay
{LOOP_TOOL} {PROMPT_005} -n 10 -t 45m -d 4h   # Stage 5: 4h delay

Notice the pattern:

• Later stages get more iterations (they need more correction cycles)
• Later stages get shorter time budgets per iteration (less work per stage)
• Delays increase linearly (each stage offset by roughly 1 hour)

When Speculative-pipeline Works Best

Good Fit

• Long pipelines (3+ stages): The time savings scale with pipeline depth
• Stages that share a git repo: Followers read upstream commits automatically
• Stages with convergence loops: The self-correction mechanism is essential
• Specs that are mostly stable after 1-2 iterations: Partial specs are useful early