Awesome Thinking: Sequential Reflective Thinking Framework

Purpose

This skill provides a structured approach to complex problem-solving through sequential, reflective thinking. It enables systematic exploration of problems where understanding deepens progressively, assumptions may need revision, and multiple solution paths should be considered.

Unlike linear problem-solving, this framework embraces:

• Dynamic adjustment of solution complexity as understanding evolves
• Questioning and revising previous conclusions when new insights emerge
• Branching into alternative approaches when uncertainty exists
• Iterative hypothesis generation and verification until a satisfactory solution is reached

When to Use This Skill

Invoke this skill for:

• Complex multi-step problems requiring careful breakdown and analysis
• Problems with unclear scope where initial estimates may need adjustment
• Scenarios requiring course correction as new information emerges
• Architectural or design decisions with multiple viable approaches and trade-offs
• Algorithm optimization where multiple strategies should be explored
• Debugging complex issues where root cause may not be immediately apparent
• Tasks needing context maintenance across multiple analytical steps
• Situations with irrelevant noise requiring careful filtering of information

Do NOT use for simple, straightforward tasks with obvious solutions.

How to Use This Framework

Core Thinking Process

Structure analysis as a sequence of numbered thoughts, each building toward the solution. Follow these principles:

1. Start with an Initial Estimate

   • Begin by estimating total thoughts needed (e.g., "I estimate this will take 5 thoughts")
   • Understand this is flexible and can be adjusted

2. Progress Through Thoughts Sequentially

   • Number each thought (1, 2, 3, ...)
   • Focus each thought on a specific aspect of the problem
   • Build on previous insights while remaining open to revision

3. Types of Thoughts

   Regular Analytical Thoughts:

   • Standard problem-solving steps
   • Information gathering and analysis
   • Logical deduction and inference
   • Example: "Thought 3/7: Analyzing the time complexity of the current approach..."

   Revision Thoughts:

   • Question or reconsider previous conclusions
   • Mark with: "Thought 5/7 (Revising Thought 2): Upon further reflection..."
   • Update understanding based on new insights
   • Example: "Thought 6/8 (Revising Thought 3): Actually, the earlier assumption about constant-time lookup was incorrect because..."

   Branching Thoughts:

   • Explore alternative approaches
   • Mark with: "Thought 4/7 (Branch A from Thought 2): Exploring alternative approach..."
   • Can have multiple branches: Branch A, Branch B, etc.
   • Example: "Thought 5/9 (Branch A from Thought 3): If we use a hash map instead..."

   Realizations About Scope:

   • Recognize when more/fewer thoughts are needed
   • Adjust total count: "Thought 5/7: This is more complex than initially estimated. Adjusting to 10 thoughts."
   • Example: "Thought 3/5: This problem is simpler than expected. Adjusting to 4 thoughts total."

   Hypothesis Generation:

   • Propose potential solutions
   • State clearly: "Hypothesis: [solution approach]"
   • Example: "Thought 7/10: Hypothesis: Using a trie data structure will reduce lookup time from O(n) to O(k) where k is key length."

   Hypothesis Verification:

   • Test proposed solutions against requirements
   • Identify flaws or confirm validity
   • Example: "Thought 8/10: Verifying hypothesis - checking edge cases... Found issue: doesn't handle Unicode properly."

4. Iteration and Refinement

   • If hypothesis fails verification, generate new hypothesis
   • Continue until a satisfactory solution emerges
   • Don't force premature conclusion

5. Filtering Irrelevant Information

   • At each thought, focus only on relevant aspects
   • Explicitly ignore tangential details
   • Example: "Thought 4/8: Focusing on the caching layer; ignoring UI concerns for now."

6. Final Thought

   • Clearly mark when complete: "Thought 10/10 (Final)"
   • Provide the definitive answer or solution
   • Summarize key insights if helpful

Formatting Thoughts

Present thoughts in a clear, structured format:

Thought [current]/[total]: [Content]

For special thought types:

Thought [current]/[total] (Revising Thought [number]): [Content]
Thought [current]/[total] (Branch [ID] from Thought [number]): [Content]
Thought [current]/[total] (Final): [Content]

Dynamic Adjustment Examples

Increasing Scope:

Thought 1/5: Analyzing the problem requirements...
Thought 2/5: Breaking down into components...
Thought 3/5: Wait, there's additional complexity here with concurrency. Adjusting to 8 thoughts.
Thought 4/8: Now examining thread-safety considerations...

Decreasing Scope:

Thought 1/7: Examining all possible approaches...
Thought 2/7: Actually, the built-in library handles this. Adjusting to 3 thoughts.
Thought 3/3 (Final): Use the standard library's XYZ method.

Branching and Comparing:

Thought 3/8: Two viable approaches identified. Exploring both.
Thought 4/8 (Branch A): Using approach A with recursion...
Thought 5/8 (Branch B): Using approach B with iteration...
Thought 6/8: Comparing branches - Branch B is more efficient due to...
Thought 7/8: Selecting Branch B approach.

Revision Based on New Insight:

Thought 4/7: Based on assumption X, the solution is Y...
Thought 5/7 (Revising Thought 4): Assumption X is actually false because Z. Need different approach.
Thought 6/7: New solution considering Z...

Process Termination

Only conclude when:

• A satisfactory solution has been found AND verified
• All critical aspects have been considered
• Confidence in the answer is high

Do NOT conclude prematurely to meet an estimated thought count. Add more thoughts if needed.

Example: Complete Thought Sequence

Thought 1/5: Analyzing the problem - need to find the fastest way to detect duplicates in a stream of integers.

Thought 2/5: Initial approach - use a HashSet for O(1) lookup. Space complexity O(n).

Thought 3/5: Considering constraints - stream is potentially infinite, can't store everything. Adjusting to 7 thoughts.

Thought 4/7 (Branch A from Thought 2): Exploring Bloom filter approach - probabilistic but constant space.

Thought 5/7 (Branch B from Thought 2): Exploring sliding window approach - only track recent N items.

Thought 6/7: Comparing approaches. If false positives acceptable, Bloom filter is optimal. Otherwise, sliding window with configurable size.

Thought 7/7 (Final): Recommendation depends on requirements:
- If no false positives allowed: Sliding window with HashSet (O(1) lookup, O(N) space for window size N)
- If rare false positives acceptable: Bloom filter (O(1) lookup, constant space)
- Recommend option 1 for correctness unless memory is severely constrained.

Best Practices

1. Be Honest About Uncertainty - Express when multiple paths exist or understanding is incomplete
2. Don't Force Linear Progression - Branch, backtrack, or revise as needed
3. Adjust Dynamically - Change estimated thought count based on evolving understanding
4. Focus Each Thought - One clear purpose per thought
5. Verify Before Concluding - Test hypotheses against requirements and edge cases
6. Filter Noise - Ignore irrelevant details at each step
7. Maintain Context - Reference previous thoughts when building on them
8. Embrace Iteration - Failed hypotheses lead to better solutions

Output Format

After completing the thought sequence, provide:

1. The Final Answer - Clear, actionable solution or recommendation
2. Key Insights (optional) - Summary of important discoveries from the thinking process
3. Next Steps (if applicable) - What should be done to implement or verify the solution

Present this as normal output after the thought sequence, not as another numbered thought.