Design Multi-Step Prompt Chains for Complex AI Workflows

This skill designs multi-step prompt chains that break complex tasks into sequential, manageable steps - multi-step AI workflow structure, context flow between prompts, and robust chains that handle edge cases. Core principles: sequential decomposition (each prompt builds on the previous output, one well-defined responsibility per step), context preservation (structured outputs and clear variable naming that filters noise while preserving essential context), built-in error handling (validation steps and fallback mechanisms that detect and correct errors from earlier steps), and state management via structured JSON/YAML intermediate outputs between steps.

Use it when a task needs multiple dependent AI steps with explicit context handoff and validation between them - not a single freeform prompt asked to do everything at once.

### CHAIN STEP [N]: [PURPOSE]

### Context Input
- Previous step output: {previous_output}
- Chain variables: {variable_name}

### Task Definition
[Clear, specific instruction for this step]

### Success Criteria
- [Specific measurable criteria]

### Error Handling
IF [error_condition] THEN [fallback_action]

Three chain architecture patterns are given directly: a linear chain (Analysis to Planning to Execution to Validation, illustrated with a four-prompt content-creation example), a branching chain (a classification step routing to Technical/Creative/Business writer prompts before merging into a final review), and an iterative-refinement loop (Generate to Evaluate to Identify Improvements to Refine, repeating until a quality threshold is met). Context flow uses a consistent variable-naming convention with prefixes like chain_state_{step_number} for main outputs and validation_{step_number} for quality checks, plus a context-compression prompt pattern that summarizes prior outputs into just key decisions, critical data points, constraints, and success criteria before the next step. Quality control inserts a validation-step prompt after critical steps that checks completeness, accuracy, consistency, and quality, returning a PASS/FAIL/NEEDS_REVISION status with specific issues and recommended fixes, alongside a chain-health JSON tracking steps completed, validation passes, and estimated completion.

Advanced techniques include a parallel-processing chain (splitting a dataset across concurrent workers, then an aggregation step reconciling results) and a self-modifying chain that inspects complexity discovered mid-chain and recommends inserting, modifying, or restructuring steps.

AI engineers building multi-step LLM workflows who need concrete linear, branching, and iterative chain patterns with real context-handoff and validation templates, not one long prompt trying to do everything. A debug-information template documents each step's purpose, input validation, processing approach, and handoff preparation during development. Implementation best practices close it out: start with simple 3-4 step chains before adding complexity, test each step independently before chaining them together, keep output formats consistent across all steps, build comprehensive error handling before production use, document decision points for complex chains, extract reusable sub-chains for common patterns, monitor token usage for efficiency, and version-control chain definitions to track iteration.