Sequential Execution

Execute tasks in order when dependencies exist between steps.

When to Use

Use sequential execution when:

• •Tasks have dependencies (Task B needs Task A's output)
• •Order matters for correctness
• •Tasks modify shared state or files
• •Workflow has clear sequential stages (e.g., commit → push → PR)
• •Later tasks need results from earlier tasks

Parameters

• •tasks: Ordered list of task descriptions
• •dependencies: Map of task dependencies (which tasks depend on which outputs)

How Sequential Execution Works

Step 1: Identify Dependencies

Map out which tasks depend on others:

• •Task A produces output X
• •Task B needs input X to proceed
• •Task C needs output from Task B

Step 2: Execute in Order

Execute tasks one at a time, passing outputs forward:

1. •Execute Task A, store output
2. •Execute Task B with output from A
3. •Execute Task C with output from B

Step 3: Track Progress

Use todo list to track sequential progress:

• •Mark current task as in-progress
• •Mark completed tasks as completed
• •Keep upcoming tasks as not-started

Sequential Patterns

Pattern 1: Linear Pipeline

A → B → C → D

Each task depends on the previous task's output.

Pattern 2: Staged Workflow

Stage 1: Setup → Stage 2: Processing → Stage 3: Cleanup

Clear phases that must happen in order.

Pattern 3: Conditional Sequencing

A → (if success) → B → (if failure) → C

Execution path depends on previous results.

Pattern 4: Accumulator Pattern

Start with initial state, each task transforms and passes to next:

• •Task 1: Initialize state
• •Task 2: Transform state
• •Task 3: Enhance state
• •Task 4: Finalize state

When to Use Sequential vs Parallel

TodoList Integration

Track sequential progress clearly:

{
  "todos": [
    { "id": 1, "title": "Fetch PR details", "status": "completed" },
    { "id": 2, "title": "Run tests", "status": "in-progress" },
    { "id": 3, "title": "Review comments", "status": "not-started" },
    { "id": 4, "title": "Merge PR", "status": "not-started" }
  ]
}

Common Sequential Workflows

Git Workflow

1. •Make changes → 2. Commit → 3. Push → 4. Create PR → 5. Merge

PR Processing

1. •Fetch PR → 2. Analyze → 3. Address comments → 4. Run checks → 5. Merge

Build Pipeline

1. •Install dependencies → 2. Build → 3. Test → 4. Package → 5. Deploy

Code Review

1. •Read code → 2. Identify issues → 3. Write comments → 4. Submit review

Error Handling

In sequential execution:

• •If step N fails, steps N+1 onwards cannot proceed
• •Decide whether to:
  • •Retry failed step
  • •Skip to error handling flow
  • •Abort entire sequence
  • •Continue with partial results

Best Practices

1. •Make dependencies explicit: Clearly document what each task needs
2. •Pass data forward: Each task receives output from previous task
3. •Track progress: Update todo list after each step
4. •Handle errors: Plan for failures at each stage
5. •Validate inputs: Ensure each task has what it needs before starting
6. •Log intermediate results: Useful for debugging and resuming

Quick Reference

WHEN TO USE:
  ✓ Tasks have dependencies
  ✓ Order matters
  ✓ Shared state modifications
  ✓ Must wait for previous results

PATTERNS:
  Linear:      A → B → C → D
  Staged:      Setup → Process → Cleanup
  Conditional: A → (check) → B or C
  Accumulator: Transform state through stages

TODOLIST:
  - Mark current step as in-progress
  - Keep future steps as not-started
  - Mark completed steps as completed

ERROR HANDLING:
  - Stop on failure
  - Retry step
  - Fallback flow
  - Abort sequence