omgkit 2.2.0 → 2.3.0

package/plugin/skills/omega/omega-thinking/SKILL.md

@@ -1,6 +1,6 @@
 ---
-name: omega-thinking
-description: 7 modes of Omega thinking for deep analysis, 10x improvements, and transformative problem solving
+name: thinking-in-omega-modes
+description: Applies 7 systematic thinking modes for breakthrough problem-solving and 10x improvements. Use when tackling complex problems, seeking transformative insights, or escaping conventional thinking traps.
 category: omega
 triggers:
   - omega thinking
@@ -8,663 +8,242 @@ triggers:
   - 10x improvement
   - transformative thinking
   - breakthrough ideas
-  - paradigm shift
 ---
 
-# Omega Thinking
+# Thinking in Omega Modes
 
-Master the **7 modes of Omega thinking** for breakthrough problem solving, transformative insights, and 10x improvements. This skill provides mental frameworks that transcend conventional approaches.
+Master the **7 modes of Omega thinking** for breakthrough problem-solving, transformative insights, and 10x improvements.
 
-## Purpose
+## Quick Start
 
-Achieve breakthrough thinking through systematic modes:
+```yaml
+# Apply all 7 modes to any significant problem
+Problem: "API performance issues"
 
-- See problems from multiple dimensions
-- Find 10x improvements instead of 10% tweaks
-- Escape conventional thinking traps
-- Discover hidden opportunities
-- Solve root causes, not symptoms
-- Create transformative solutions
-- Build systemic understanding
+Modes:
+  Telescopic: "Zoom out - what's the biggest picture?"
+  Microscopic: "First principles - what's fundamentally true?"
+  Lateral: "Different angle - how would Netflix solve this?"
+  Inversion: "Failure mode - how to guarantee failure?"
+  Temporal: "Time dimension - past, present, future impact?"
+  Systemic: "Connections - what are the feedback loops?"
+  Quantum: "Possibilities - what are ALL options?"
 
-## Features
-
-### 1. The 7 Omega Thinking Modes
-
-```markdown
-## Overview: The 7 Modes
-
-┌─────────────────────────────────────────────────────────────────┐
-│                    OMEGA THINKING MODES                          │
-├─────────────────────────────────────────────────────────────────┤
-│                                                                 │
-│  🔭 TELESCOPIC    - Zoom out to see the big picture             │
-│                                                                 │
-│  🔬 MICROSCOPIC   - First principles analysis                   │
-│                                                                 │
-│  ↔️  LATERAL       - Different angles and approaches             │
-│                                                                 │
-│  🔄 INVERSION     - Learn through failure analysis              │
-│                                                                 │
-│  ⏳ TEMPORAL      - Time dimension analysis                     │
-│                                                                 │
-│  🕸️  SYSTEMIC      - Interconnections and emergence             │
-│                                                                 │
-│  ⚛️  QUANTUM       - Multiple possibilities simultaneously      │
-│                                                                 │
-└─────────────────────────────────────────────────────────────────┘
-
-For any significant problem:
-1. Apply ALL 7 modes systematically
-2. Synthesize insights across modes
-3. Identify the 10x opportunity
+Synthesis:
+  10x_Opportunity: "Shift from request-response to event-driven real-time"
 ```
 
-### 2. 🔭 Telescopic Thinking
+## Features
 
-```markdown
-## Telescopic: Zoom Out
+| Feature | Description | Guide |
+|---------|-------------|-------|
+| Telescopic | Zoom out to biggest picture | Task to ultimate impact |
+| Microscopic | First principles analysis | 5 Whys to root cause |
+| Lateral | Different angles and perspectives | Industry translation |
+| Inversion | Learn through failure analysis | Pre-mortem planning |
+| Temporal | Time dimension analysis | Past, present, future effects |
+| Systemic | Interconnections and emergence | Feedback loops mapping |
+| Quantum | Multiple possibilities simultaneously | Scenario planning |
+
+## Common Patterns
 
-"What's the biggest picture this fits into?"
+### The 7 Omega Thinking Modes
 
-### The Zoom Ladder
 ```
-Current task     → What feature does this enable?
-Feature          → What product capability?
-Product          → What business outcome?
-Business         → What market need?
-Market           → What industry trend?
-Industry         → What societal shift?
-Society          → What human need?
+TELESCOPIC    - Zoom out to see the big picture
+MICROSCOPIC   - First principles analysis
+LATERAL       - Different angles and approaches
+INVERSION     - Learn through failure analysis
+TEMPORAL      - Time dimension analysis
+SYSTEMIC      - Interconnections and emergence
+QUANTUM       - Multiple possibilities simultaneously
 ```
 
-### Application Template
-```markdown
-## Telescopic Analysis: [Problem]
-
-Level 1 - Task:
-What am I directly trying to accomplish?
-→ [Answer]
-
-Level 2 - Feature:
-What larger feature does this serve?
-→ [Answer]
-
-Level 3 - Product:
-How does this help the product succeed?
-→ [Answer]
-
-Level 4 - Business:
-What business goal does this support?
-→ [Answer]
-
-Level 5 - Market:
-What market need does this address?
-→ [Answer]
-
-Level 6 - Industry:
-How does this relate to industry evolution?
-→ [Answer]
+### Telescopic: Zoom Out
 
-Level 7 - Ultimate Impact:
-What lasting change could this create?
-→ [Answer]
+```markdown
+## The Zoom Ladder
 
-## Insight
-[What new understanding emerged from zooming out?]
-```
+Current task     -> What feature does this enable?
+Feature          -> What product capability?
+Product          -> What business outcome?
+Business         -> What market need?
+Market           -> What industry trend?
+Industry         -> What societal shift?
 
-### Example
-```markdown
+## Example
 Task: Optimize database query
-→ Feature: Faster page load
-→ Product: Better user experience
-→ Business: Higher conversion rate
-→ Market: User expectation for instant responses
-→ Industry: Real-time everything trend
-→ Ultimate: Human attention span evolution
-
-Insight: Maybe we need a real-time architecture,
-not just query optimization. 10x opportunity identified.
-```
+-> Feature: Faster page load
+-> Product: Better UX
+-> Business: Higher conversion
+-> Market: Real-time expectation
+-> Insight: Need real-time architecture, not just query fixes
 ```
 
-### 3. 🔬 Microscopic Thinking
+### Microscopic: First Principles
 
 ```markdown
-## Microscopic: First Principles
+## The 5 Whys
 
-"What is fundamentally, irreducibly true?"
-
-### The 5 Whys Deep Dive
-```
 Problem: Users complain about slow app
 
-Why 1? → Page load takes 5 seconds
-Why 2? → Large JavaScript bundle
-Why 3? → All dependencies loaded upfront
-Why 4? → No code splitting implemented
-Why 5? → Architecture assumed fast connections
+Why 1? -> Page load takes 5 seconds
+Why 2? -> Large JavaScript bundle
+Why 3? -> All dependencies loaded upfront
+Why 4? -> No code splitting implemented
+Why 5? -> Architecture assumed fast connections
 
 Root cause: Architecture assumptions don't match reality
-```
-
-### First Principles Template
-```markdown
-## Microscopic Analysis: [Problem]
-
-### Surface Problem
-[What appears to be the problem?]
-
-### Why #1
-[Why does this happen?]
-→ [Answer]
-
-### Why #2
-[Why does that happen?]
-→ [Answer]
-
-### Why #3
-[Why does that happen?]
-→ [Answer]
-
-### Why #4
-[Why does that happen?]
-→ [Answer]
 
-### Why #5
-[Why does that happen?]
-→ [Answer]
-
-### Root Cause
-[The fundamental issue]
-
-### First Principles Truth
-[What is irreducibly true about this domain?]
-
-### Implication
-[How does this change our approach?]
-```
-
-### Fundamental Truths Checklist
-```markdown
-When analyzing, find what is fundamentally true:
-
-□ Physics constraints (speed of light, thermodynamics)
-□ Mathematical certainties (complexity bounds, statistics)
-□ Human constants (attention span, cognitive load)
-□ Economic principles (supply/demand, incentives)
-□ Information theory (entropy, compression limits)
-□ Network effects (Metcalfe's law, viral coefficient)
-```
+## Fundamental Truths Checklist
+- Physics constraints (speed of light)
+- Mathematical certainties (complexity bounds)
+- Human constants (attention span, cognitive load)
+- Economic principles (supply/demand)
+- Network effects (Metcalfe's law)
 ```
 
-### 4. ↔️ Lateral Thinking
+### Lateral: Different Angles
 
-```markdown
-## Lateral: Different Angles
-
-"What would [X] do differently?"
-
-### Perspective Shifts
 ```markdown
 ## Industry Translation
 How would [other industry] solve this?
 
-- How would Netflix solve slow content delivery?
-  → Aggressive caching, CDN, predictive loading
-
-- How would Tesla solve software updates?
-  → OTA updates, feature flagging, A/B testing
-
-- How would Amazon solve inventory management?
-  → Predictive stocking, distributed warehouses, ML demand forecasting
-
-- How would Spotify solve personalization?
-  → Collaborative filtering, taste profiles, discovery algorithms
-```
-
-### Opposite Day Analysis
-```markdown
-## What's the opposite approach?
+- Netflix: Aggressive caching, CDN, predictive loading
+- Tesla: OTA updates, feature flagging, A/B testing
+- Amazon: Predictive stocking, distributed warehouses
+- Spotify: Collaborative filtering, taste profiles
 
+## Opposite Day Analysis
 Current: Push notifications to users
 Opposite: Let users pull when ready
-Insight: Maybe less is more - reduce notification fatigue
-
-Current: Centralized database
-Opposite: Distributed data at edge
-Insight: Latency matters more than consistency sometimes
-
-Current: Manual code review
-Opposite: Automated AI review
-Insight: Humans for design, AI for mechanics
-```
-
-### Random Stimulus
-```markdown
-## Force random connections
+Insight: Less is more - reduce notification fatigue
 
+## Random Stimulus
 Pick random word: "Butterfly"
-
-Connection to our problem:
-- Metamorphosis → Transform architecture gradually
-- Wings → Lightweight, distributed components
-- Migration → Data migration patterns
-- Effect → Small changes, big impact
-
-Insight sparked: What small change would have butterfly effect on system performance?
-```
+- Metamorphosis -> Transform architecture gradually
+- Wings -> Lightweight, distributed components
+- Effect -> Small changes, big impact
 ```
 
-### 5. 🔄 Inversion Thinking
+### Inversion: Failure Analysis
 
 ```markdown
-## Inversion: Learn from Failure
-
-"How would we guarantee failure?"
-
-### Failure Analysis Template
-```markdown
-## Inversion Analysis: [Goal]
-
-### Goal
-[What we want to achieve]
+## How to Guarantee Failure
 
-### Guaranteed Failures
-How to ensure we FAIL at this goal:
-
-1. [Failure mode 1]
-   Prevention: [How to avoid]
-
-2. [Failure mode 2]
-   Prevention: [How to avoid]
-
-3. [Failure mode 3]
-   Prevention: [How to avoid]
-
-4. [Failure mode 4]
-   Prevention: [How to avoid]
-
-5. [Failure mode 5]
-   Prevention: [How to avoid]
-
-### Priority Actions
-Based on inversion analysis:
-1. [Most critical prevention]
-2. [Second priority]
-3. [Third priority]
-```
-
-### Example: Building Reliable System
-```markdown
 Goal: Build a highly reliable system
 
 Guaranteed Failures:
-1. No monitoring → Add comprehensive monitoring
-2. Single points of failure → Build redundancy
-3. No testing → Implement thorough testing
-4. Ignore edge cases → Design for edge cases
-5. Deploy on Friday → Establish deployment policies
-6. No documentation → Document everything
-7. Hardcode secrets → Use secret management
-8. No backups → Implement backup strategy
-9. Ignore security → Security by design
-10. No capacity planning → Plan for scale
-
-Most Critical: Monitoring + Redundancy + Testing
-```
-
-### Pre-Mortem Template
-```markdown
-## Pre-Mortem: [Project]
+1. No monitoring -> Add comprehensive monitoring
+2. Single points of failure -> Build redundancy
+3. No testing -> Implement thorough testing
+4. Hardcode secrets -> Use secret management
+5. No backups -> Implement backup strategy
 
+## Pre-Mortem Template
 Imagine it's 6 months from now and the project failed.
 
-### What went wrong?
-
-Technical Failures:
-- [Potential technical failure 1]
-- [Potential technical failure 2]
-
-Process Failures:
-- [Potential process failure 1]
-- [Potential process failure 2]
+Technical Failures: [List what went wrong]
+Process Failures: [List what went wrong]
+People Failures: [List what went wrong]
+External Failures: [List what went wrong]
 
-People Failures:
-- [Potential people failure 1]
-- [Potential people failure 2]
-
-External Failures:
-- [Potential external failure 1]
-- [Potential external failure 2]
-
-### Prevention Plan
-[For each failure, identify prevention measures]
+Prevention Plan: [For each, identify prevention]
 ```
-```
-
-### 6. ⏳ Temporal Thinking
-
-```markdown
-## Temporal: Time Dimension
-
-"How does time change this?"
 
-### Time Horizon Analysis
-```markdown
-## Temporal Analysis: [Decision]
-
-### Past (History)
-- Has this been tried before?
-- What can we learn from history?
-- What patterns repeat?
-
-### Present (Current State)
-- What is true today?
-- What constraints exist now?
-- What resources are available?
-
-### Near Future (1 year)
-- What will change soon?
-- What trends are emerging?
-- What should we prepare for?
-
-### Medium Future (5 years)
-- What technologies will mature?
-- How will the market evolve?
-- What skills will be needed?
-
-### Long Future (10+ years)
-- What is inevitable?
-- What will become obsolete?
-- What will endure?
-
-### Timeless
-- What never changes?
-- What principles are eternal?
-- What human needs persist?
-```
+### Temporal: Time Dimension
 
-### Temporal Strategy Template
 ```markdown
-## Technology Decision: [Technology]
-
-### Current Value
-[What value does it provide today?]
-
-### Peak Value (When?)
-[When will it be most valuable?]
+## Time Horizon Analysis
 
-### Decline (When?)
-[When will it start declining?]
+Past: Has this been tried before? What patterns repeat?
+Present: What is true today? What constraints exist?
+Near (1yr): What trends are emerging?
+Medium (5yr): What technologies will mature?
+Long (10yr+): What is inevitable? What will endure?
 
-### Obsolescence (When?)
-[When will it become obsolete?]
+## Second-Order Effects
 
-### What Replaces It?
-[What will take its place?]
+First-order: [Immediate effect]
+Second-order (1yr): [Effects of first-order effects]
+Third-order (3yr): [Effects of second-order effects]
+Fourth-order (5yr+): [Long-term cascading effects]
 
-### Decision
-Given temporal analysis:
-- Invest now? [Yes/No]
-- How much? [Level]
-- Exit strategy? [Plan]
-```
-
-### Second-Order Effects
-```markdown
-## Second-Order Temporal Effects
-
-First-order: [Immediate effect of decision]
-
-Second-order (1 year): [Effects of first-order effects]
-
-Third-order (3 years): [Effects of second-order effects]
-
-Fourth-order (5+ years): [Long-term cascading effects]
-
-Example: Choosing microservices architecture
+Example: Choosing microservices
 - First: More deployment complexity
-- Second: Team reorganization around services
-- Third: Different hiring needs (DevOps focus)
-- Fourth: Company culture shifts to distributed
-```
+- Second: Team reorganization
+- Third: Different hiring needs (DevOps)
+- Fourth: Company culture shifts
 ```
 
-### 7. 🕸️ Systemic Thinking
-
-```markdown
-## Systemic: Interconnections
-
-"What are all the connections and feedback loops?"
+### Systemic: Interconnections
 
-### System Mapping
-```
-                 ┌─────────────┐
-                 │   Users     │
-                 └──────┬──────┘
-                        │ feedback
-            ┌───────────┼───────────┐
-            ▼           ▼           ▼
-      ┌─────────┐ ┌─────────┐ ┌─────────┐
-      │Features │ │Marketing│ │ Support │
-      └────┬────┘ └────┬────┘ └────┬────┘
-           │           │           │
-           │    ┌──────┴──────┐    │
-           └───►│  Product    │◄───┘
-                │  Decisions  │
-                └──────┬──────┘
-                       │
-                       ▼
-              ┌────────────────┐
-              │   Revenue      │
-              └────────────────┘
-```
-
-### Feedback Loop Analysis
 ```markdown
-## Feedback Loops: [System]
-
-### Reinforcing Loops (Amplify)
-1. [Loop description]
-   A increases → B increases → A increases more
-   Type: Virtuous/Vicious
-
-2. [Loop description]
-   X improves → Y improves → X improves more
+## Feedback Loop Analysis
 
-### Balancing Loops (Stabilize)
-1. [Loop description]
-   A increases → B decreases → A stabilizes
+Reinforcing Loops (Amplify):
+A increases -> B increases -> A increases more
+Type: Virtuous or Vicious?
 
-2. [Loop description]
-   X grows → Y limits → X stops growing
+Balancing Loops (Stabilize):
+A increases -> B decreases -> A stabilizes
 
-### Intervention Points
+Intervention Points:
 Where can we intervene for maximum effect?
-1. [High leverage point]
-2. [Medium leverage point]
-3. [Low leverage point]
-
-### Unintended Consequences
-What might happen that we don't expect?
-1. [Potential consequence]
-2. [Potential consequence]
-```
+1. High leverage point
+2. Medium leverage point
+3. Low leverage point
 
-### Emergence Detection
-```markdown
-## Emergent Properties: [System]
-
-### Components
-- Component A: [Function]
-- Component B: [Function]
-- Component C: [Function]
-
-### Individual Behaviors
-- A does: [Behavior]
-- B does: [Behavior]
-- C does: [Behavior]
-
-### Emergent Properties
-What appears only when combined:
-1. [Property that no single component has]
-2. [Behavior that emerges from interaction]
-3. [Capability that only exists as whole]
-
-### Design Implications
-How to cultivate positive emergence:
-- [Design principle 1]
-- [Design principle 2]
-```
+## Emergent Properties
+What appears only when components combine:
+- Properties no single component has
+- Behaviors that emerge from interaction
+- Capabilities that only exist as whole
 ```
 
-### 8. ⚛️ Quantum Thinking
+### Quantum: Multiple Possibilities
 
 ```markdown
-## Quantum: Multiple Possibilities
+## Possibility Explosion
 
-"What are all possible states simultaneously?"
+Conventional: Option A or Option B
 
-### Possibility Explosion
-```markdown
-## Quantum Analysis: [Decision]
-
-### Conventional Options
-1. Option A: [Standard approach]
-2. Option B: [Alternative approach]
-
-### Expanded Possibilities
-3. Option A + B: [Combination]
-4. Neither: [Completely different approach]
-5. Sequence: [A then B]
-6. Inverse sequence: [B then A]
-7. Parallel: [Both simultaneously]
-8. Delegate: [Someone else decides]
-9. Defer: [Decide later with more info]
-10. Eliminate: [Remove need for decision]
-
-### Wild Cards
-- What if we 10x the approach?
-- What if we do the opposite?
-- What if we do nothing?
-- What if we do everything?
-```
-
-### Scenario Planning
-```markdown
-## Scenario Planning: [Uncertainty]
+Expanded:
+- A + B: Combination
+- Neither: Completely different approach
+- Sequence: A then B
+- Parallel: Both simultaneously
+- Delegate: Someone else decides
+- Defer: Decide later with more info
+- Eliminate: Remove need for decision
 
-### Key Uncertainties
-1. [Uncertainty 1]: High/Low
-2. [Uncertainty 2]: High/Low
-
-### Scenario Matrix
+## Scenario Planning Matrix
                     Uncertainty 2
                     Low         High
-              ┌─────────────┬─────────────┐
-      High    │ Scenario A  │ Scenario B  │
-Uncertainty 1 │ [Describe]  │ [Describe]  │
-              ├─────────────┼─────────────┤
-      Low     │ Scenario C  │ Scenario D  │
-              │ [Describe]  │ [Describe]  │
-              └─────────────┴─────────────┘
-
-### Robust Strategies
-What works in ALL scenarios:
-- [Strategy 1]
-- [Strategy 2]
-
-### Contingent Strategies
-If Scenario A: [Strategy]
-If Scenario B: [Strategy]
-If Scenario C: [Strategy]
-If Scenario D: [Strategy]
-```
+              +-------------+-------------+
+      High    | Scenario A  | Scenario B  |
+Uncertainty 1 |             |             |
+              +-------------+-------------+
+      Low     | Scenario C  | Scenario D  |
+              |             |             |
+              +-------------+-------------+
 
-### Optionality Creation
-```markdown
-## Creating Optionality
-
-### Current State
-[Fixed decisions and commitments]
-
-### Options to Create
-1. [Option that could be valuable]
-   Cost to create: [Low/Medium/High]
-   Potential value: [Low/Medium/High]
-
-2. [Option that could be valuable]
-   Cost to create: [Low/Medium/High]
-   Potential value: [Low/Medium/High]
-
-### Principle
-Create options when:
-- Cost is low
-- Uncertainty is high
-- Potential upside is large
-- Downside is limited
+Robust Strategies: What works in ALL scenarios?
+Contingent Strategies: If Scenario X, do Y
 ```
-```
-
-## Use Cases
 
-### Full Omega Analysis
+### Full Omega Analysis Example
 
 ```markdown
-## Complete Omega Analysis: API Performance Problem
-
-### 🔭 Telescopic
-- Task: Fix slow API
-- Feature: Better response times
-- Product: Superior user experience
-- Business: Competitive advantage
-- Market: Real-time expectation economy
-Insight: Need to think real-time first, not request-response
-
-### 🔬 Microscopic
-Why slow? → Database queries
-Why slow queries? → No indexes
-Why no indexes? → Not designed for current query patterns
-Why mismatch? → Schema designed for different use case
-Why different? → Original requirements changed
-Root cause: Architecture drift from evolving requirements
-
-### ↔️ Lateral
-- How would gaming industry solve? → Predictive loading
-- How would CDN solve? → Cache at edge
-- Opposite approach? → Push updates instead of pull
-Insight: Consider push-based architecture with caching
-
-### 🔄 Inversion
-How to make it even SLOWER:
-- Add more database joins → Solution: Denormalize
-- No caching → Solution: Add caching layer
-- Sync operations → Solution: Go async
-- No monitoring → Solution: Add observability
-
-### ⏳ Temporal
-- Past: Monolith was fine at small scale
-- Present: Growing pains at current scale
-- Future: Need 100x scale capability
-- Timeless: Latency always matters
-Insight: Solve for future scale, not just current pain
-
-### 🕸️ Systemic
-- Database ← affects → API speed
-- API speed ← affects → User satisfaction
-- User satisfaction ← affects → Business metrics
-- Business metrics ← affects → Investment in infrastructure
-Intervention point: Cache layer breaks bottleneck loop
-
-### ⚛️ Quantum
-Options:
-1. Optimize queries (10% improvement)
-2. Add caching (50% improvement)
-3. Rearchitect for real-time (10x improvement)
-4. Combination of all three
-Decision: Start with caching, plan for rearchitecture
+## Problem: API Performance
+
+TELESCOPIC: Need real-time first, not request-response
+MICROSCOPIC: Architecture drift from evolving requirements
+LATERAL: Consider push-based architecture with caching
+INVERSION: Add monitoring, caching, go async
+TEMPORAL: Solve for future scale, not just current pain
+SYSTEMIC: Cache layer breaks bottleneck loop
+QUANTUM: Start with caching, plan for rearchitecture
 
 ## Synthesis
 10x Opportunity: Shift from request-response to
@@ -673,35 +252,15 @@ event-driven real-time architecture with edge caching.
 
 ## Best Practices
 
-### Do's
-
-- Apply ALL 7 modes systematically
-- Document insights from each mode
-- Look for 10x opportunities, not 10% tweaks
-- Synthesize across modes
-- Challenge assumptions explicitly
-- Consider unintended consequences
-- Map systems and feedback loops
-- Think across time horizons
-- Generate many possibilities
-- Seek first principles truths
-
-### Don'ts
-
-- Don't stop at surface level
-- Don't use only one thinking mode
-- Don't accept first solution
-- Don't ignore temporal effects
-- Don't miss systemic connections
-- Don't limit possibilities too early
-- Don't forget to zoom out
-- Don't forget to zoom in
-- Don't skip the inversion check
-- Don't rush the analysis
-
-## References
-
-- [Mental Models - Farnam Street](https://fs.blog/mental-models/)
-- [The Fifth Discipline - Peter Senge](https://www.amazon.com/Fifth-Discipline-Practice-Learning-Organization/dp/0385517254)
-- [Thinking in Systems - Donella Meadows](https://www.amazon.com/Thinking-Systems-Donella-H-Meadows/dp/1603580557)
-- [Poor Charlie's Almanack - Charlie Munger](https://www.stripe.press/poor-charlies-almanack)
+| Do | Avoid |
+|----|-------|
+| Apply ALL 7 modes systematically | Stopping at surface level |
+| Document insights from each mode | Using only one thinking mode |
+| Look for 10x opportunities, not 10% | Accepting first solution |
+| Synthesize across modes | Ignoring temporal effects |
+| Challenge assumptions explicitly | Missing systemic connections |
+| Consider unintended consequences | Limiting possibilities too early |
+| Map systems and feedback loops | Forgetting to zoom out |
+| Think across time horizons | Forgetting to zoom in |
+| Generate many possibilities | Skipping the inversion check |
+| Seek first principles truths | Rushing the analysis |