pipeline

# Pipeline Skill

## Overview

The pipeline skill enables chaining multiple agents together in defined workflows where the output of one agent becomes the input to the next. This creates powerful agent pipelines similar to Unix pipes but designed for AI agent orchestration.

## Core Concepts

### 1. Sequential Pipelines

The simplest form: Agent A's output flows to Agent B, which flows to Agent C.

```
explore -> architect -> executor
```

**Flow:**
1. Explore agent searches codebase and produces findings
2. Architect receives findings and produces analysis/recommendations
3. Executor receives recommendations and implements changes

### 2. Branching Pipelines

Route to different agents based on output conditions.

```
explore -> {
  if "complex refactoring" -> architect -> executor-high
  if "simple change" -> executor-low
  if "UI work" -> designer -> executor
}
```

### 3. Parallel-Then-Merge Pipelines

Run multiple agents in parallel, merge their outputs.

```
parallel(explore, researcher) -> architect -> executor
```

## Built-in Pipeline Presets

### Review Pipeline
**Purpose:** Comprehensive code review and implementation

```
/pipeline review <task>
```

**Stages:**
1. `explore` - Find relevant code and patterns
2. `architect` - Analyze architecture and design implications
3. `critic` - Review and critique the analysis
4. `executor` - Implement with full context

**Use for:** Major features, refactorings, complex changes

---

### Implement Pipeline
**Purpose:** Planned implementation with testing

```
/pipeline implement <task>
```

**Stages:**
1. `planner` - Create detailed implementation plan
2. `executor` - Implement the plan
3. `tdd-guide` - Add/verify tests

**Use for:** New features with clear requirements

---

### Debug Pipeline
**Purpose:** Systematic debugging workflow

```
/pipeline debug <issue>
```

**Stages:**
1. `explore` - Locate error locations and related code
2. `architect` - Analyze root cause
3. `build-fixer` - Apply fixes and verify

**