v1.0.0 to v1.0.0

3 added, 315 removed. Audit A to A.

---

name: stream-chain

description: Stream-JSON chaining for multi-agent pipelines, data transformation, and sequential workflows. Use when piping output between agents/tools as streaming JSON or building a sequential transform pipeline.

version: 1.0.0

category: workflow

tags: [streaming, pipeline, chaining, multi-agent, workflow]

---

# Stream-Chain Skill

Execute sophisticated multi-step workflows where each agent's output flows into the next, enabling complex data transformations and sequential processing pipelines.

## Overview

Stream-Chain provides two powerful modes for orchestrating multi-agent workflows:

1. **Custom Chains** (`run`): Execute custom prompt sequences with full control

2. **Predefined Pipelines** (`pipeline`): Use battle-tested workflows for common tasks

Each step in a chain receives the complete output from the previous step, enabling sophisticated multi-agent coordination through streaming data flow.

---

## Quick Start

### Run a Custom Chain

```bash

claude-flow stream-chain run \

"Analyze codebase structure" \

"Identify improvement areas" \

"Generate action plan"

```

### Execute a Pipeline

```bash

claude-flow stream-chain pipeline analysis

```

---

- ## Custom Chains (`run`)

- Execute custom stream chains with your own prompts for maximum flexibility.

- ### Syntax

- ```bash

- claude-flow stream-chain run <prompt1> <prompt2> [...] [options]

- ```

- **Requirements:**

- - Minimum 2 prompts required

- - Each prompt becomes a step in the chain

- - Output flows sequentially through all steps

- ### Options

- | Option | Description | Default |

- |--------|-------------|---------|

- | `--verbose` | Show detailed execution information | `false` |

- | `--timeout <seconds>` | Timeout per step | `30` |

- | `--debug` | Enable debug mode with full logging | `false` |

- ### How Context Flows

- Each step receives the previous output as context:

- ```

- Step 1: "Write a sorting function"

- Output: [function implementation]

- Step 2 receives:

- "Previous step output:

- [function implementation]

- Next task: Add comprehensive tests"

- Step 3 receives:

- "Previous steps output:

- [function + tests]

- Next task: Optimize performance"

- ```

- ### Examples

- #### Basic Development Chain

- ```bash

- claude-flow stream-chain run \

- "Write a user authentication function" \

- "Add input validation and error handling" \

- "Create unit tests with edge cases"

- ```

- #### Security Audit Workflow

- ```bash

- claude-flow stream-chain run \

- "Analyze authentication system for vulnerabilities" \

- "Identify and categorize security issues by severity" \

- "Propose fixes with implementation priority" \

- "Generate security test cases" \

- --timeout 45 \

- --verbose

- ```

- #### Code Refactoring Chain

- ```bash

- claude-flow stream-chain run \

- "Identify code smells in src/ directory" \

- "Create refactoring plan with specific changes" \

- "Apply refactoring to top 3 priority items" \

- "Verify refactored code maintains behavior" \

- --debug

- ```

- #### Data Processing Pipeline

- ```bash

- claude-flow stream-chain run \

- "Extract data from API responses" \

- "Transform data into normalized format" \

- "Validate data against schema" \

- "Generate data quality report"

- ```

- ---

- ## Predefined Pipelines (`pipeline`)

- Execute battle-tested workflows optimized for common development tasks.

- ### Syntax

- ```bash

- claude-flow stream-chain pipeline <type> [options]

- ```

- ### Available Pipelines

- #### 1. Analysis Pipeline

- Comprehensive codebase analysis and improvement identification.

- ```bash

- claude-flow stream-chain pipeline analysis

- ```

- **Workflow Steps:**

- 1. **Structure Analysis**: Map directory structure and identify components

- 2. **Issue Detection**: Find potential improvements and problems

- 3. **Recommendations**: Generate actionable improvement report

- **Use Cases:**

- - New codebase onboarding

- - Technical debt assessment

- - Architecture review

- - Code quality audits

- #### 2. Refactor Pipeline

- Systematic code refactoring with prioritization.

- ```bash

- claude-flow stream-chain pipeline refactor

- ```

- **Workflow Steps:**

- 1. **Candidate Identification**: Find code needing refactoring

- 2. **Prioritization**: Create ranked refactoring plan

- 3. **Implementation**: Provide refactored code for top priorities

- **Use Cases:**

- - Technical debt reduction

- - Code quality improvement

- - Legacy code modernization

- - Design pattern implementation

- #### 3. Test Pipeline

- Comprehensive test generation with coverage analysis.

- ```bash

- claude-flow stream-chain pipeline test

- ```

- **Workflow Steps:**

- 1. **Coverage Analysis**: Identify areas lacking tests

- 2. **Test Design**: Create test cases for critical functions

- 3. **Implementation**: Generate unit tests with assertions

- **Use Cases:**

- - Increasing test coverage

- - TDD workflow support

- - Regression test creation

- - Quality assurance

- #### 4. Optimize Pipeline

- Performance optimization with profiling and implementation.

- ```bash

- claude-flow stream-chain pipeline optimize

- ```

- **Workflow Steps:**

- 1. **Profiling**: Identify performance bottlenecks

- 2. **Strategy**: Analyze and suggest optimization approaches

- 3. **Implementation**: Provide optimized code

- **Use Cases:**

- - Performance improvement

- - Resource optimization

- - Scalability enhancement

- - Latency reduction

- ### Pipeline Options

- | Option | Description | Default |

- |--------|-------------|---------|

- | `--verbose` | Show detailed execution | `false` |

- | `--timeout <seconds>` | Timeout per step | `30` |

- | `--debug` | Enable debug mode | `false` |

- ### Pipeline Examples

- #### Quick Analysis

- ```bash

- claude-flow stream-chain pipeline analysis

- ```

- #### Extended Refactoring

- ```bash

- claude-flow stream-chain pipeline refactor --timeout 60 --verbose

- ```

- #### Debug Test Generation

- ```bash

- claude-flow stream-chain pipeline test --debug

- ```

- #### Comprehensive Optimization

- ```bash

- claude-flow stream-chain pipeline optimize --timeout 90 --verbose

- ```

- ### Pipeline Output

- Each pipeline execution provides:

- - **Progress**: Step-by-step execution status

- - **Results**: Success/failure per step

- - **Timing**: Total and per-step execution time

- - **Summary**: Consolidated results and recommendations

- ---

- ## Custom Pipeline Definitions

- Define reusable pipelines in `.claude-flow/config.json`:

- ### Configuration Format

- ```json

- {

- "streamChain": {

- "pipelines": {

- "security": {

- "name": "Security Audit Pipeline",

- "description": "Comprehensive security analysis",

- "prompts": [

- "Scan codebase for security vulnerabilities",

- "Categorize issues by severity (critical/high/medium/low)",

- "Generate fixes with priority and implementation steps",

- "Create security test suite"

- ],

- "timeout": 45

- },

- "documentation": {

- "name": "Documentation Generation Pipeline",

- "prompts": [

- "Analyze code structure and identify undocumented areas",

- "Generate API documentation with examples",

- "Create usage guides and tutorials",

- "Build architecture diagrams and flow charts"

- ]

- }

- ```

- ### Execute Custom Pipeline

- ```bash

- claude-flow stream-chain pipeline security

- claude-flow stream-chain pipeline documentation

- ```

- ---

- ## Advanced Use Cases

- ### Multi-Agent Coordination

- Chain different agent types for complex workflows:

- ```bash

- claude-flow stream-chain run \

- "Research best practices for API design" \

- "Design REST API with discovered patterns" \

- "Implement API endpoints with validation" \

- "Generate OpenAPI specification" \

- "Create integration tests" \

- "Write deployment documentation"

- ```

- ### Data Transformation Pipeline

- Process and transform data through multiple stages:

- ```bash

- claude-flow stream-chain run \

- "Extract user data from CSV files" \

- "Normalize and validate data format" \

- "Enrich data with external API calls" \

- "Generate analytics report" \

- "Create visualization code"

- ```

- ### Code Migration Workflow

- Systematic code migration with validation:

- ```bash

- claude-flow stream-chain run \

- "Analyze legacy codebase dependencies" \

- "Create migration plan with risk assessment" \

- "Generate modernized code for high-priority modules" \

- "Create migration tests" \

- "Document migration steps and rollback procedures"

- ```

+ ## Reference

- ### Quality Assurance Chain

- Comprehensive code quality workflow:

+ The full detail lives in `references/` and loads only when needed:

- ```bash

- claude-flow stream-chain pipeline analysis

- claude-flow stream-chain pipeline refactor

- claude-flow stream-chain pipeline test

- claude-flow stream-chain pipeline optimize

- ```

+ - [`references/pipelines.md`](references/pipelines.md) — custom chains, predefined pipelines, custom pipeline definitions & advanced use cases.

---

## Best Practices

### 1. Clear and Specific Prompts

**Good:**

```bash

"Analyze authentication.js for SQL injection vulnerabilities"

```

**Avoid:**

```bash

"Check security"

```

### 2. Logical Progression

Order prompts to build on previous outputs:

```bash

1. "Identify the problem"

2. "Analyze root causes"

3. "Design solution"

4. "Implement solution"

5. "Verify implementation"

```

### 3. Appropriate Timeouts

- Simple tasks: 30 seconds (default)

- Analysis tasks: 45-60 seconds

- Implementation tasks: 60-90 seconds

- Complex workflows: 90-120 seconds

### 4. Verification Steps

Include validation in your chains:

```bash

claude-flow stream-chain run \

"Implement feature X" \

"Write tests for feature X" \

"Verify tests pass and cover edge cases"

```

### 5. Iterative Refinement

Use chains for iterative improvement:

```bash

claude-flow stream-chain run \

"Generate initial implementation" \

"Review and identify issues" \

"Refine based on issues found" \

"Final quality check"

```

---

## Integration with Claude Flow

### Combine with Swarm Coordination

```bash

# Initialize swarm for coordination

claude-flow swarm init --topology mesh

# Execute stream chain with swarm agents

claude-flow stream-chain run \

"Agent 1: Research task" \

"Agent 2: Implement solution" \

"Agent 3: Test implementation" \

"Agent 4: Review and refine"

```

### Memory Integration

Stream chains automatically store context in memory for cross-session persistence:

```bash

# Execute chain with memory

claude-flow stream-chain run \

"Analyze requirements" \

"Design architecture" \

--verbose

# Results stored in .claude-flow/memory/stream-chain/

```

### Neural Pattern Training

Successful chains train neural patterns for improved performance:

```bash

# Enable neural training

claude-flow stream-chain pipeline optimize --debug

# Patterns learned and stored for future optimizations

```

---

## Troubleshooting

### Chain Timeout

If steps timeout, increase timeout value:

```bash

claude-flow stream-chain run "complex task" --timeout 120

```

### Context Loss

If context not flowing properly, use `--debug`:

```bash

claude-flow stream-chain run "step 1" "step 2" --debug

```

### Pipeline Not Found

Verify pipeline name and custom definitions:

```bash

# Check available pipelines

cat .claude-flow/config.json | grep -A 10 "streamChain"

```

---

## Performance Characteristics

- **Throughput**: 2-5 steps per minute (varies by complexity)

- **Context Size**: Up to 100K tokens per step

- **Memory Usage**: ~50MB per active chain

- **Concurrency**: Supports parallel chain execution

---

## Related Skills

- **SPARC Methodology**: Systematic development workflow

- **Swarm Coordination**: Multi-agent orchestration

- **Memory Management**: Persistent context storage

- **Neural Patterns**: Adaptive learning

---

## Examples Repository

### Complete Development Workflow

```bash

# Full feature development chain

claude-flow stream-chain run \

"Analyze requirements for user profile feature" \

"Design database schema and API endpoints" \

"Implement backend with validation" \

"Create frontend components" \

"Write comprehensive tests" \

"Generate API documentation" \

--timeout 60 \

--verbose

```

### Code Review Pipeline

```bash

# Automated code review workflow

claude-flow stream-chain run \

"Analyze recent git changes" \

"Identify code quality issues" \

"Check for security vulnerabilities" \

"Verify test coverage" \

"Generate code review report with recommendations"

```

### Migration Assistant

```bash

# Framework migration helper

claude-flow stream-chain run \

"Analyze current Vue 2 codebase" \

"Identify Vue 3 breaking changes" \

"Create migration checklist" \

"Generate migration scripts" \

"Provide updated code examples"

```

---

## Conclusion

Stream-Chain enables sophisticated multi-step workflows by:

- **Sequential Processing**: Each step builds on previous results

- **Context Preservation**: Full output history flows through chain

- **Flexible Orchestration**: Custom chains or predefined pipelines

- **Agent Coordination**: Natural multi-agent collaboration pattern

- **Data Transformation**: Complex processing through simple steps

Use `run` for custom workflows and `pipeline` for battle-tested solutions.