workflow-composer

What this skill does

# Workflow Composer

**⚡ UNIQUE FEATURE**: First skill that lets you chain multiple Claude Code skills together into automated workflows with conditional logic, parallel execution, and error handling. Create complex automation pipelines with simple YAML configs.

## What This Skill Does

Orchestrates multiple skills into powerful automated workflows:

- **Chain skills together**: Output of one skill becomes input to the next
- **Parallel execution**: Run multiple skills simultaneously
- **Conditional logic**: IF/THEN/ELSE based on skill results
- **Error handling**: Retry logic and fallback strategies
- **Progress tracking**: Real-time status of workflow execution
- **Workflow templates**: Save and reuse common workflows
- **Schedule workflows**: Run workflows on triggers or schedules

## Why This Is Revolutionary

This is the **first skill-composition framework** for Claude Code:
- **No coding required**: Define workflows in simple YAML
- **Visual workflow builder**: Generate workflow configs interactively
- **Reusable components**: Build once, use everywhere
- **Enterprise-ready**: Error handling, logging, notifications
- **Community workflows**: Share workflows with others

## Workflow Structure

```yaml
name: my-workflow
description: What this workflow does
version: 1.0.0

# Input parameters
inputs:
  project_path:
    type: string
    required: true
  run_tests:
    type: boolean
    default: true

# Workflow steps
steps:
  # Sequential steps
  - name: generate-readme
    skill: readme-generator
    inputs:
      path: ${inputs.project_path}

  - name: generate-tests
    skill: unit-test-generator
    inputs:
      target: ${inputs.project_path}/src
    when: ${inputs.run_tests}

  # Parallel execution
  - name: quality-checks
    parallel:
      - name: security-scan
        skill: security-auditor
        inputs:
          path: ${inputs.project_path}

      - name: lint-code
        skill: code-linter
        inputs:
          path: ${inputs.project_path}

  # Conditional logic
  - name: fix-issues
    skill: auto-fixer
    when: ${steps.quality-checks.security-scan.issues > 0}
    inputs:
      issues: ${steps.quality-checks.security-scan.results}

  # Error handling
  - name: deploy
    skill: deploy-orchestrator
    inputs:
      environment: production
    retry:
      max_attempts: 3
      backoff: exponential
    on_failure:
      - skill: rollback
      - skill: notify-team
        inputs:
          message: "Deployment failed"

# Output mapping
outputs:
  readme_path: ${steps.generate-readme.output.file_path}
  test_coverage: ${steps.generate-tests.output.coverage}
  security_issues: ${steps.quality-checks.security-scan.issues}
```

## Instructions

### Creating a Workflow

When a user wants to create a workflow:

1. **Interactive Workflow Builder**:
   ```
   Ask user:
   - What's the goal of this workflow?
   - Which skills should be included?
   - Should any skills run in parallel?
   - What are the inputs needed?
   - What conditions/logic are needed?
   ```

2. **Generate Workflow YAML**:
   - Create well-structured YAML file
   - Add comments explaining each step
   - Include error handling
   - Validate syntax

3. **Save Workflow**:
   - Use Write to create `.claude-workflows/workflow-name.yml`
   - Add to workflow registry
   - Create documentation

### Running a Workflow

When a user wants to run a workflow:

1. **Load Workflow**:
   ```bash
   Use Read to load workflow YAML from .claude-workflows/
   ```

2. **Validate Inputs**:
   - Check all required inputs provided
   - Validate input types
   - Set defaults for optional inputs

3. **Create Execution Plan**:
   ```
   - Parse workflow steps
   - Identify parallel vs sequential
   - Build dependency graph
   - Prepare Task agents
   ```

4. **Execute Workflow**:
   ```
   For each step:
     - Check 'when' condition (skip if false)
     - If parallel block:
       - Launch all Task agents simultaneously
       - Wait for all to complete
     - If sequential:
       - Execute skill via Task agent
       - Capture output
       - Pass to next step
     - Handle errors:
       - Retry if configured
       - Run on_failure steps
       - Stop or continue based on config
   ```

5. **Track Progress**:
   - Use TodoWrite to show workflow progress
   - Update status for each step
   - Show current step and completion percentage

6. **Generate Report**:
   ```markdown
   # Workflow Execution Report

   **Workflow**: ${workflow.name}
   **Started**: ${start_time}
   **Duration**: ${duration}
   **Status**: ✅ Success / ⚠️ Partial / ❌ Failed

   ## Steps
   1. ✅ generate-readme (2.3s)
   2. ✅ generate-tests (5.1s)
   3. ⏭️ fix-issues (skipped - no issues found)
   4. ✅ deploy (12.4s)

   ## Outputs
   - readme_path: /project/README.md
   - test_coverage: 87%
   - deployment_url: https://app.example.com
   ```

## Example Workflows

### Example 1: Complete Project Setup

```yaml
name: project-setup
description: Initialize new project with README, tests, CI/CD, and docs

steps:
  - name: scaffold
    skill: project-scaffolder
    inputs:
      type: ${inputs.project_type}
      name: ${inputs.project_name}

  - name: generate-files
    parallel:
      - name: readme
        skill: readme-generator

      - name: gitignore
        skill: gitignore-generator

      - name: license
        skill: license-picker
        inputs:
          license_type: MIT

  - name: setup-tests
    skill: unit-test-generator
    inputs:
      coverage_target: 80

  - name: setup-cicd
    skill: ci-cd-wizard
    inputs:
      platform: github-actions

  - name: init-git
    skill: git-initializer
    inputs:
      remote: ${inputs.git_remote}
```

**Usage:**
```
User: "Set up a new Python project called 'my-api'"

Workflow Composer:
- Prompts for project type, git remote
- Executes all steps
- Shows progress
- Reports results
```

### Example 2: Pre-Commit Workflow

```yaml
name: pre-commit-checks
description: Run all quality checks before committing code

steps:
  - name: quality-checks
    parallel:
      - name: lint
        skill: code-linter

      - name: format
        skill: code-formatter

      - name: security
        skill: security-auditor

      - name: tests
        skill: test-runner

  - name: fix-issues
    when: ${steps.quality-checks.lint.issues > 0}
    skill: auto-fixer
    inputs:
      auto_fix: true

  - name: verify
    when: ${steps.fix-issues.ran}
    skill: test-runner
```

### Example 3: Deploy Pipeline

```yaml
name: deploy-pipeline
description: Complete deployment with tests, build, and monitoring setup

steps:
  - name: pre-deploy-checks
    parallel:
      - skill: test-runner
      - skill: security-auditor
      - skill: dependency-checker

  - name: build
    when: ${steps.pre-deploy-checks.all_passed}
    skill: build-optimizer

  - name: deploy
    skill: deploy-orchestrator
    inputs:
      environment: ${inputs.environment}
      strategy: blue-green
    retry:
      max_attempts: 3

  - name: post-deploy
    parallel:
      - skill: health-checker
      - skill: performance-tester
      - skill: log-analyzer

  - name: notify
    skill: slack-bridge
    inputs:
      channel: deployments
      message: "✅ Deployed ${inputs.environment}"
```

## Built-in Workflow Templates

### 1. New Feature Workflow
- Create feature branch
- Generate boilerplate
- Create tests
- Setup documentation
- Create PR

### 2. Code Review Workflow
- Run linters
- Check security
- Verify tests
- Review architecture
- Post review comments

### 3. Bug Fix Workflow
- Reproduce bug
- Generate failing test
- Apply fix
- Verify fix
- Update changelog

### 4. Release Workflow
- Update version
- Generate changelog
- Run full test suite
- Build artifacts
- Create release notes
- Tag release

## Tool Requirements

- **Read**: Load workflow definitions
- **Write**: Save workflows and reports
- **Bash**: Execute commands, git operations
- **Task**: Launch skills as agents
- **TodoWrite**: Track work