Workflow Designer

The Workflow Designer skill helps you design, document, and optimize multi-step AI-powered workflows. It applies process design principles to break down complex tasks into clear, executable sequences that leverage Claude Code's capabilities, external tools, and multi-agent coordination.

This skill guides you through workflow analysis, identifying optimal task decomposition, determining when to use automation versus human input, and documenting workflows in a format that's both human-readable and AI-executable. It helps you think through error handling, branching logic, validation steps, and integration points.

Use this skill when you're tackling complex, multi-step processes that could benefit from AI assistance, or when you need to transform ad-hoc procedures into repeatable, documented workflows.

Core Workflows

Workflow 1: Design New Workflow from Requirements

1. Clarify the goal:
   • What outcome is needed?
   • Who initiates the workflow?
   • What triggers completion?
2. Identify inputs and outputs:
   • What data/context is required to start?
   • What should the workflow produce?
   • What format should outputs take?
3. Map the process:
   • Break into logical phases
   • Identify decision points
   • Map dependencies between steps
   • Note parallel vs sequential operations
4. Design error handling:
   • What can go wrong at each step?
   • How should failures be handled?
   • What requires human intervention?
5. Assign responsibilities:
   • Which steps are AI-executable?
   • Which require human judgment?
   • Which need external tools/APIs?
6. Document the workflow:
   • Step-by-step instructions
   • Decision trees
   • Validation checkpoints
   • Success criteria
7. Test with sample scenario
8. Refine based on results

Workflow 2: Optimize Existing Workflow

1. Analyze current workflow:
   • Map current steps
   • Identify bottlenecks
   • Note repetitive tasks
   • Find error-prone areas
2. Identify optimization opportunities:
   • What can be automated?
   • What can be parallelized?
   • What steps are unnecessary?
   • Where are handoffs inefficient?
3. Redesign with improvements:
   • Consolidate redundant steps
   • Automate repetitive tasks
   • Parallelize independent operations
   • Add validation early
4. Compare before/after:
   • Time savings
   • Error reduction
   • Complexity changes
   • Resource requirements
5. Document changes and rationale
6. Plan migration from old to new
7. Test new workflow thoroughly

Workflow 3: Break Down Complex Task

1. Understand the complex task:
   • What makes it complex?
   • What are the components?
   • What are the constraints?
2. Decompose into subtasks:
   • Identify logical boundaries
   • Group related operations
   • Order by dependencies
3. Define interfaces:
   • Inputs for each subtask
   • Outputs from each subtask
   • Data flow between tasks
4. Assign to appropriate executors:
   • AI agents
   • External tools/MCPs
   • Human review points
5. Add coordination layer:
   • How do subtasks communicate?
   • What monitors overall progress?
   • How are results integrated?
6. Document the decomposition
7. Validate completeness

Workflow 4: Add Error Handling & Resilience

1. Map potential failure points:
   • External API failures
   • Invalid inputs
   • Resource constraints
   • Timeout scenarios
2. Design error handling strategy:
   • Graceful degradation
   • Retry logic with backoff
   • Fallback options
   • Error reporting
3. Add validation checkpoints:
   • Pre-conditions before steps
   • Post-conditions after steps
   • Intermediate result validation
4. Implement recovery mechanisms:
   • State preservation
   • Resume from checkpoint
   • Rollback procedures
5. Document error scenarios:
   • What to do when X fails
   • How to recover
   • When to escalate
6. Test failure scenarios

Quick Reference

Best Practices

• Start with Outcomes: Define success before designing steps

  • What does "done" look like?
  • What artifacts should exist?
  • What state should system be in?

• Keep Steps Atomic: Each step should be single-purpose

  • One clear action
  • One clear output
  • Easy to validate
  • Easy to replace or improve

• Make Dependencies Explicit: Show what relies on what

  • Use directed graphs or numbered dependencies
  • Identify parallelizabl

...