omgkit 2.1.1 → 2.2.0

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

@@ -1,54 +1,707 @@
 ---
 name: omega-thinking
-description: 7 modes of Omega thinking. Use for deep analysis, problem solving, finding 10x improvements.
+description: 7 modes of Omega thinking for deep analysis, 10x improvements, and transformative problem solving
+category: omega
+triggers:
+  - omega thinking
+  - deep analysis
+  - 10x improvement
+  - transformative thinking
+  - breakthrough ideas
+  - paradigm shift
 ---
 
-# Omega Thinking Skill
-
-## The 7 Modes
-
-### 🔭 TELESCOPIC
-Zoom out to see the big picture.
-- Task → Feature → Product → Market → Industry → World
-- **Ask**: "What's the ultimate impact?"
-
-### 🔬 MICROSCOPIC
-First principles analysis.
-- Why? → Why? → Why? → Why? → Why?
-- **Ask**: "What's fundamentally true?"
-
-### ↔️ LATERAL
-Different angles and approaches.
-- How would [X industry] solve this?
-- What's the opposite approach?
-- **Ask**: "What are we not seeing?"
-
-### 🔄 INVERSION
-Learn through failure.
-- How to guarantee failure?
-- Avoid those things.
-- **Ask**: "What would make this fail?"
-
-### ⏳ TEMPORAL
-Time dimension analysis.
-- Historical patterns?
-- Relevant in 10 years?
-- **Ask**: "How does time affect this?"
-
-### 🕸️ SYSTEMIC
-Interconnections and emergence.
-- Components and connections?
-- Feedback loops?
-- **Ask**: "What system dynamics are at play?"
-
-### ⚛️ QUANTUM
-Multiple possibilities.
-- All possible solutions?
-- How to test quickly?
-- **Ask**: "What are all the possibilities?"
-
-## Application
-For any problem:
-1. Apply all 7 modes
-2. Synthesize insights
-3. Find the 10x opportunity
+# Omega Thinking
+
+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.
+
+## Purpose
+
+Achieve breakthrough thinking through systematic modes:
+
+- 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
+
+## 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
+```
+
+### 2. 🔭 Telescopic Thinking
+
+```markdown
+## Telescopic: Zoom Out
+
+"What's the biggest picture this fits into?"
+
+### 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?
+```
+
+### 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]
+
+Level 7 - Ultimate Impact:
+What lasting change could this create?
+→ [Answer]
+
+## Insight
+[What new understanding emerged from zooming out?]
+```
+
+### Example
+```markdown
+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.
+```
+```
+
+### 3. 🔬 Microscopic Thinking
+
+```markdown
+## Microscopic: First Principles
+
+"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
+
+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)
+```
+```
+
+### 4. ↔️ Lateral Thinking
+
+```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?
+
+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
+
+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?
+```
+```
+
+### 5. 🔄 Inversion Thinking
+
+```markdown
+## Inversion: Learn from Failure
+
+"How would we guarantee failure?"
+
+### Failure Analysis Template
+```markdown
+## Inversion Analysis: [Goal]
+
+### Goal
+[What we want to achieve]
+
+### 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]
+
+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]
+
+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]
+```
+```
+
+### 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 Strategy Template
+```markdown
+## Technology Decision: [Technology]
+
+### Current Value
+[What value does it provide today?]
+
+### Peak Value (When?)
+[When will it be most valuable?]
+
+### Decline (When?)
+[When will it start declining?]
+
+### Obsolescence (When?)
+[When will it become obsolete?]
+
+### What Replaces It?
+[What will take its place?]
+
+### 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
+- First: More deployment complexity
+- Second: Team reorganization around services
+- Third: Different hiring needs (DevOps focus)
+- Fourth: Company culture shifts to distributed
+```
+```
+
+### 7. 🕸️ Systemic Thinking
+
+```markdown
+## Systemic: Interconnections
+
+"What are all the connections and feedback loops?"
+
+### 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
+
+### Balancing Loops (Stabilize)
+1. [Loop description]
+   A increases → B decreases → A stabilizes
+
+2. [Loop description]
+   X grows → Y limits → X stops growing
+
+### 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]
+```
+
+### 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]
+```
+```
+
+### 8. ⚛️ Quantum Thinking
+
+```markdown
+## Quantum: Multiple Possibilities
+
+"What are all possible states simultaneously?"
+
+### 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]
+
+### Key Uncertainties
+1. [Uncertainty 1]: High/Low
+2. [Uncertainty 2]: High/Low
+
+### Scenario 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]
+```
+
+### 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
+```
+```
+
+## Use Cases
+
+### Full Omega Analysis
+
+```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
+
+## Synthesis
+10x Opportunity: Shift from request-response to
+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)