Thinking in Steps

The key to effective prompt chaining is learning to decompose complex tasks into discrete, well-defined steps. This skill transforms how you approach AI-assisted work.

The Decomposition Mindset

Instead of asking "What prompt will get me the final result?", ask:

• What are the distinct phases of this task?
• What information does each phase need?
• What should each phase produce?

A Framework for Breaking Down Tasks

Step 1: Identify the End Goal

Start with a clear picture of your desired output:

• What format should it be in?
• What quality standards must it meet?
• Who will use it and how?

Step 2: Work Backwards

From your end goal, identify what inputs that final step needs:

• What data or content must exist?
• What decisions must already be made?
• What preparation is required?

Step 3: Identify Dependencies

Map out which steps depend on others:

• Which steps must happen sequentially?
• Which can happen in parallel?
• Where are the critical decision points?

Example: Breaking Down a Blog Post

Single-prompt approach (problematic):

"Write a 1500-word blog post about sustainable investing for millennials"

Decomposed approach:

Step 1: Research & Outline
├── Identify key topics in sustainable investing
├── Find statistics relevant to millennials
└── Create structured outline

Step 2: Draft Sections
├── Write introduction (hook + thesis)
├── Write each main section
└── Write conclusion with call-to-action

Step 3: Review & Polish
├── Check facts and claims
├── Improve readability
└── Add transitions between sections

Step 4: Optimize
├── SEO optimization
├── Add meta description
└── Create social snippets

Each step produces a concrete output that feeds into the next.

Identifying Step Boundaries

Good step boundaries have these characteristics:

Clear Inputs and Outputs Each step should accept well-defined input and produce well-defined output.

Single Responsibility A step should do one thing well, not multiple unrelated things.

Verifiable Results You should be able to check if a step succeeded before proceeding.

Appropriate Granularity Not too broad (defeats the purpose) or too narrow (creates overhead).

Exercise: Decompose a Task

Consider this complex task: "Create a competitive analysis report for a new coffee shop opening in downtown Seattle."

A good decomposition might look like:

Step	Input	Output	Verification
1. Identify Competitors	Location, radius	List of competitors with addresses	Check completeness
2. Gather Data	Competitor list	Pricing, hours, reviews, menu data	Verify data exists for each
3. Analyze Strengths/Weaknesses	Competitor data	SWOT for each competitor	Review for completeness
4. Identify Market Gaps	SWOT analyses	List of opportunities	Validate against data
5. Generate Recommendations	Opportunities, context	Strategic recommendations	Check actionability
6. Create Report	All outputs	Formatted report	Review for coherence

Common Decomposition Patterns

The Pipeline Pattern

Sequential steps where each transforms the previous output:

Raw Data → Cleaned Data → Analyzed Data → Insights → Report

The Gather-Process-Synthesize Pattern

Collect from multiple sources, then combine:

Source A →
Source B → → Synthesis → Output
Source C →

The Generate-Evaluate-Refine Pattern

Create, critique, and improve:

Generate Draft → Evaluate Quality → Refine Based on Feedback → Final Output

The Classify-Route Pattern

Categorize input, then handle each category differently:

Input → Classification → Route A (if type 1)
                       → Route B (if type 2)
                       → Route C (if type 3)

Avoiding Over-Decomposition

Don't break things down too far:

Too granular (wasteful):

1. Read sentence 1
2. Understand sentence 1
3. Read sentence 2
4. Understand sentence 2
5. Connect sentence 1 and 2
6. ... (continues for 500 steps)

Appropriately granular (efficient):

1. Read and understand the document
2. Extract key themes
3. Summarize each theme
4. Synthesize into final summary

Key Takeaways

• Start with the end goal and work backwards
• Each step should have clear inputs, outputs, and verification criteria
• Look for natural boundaries where outputs can be validated
• Use common patterns as templates for decomposition
• Avoid both over-decomposition and under-decomposition

Next, we'll explore specific scenarios where chaining provides clear advantages over single prompts.