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:

• Custom Chains (run ): Execute custom prompt sequences with full control

• 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

claude-flow stream-chain run
"Analyze codebase structure"
"Identify improvement areas"
"Generate action plan"

Execute a Pipeline

claude-flow stream-chain pipeline analysis

Custom Chains (run )

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

Syntax

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

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

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

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

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

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

Available Pipelines

1. Analysis Pipeline

Comprehensive codebase analysis and improvement identification.

claude-flow stream-chain pipeline analysis

Workflow Steps:

• Structure Analysis: Map directory structure and identify components

• Issue Detection: Find potential improvements and problems

• 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.

claude-flow stream-chain pipeline refactor

Workflow Steps:

• Candidate Identification: Find code needing refactoring

• Prioritization: Create ranked refactoring plan

• 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.

claude-flow stream-chain pipeline test

Workflow Steps:

• Coverage Analysis: Identify areas lacking tests

• Test Design: Create test cases for critical functions

• 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.

claude-flow stream-chain pipeline optimize

Workflow Steps:

• Profiling: Identify performance bottlenecks

• Strategy: Analyze and suggest optimization approaches

• 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

claude-flow stream-chain pipeline analysis

Extended Refactoring

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

Debug Test Generation

claude-flow stream-chain pipeline test --debug

Comprehensive Optimization

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

{ "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

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:

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:

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:

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"

Quality Assurance Chain

Comprehensive code quality workflow:

claude-flow stream-chain pipeline analysis claude-flow stream-chain pipeline refactor claude-flow stream-chain pipeline test claude-flow stream-chain pipeline optimize

Best Practices

1. Clear and Specific Prompts

Good:

"Analyze authentication.js for SQL injection vulnerabilities"

Avoid:

"Check security"

2. Logical Progression

Order prompts to build on previous outputs:

1. "Identify the problem"

2. "Analyze root causes"

3. "Design solution"

4. "Implement solution"

5. "Verify implementation"

6. 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:

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:

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

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:

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:

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:

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

Context Loss

If context not flowing properly, use --debug :

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

Pipeline Not Found

Verify pipeline name and custom definitions:

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

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

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

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.