name: Workflow Designer
slug: workflow-designer
description: Design and optimize AI-powered workflows for complex tasks
category: meta
complexity: complex
version: "1.0.0"
author: "ID8Labs"
triggers:
- "design a workflow"
- "create workflow"
- "optimize workflow"
- "workflow designer"
- "plan workflow"
tags:
- workflow-design
- process-optimization
- automation

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:
2. What outcome is needed?
3. Who initiates the workflow?
4. What triggers completion?
5. Identify inputs and outputs:
6. What data/context is required to start?
7. What should the workflow produce?
8. What format should outputs take?
9. Map the process:
10. Break into logical phases
11. Identify decision points
12. Map dependencies between steps
13. Note parallel vs sequential operations
14. Design error handling:
15. What can go wrong at each step?
16. How should failures be handled?
17. What requires human intervention?
18. Assign responsibilities:
19. Which steps are AI-executable?
20. Which require human judgment?
21. Which need external tools/APIs?
22. Document the workflow:
23. Step-by-step instructions
24. Decision trees
25. Validation checkpoints
26. Success criteria
27. Test with sample scenario
28. Refine based on results

Workflow 2: Optimize Existing Workflow

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

Workflow 3: Break Down Complex Task

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

Workflow 4: Add Error Handling & Resilience

1. Map potential failure points:
2. External API failures
3. Invalid inputs
4. Resource constraints
5. Timeout scenarios
6. Design error handling strategy:
7. Graceful degradation
8. Retry logic with backoff
9. Fallback options
10. Error reporting
11. Add validation checkpoints:
12. Pre-conditions before steps
13. Post-conditions after steps
14. Intermediate result validation
15. Implement recovery mechanisms:
16. State preservation
17. Resume from checkpoint
18. Rollback procedures
19. Document error scenarios:
20. What to do when X fails
21. How to recover
22. When to escalate
23. 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 parallelizable operations

• Note blocking dependencies

• Plan for Failure: Every workflow has edge cases

• What if API is down?
• What if input is malformed?
• What if process takes too long?

• What if user cancels?

• Add Validation Early: Catch issues before they cascade

• Validate inputs before processing
• Check outputs before passing to next step

• Verify assumptions at decision points

• Document Decision Points: Make branching logic clear

• What triggers each path?
• What are the criteria?

• Who makes the decision (AI vs human)?

• Separate Concerns: Group related operations

• Data collection phase
• Processing phase
• Validation phase

• Output generation phase

• Make It Resumable: Long workflows should support interruption

• Save state at checkpoints
• Enable resume from last checkpoint

• Track progress explicitly

• Test with Edge Cases: Don't just test happy path

• Malformed inputs
• Missing dependencies
• Timeout scenarios
• Concurrent execution

Workflow Design Patterns

Sequential Pipeline

Input → Step 1 → Step 2 → Step 3 → Output

Use when: Each step depends on previous step's output
Example: Data ingestion → Validation → Transformation → Storage

Parallel Execution

Input → [Step 1, Step 2, Step 3] → Merge → Output

Use when: Independent operations can run concurrently
Example: Lint, Test, Type-check → Aggregate results → Report

Conditional Branching

Input → Decision → [Path A | Path B] → Merge → Output

Use when: Different paths based on conditions
Example: File type detection → [JSON parser | CSV parser] → Normalize

Iterative Refinement

Input → Process → Validate → [Done? → Output | Refine → Process]

Use when: Output quality improves through iterations
Example: Generate code → Review → [Acceptable? → Deploy | Fix issues → Generate]

Multi-Agent Orchestration

Input → Coordinator → [Agent A, Agent B, Agent C] → Synthesizer → Output

Use when: Complex task needs specialized sub-agents
Example: Feature request → Planner → [Designer, Developer, Tester] → Integrator → PR

Event-Driven Workflow

Trigger → [Handler 1, Handler 2, Handler N] → Aggregate → Output

Use when: Workflow responds to events/webhooks
Example: Git push → [Build, Test, Deploy, Notify] → Status update

Workflow Documentation Template

## Workflow: [Name]

### Purpose
[What this workflow accomplishes]

### Triggers
- [What initiates this workflow]

### Inputs
- [Required inputs]
- [Optional inputs]

### Steps
1. **[Step Name]**
   - Action: [What happens]
   - Owner: [AI | Human | Tool]
   - Input: [What this step receives]
   - Output: [What this step produces]
   - Validation: [How to verify success]
   - On failure: [What to do if this fails]

2. **[Step Name]**
   [...]

### Decision Points
- **[Decision Name]**
  - Condition: [What determines the path]
  - If true: [Path A]
  - If false: [Path B]

### Outputs
- [What the workflow produces]
- [Where outputs are stored/sent]

### Success Criteria
- [How to know the workflow succeeded]

### Error Handling
- [Common failures and responses]

### Estimated Duration
- [How long this typically takes]

### Dependencies
- [External tools/services required]
- [Other workflows this depends on]

Workflow Metrics to Track

When designing workflows, consider measuring:

• Duration: How long does the workflow take?
• Success rate: What percentage complete successfully?
• Bottlenecks: Which steps take longest?
• Failure points: Where do errors occur most?
• Retry rate: How often do steps need retrying?
• Human intervention: How often is manual action needed?
• Resource usage: What's the computational/financial cost?

Common Pitfalls

• Over-engineering: Don't add complexity for problems that haven't occurred
• Under-specifying: Don't assume steps are obvious without documentation
• Ignoring failures: Don't design only for happy path
• Tight coupling: Don't make steps too dependent on implementation details
• No rollback: Don't make destructive operations irreversible
• Missing validation: Don't pass bad data between steps
• Sequential when parallel works: Don't serialize independent operations
• No progress tracking: Don't make long workflows black boxes