Sequential Thinking

Create a numbered list of steps in execution order:

1. [First step that must happen]
2. [Second step that depends on step 1]
3. [Third step that depends on step 2]
...

Guidelines:

• Each step should be a single, clear action
• Steps should be ordered by dependencies
• One step should not do multiple unrelated things
• Steps should be testable/verifiable

Step 3: Identify Dependencies

For each step, note:

• What must be completed before this step
• What this step enables for later steps
• Any blocking dependencies

Step 4: Present the Plan

Show the numbered plan to the user before implementation:

## Implementation Plan

1. [Step description]
   - Dependencies: [if any]
   - Outcome: [what this achieves]

2. [Step description]
   - Dependencies: [if any]
   - Outcome: [what this achieves]
...

Step 5: Execute Sequentially

Execute steps in order:

• Complete each step fully before moving to the next
• Verify each step works before proceeding
• If a step fails, stop and reassess the plan
• Update the plan if new information emerges

Output Format

Always present sequential thinking as a numbered list:

## Sequential Plan

1. First action to take
2. Second action (depends on step 1)
3. Third action (depends on step 2)
4. Final verification step

Examples

Example 1: Adding a New Feature

Task: Add user profile editing functionality

Sequential Plan:

1. Create profile edit API endpoint

   • Dependencies: None
   • Outcome: Backend route for profile updates

2. Create profile edit form component

   • Dependencies: API endpoint exists
   • Outcome: UI for editing profile

3. Add form validation

   • Dependencies: Form component exists
   • Outcome: Validated user input

4. Connect form to API endpoint

   • Dependencies: Form and API both exist
   • Outcome: Functional profile editing

5. Add error handling and success feedback

   • Dependencies: Full flow works
   • Outcome: Complete user experience

Example 2: Refactoring

Task: Migrate component to use design tokens

Sequential Plan:

1. Identify all hardcoded values in component

   • Dependencies: None
   • Outcome: List of values to replace

2. Map hardcoded values to design tokens

   • Dependencies: Step 1 complete
   • Outcome: Token mapping

3. Replace spacing values with tokens

   • Dependencies: Step 2 complete
   • Outcome: Spacing updated

4. Replace color values with tokens

   • Dependencies: Step 3 complete
   • Outcome: Colors updated

5. Replace typography values with tokens

   • Dependencies: Step 4 complete
   • Outcome: Typography updated

6. Test in light and dark modes

   • Dependencies: All replacements complete
   • Outcome: Verified working

Best Practices

1. Don't skip steps - Even if a step seems obvious, include it for clarity
2. One thing per step - Each step should accomplish one clear goal
3. Verify as you go - Check that each step works before proceeding
4. Update when needed - If you discover new information, update the plan
5. Communicate progress - After completing each step, mention what's done and what's next

Anti-Patterns

❌ Don't: Jump into implementation without planning ❌ Don't: Combine multiple unrelated actions in one step ❌ Don't: Skip dependency analysis ❌ Don't: Proceed to next step if current step failed

✅ Do: Always create a numbered plan first ✅ Do: One clear action per step ✅ Do: Identify and respect dependencies ✅ Do: Verify each step before continuing