zhongwei/gh-tachyon-beep-skillpacks-plugins-yzmir-systems-thinking
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Initial commit

Browse Source
This commit is contained in:
Zhongwei Li
2025-11-30 09:00:08 +08:00
commit dccefb2050
10 changed files with 5088 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

483
skills/using-systems-thinking/SKILL.md Normal file
View File

@@ -0,0 +1,483 @@
---
name: using-systems-thinking
description: Router for systems thinking methodology - patterns, leverage points, archetypes, stocks-flows, causal loops, BOT graphs
mode: true
pack: yzmir/systems-thinking
faction: yzmir
skill_type: meta_router
dependencies:
- yzmir/systems-thinking/recognizing-system-patterns
- yzmir/systems-thinking/leverage-points-mastery
- yzmir/systems-thinking/systems-archetypes-reference
- yzmir/systems-thinking/stocks-and-flows-modeling
- yzmir/systems-thinking/causal-loop-diagramming
- yzmir/systems-thinking/behavior-over-time-graphs
estimated_time_hours: 0.5
---
# Using Systems-Thinking (Meta-Skill Router)
**Your entry point to systems thinking methodology.** This skill routes you to the right combination of systems analysis skills for understanding complex, interconnected problems.
## Purpose
This is a **meta-skill** that:
1. ✅ **Routes** you to the correct systems thinking skills
2. ✅ **Combines** multiple skills for comprehensive analysis
3. ✅ **Provides** workflows for common problem types
4. ✅ **Explains** when to use systems thinking vs other approaches
**You should use this skill:** When facing complex problems with feedback loops, delays, unintended consequences, or persistent failures despite interventions.
---
## Core Philosophy: Think in Systems
### The Central Idea
**Linear Thinking**: Problem → Solution → Fixed
- Assumes cause and effect are close in time and space
- Ignores feedback loops and delays
- Leads to "fixes that fail" and escalation
- Symptoms return or move elsewhere
**Systems Thinking**: Structure → Behavior → Intervention
- Recognizes feedback loops create behavior
- Delays cause intuition failures
- Small interventions at leverage points beat brute force
- Address root causes, not symptoms
### When This Pack Applies
**✅ Use systems-thinking when:**
- Problems persist despite repeated fixes
- Solutions create new problems (unintended consequences)
- System behavior is counter-intuitive
- Multiple stakeholders with conflicting incentives
- Long delays between action and result
- "The harder we push, the harder the system pushes back"
**❌ Don't use systems-thinking when:**
- Simple, isolated problems with clear cause-effect
- One-time decisions with immediate results
- Pure optimization (no feedback dynamics)
- Well-understood linear processes
---
## Pack Overview: 6 Core Skills
### Wave 1: Foundation and Pattern Recognition
#### 1. recognizing-system-patterns
**When to use:** ANY complex problem - start here
**Teaches:** S-curves, feedback loops (reinforcing/balancing), delays, stock-flow thinking
**Examples:** Viral growth, technical debt, burnout spirals
**Time:** 45-60 min
**Key insight:** Behavior patterns reveal underlying structure
#### 2. systems-archetypes-reference
**When to use:** Recognize recurring problem patterns
**Teaches:** 10 classic archetypes (Fixes that Fail, Shifting the Burden, Escalation, etc.)
**Examples:** Feature factory, hero culture, arms race
**Time:** 60-90 min
**Key insight:** Most problems match known patterns with known solutions
#### 3. leverage-points-mastery
**When to use:** Design interventions, prioritize where to act
**Teaches:** Donella Meadows' 12 leverage points hierarchy
**Examples:** Constants (weak) vs rules vs paradigms (powerful)
**Time:** 60-75 min
**Key insight:** Small changes at high leverage points beat large changes at low points
### Wave 2: Quantitative Analysis
#### 4. stocks-and-flows-modeling
**When to use:** Predict future states, calculate equilibrium, analyze accumulation dynamics
**Teaches:** Formal notation, equilibrium analysis, time constants, delay analysis
**Examples:** Customer churn, bug backlog, burnout accumulation
**Time:** 75-90 min
**Key insight:** Quantification elevates from "will get worse" to "6.7 weeks to crisis"
#### 5. causal-loop-diagramming
**When to use:** Map system structure, communicate feedback dynamics, find root causes
**Teaches:** 6-step construction process, polarity testing, loop identification
**Examples:** Death spirals, virtuous cycles, balancing processes
**Time:** 60-75 min
**Key insight:** Systematic construction prevents polarity errors that change diagnosis
#### 6. behavior-over-time-graphs
**When to use:** Show trajectories, compare scenarios, communicate dynamics over time
**Teaches:** 7-step construction, 70-80% scale rule, ASCII standards, validation
**Examples:** S-curve adoption, crisis timing, intervention impact
**Time:** 60-75 min
**Key insight:** "What happens over time" with concrete numbers and dates
---
## Routing Logic: Which Skills Do I Need?
### Decision Tree
```
START: What's your goal?
├─ UNDERSTAND A PROBLEM (First time encountering complexity)
│ ├─ Start here → recognizing-system-patterns
│ ├─ Does it match a known pattern? → systems-archetypes-reference
│ └─ What behavior over time? → behavior-over-time-graphs
│
├─ MAP SYSTEM STRUCTURE (How does this work?)
│ ├─ Identify feedback loops → causal-loop-diagramming
│ ├─ Calculate accumulation → stocks-and-flows-modeling
│ └─ Show dynamics → behavior-over-time-graphs
│
├─ DESIGN INTERVENTIONS (What should we do?)
│ ├─ Identify leverage points → leverage-points-mastery
│ ├─ Predict outcomes → stocks-and-flows-modeling + behavior-over-time-graphs
│ └─ Match to archetype solution → systems-archetypes-reference
│
├─ COMMUNICATE TO STAKEHOLDERS (Convince others)
│ ├─ Executive version → behavior-over-time-graphs (with $ impacts)
│ ├─ Technical version → causal-loop-diagramming + stocks-and-flows-modeling
│ └─ Pattern recognition → systems-archetypes-reference ("We're in Fixes that Fail")
│
└─ QUANTITATIVE PREDICTION (When will crisis hit? How many?)
├─ Calculate trajectory → stocks-and-flows-modeling
├─ Visualize scenarios → behavior-over-time-graphs
└─ Validate structure → causal-loop-diagramming
```
---
## Common Problem Types and Skill Combinations
### Scenario 1: "Our Solution Keeps Failing"
**Symptoms:**
- Applied fix multiple times
- Problem returns or gets worse
- "We tried everything"
**Routing Sequence:**
1. **systems-archetypes-reference** → Recognize "Fixes that Fail" or "Shifting the Burden"
2. **causal-loop-diagramming** → Map the reinforcing loop keeping problem alive
3. **leverage-points-mastery** → Find intervention point (probably addressing root cause, not symptom)
4. **behavior-over-time-graphs** → Show "with fix" vs "without fix" vs "address root cause"
**Why this sequence:**
- Archetypes give you the pattern (quick recognition)
- CLD maps the specific instance
- Leverage points guide where to intervene
- BOT graphs communicate to stakeholders
### Scenario 2: "Growth is Slowing / Hitting Limits"
**Symptoms:**
- Initial success, now plateauing
- S-curve behavior
- Limits to growth
**Routing Sequence:**
1. **recognizing-system-patterns** → Identify S-curve, find the balancing loop
2. **stocks-and-flows-modeling** → Calculate time to saturation, equilibrium capacity
3. **systems-archetypes-reference** → "Limits to Growth" archetype
4. **leverage-points-mastery** → Options: expand limit, find new growth, stabilize
5. **behavior-over-time-graphs** → Show trajectory with/without limit expansion
**Why this sequence:**
- Pattern recognition confirms S-curve
- Stock-flow gives you numbers (when hits limit?)
- Archetype provides intervention options
- Leverage points prioritize options
- BOT graphs show impact
### Scenario 3: "We're in a Vicious Spiral"
**Symptoms:**
- Self-reinforcing decline
- "The harder we work, the worse it gets"
- Death spiral, burnout, quality collapse
**Routing Sequence:**
1. **recognizing-system-patterns** → Identify reinforcing loop (R)
2. **causal-loop-diagramming** → Map the specific reinforcing structure
3. **systems-archetypes-reference** → Match to "Escalation" or "Success to the Successful"
4. **stocks-and-flows-modeling** → Calculate time to crisis (when does morale hit 0?)
5. **leverage-points-mastery** → Break the loop (add balancing feedback)
6. **behavior-over-time-graphs** → Show crisis timing + intervention impact
**Why this sequence:**
- Pattern recognition identifies reinforcing dynamic
- CLD maps exact structure (what's reinforcing what?)
- Archetype gives tested solutions
- Stock-flow calculates urgency
- Leverage points find where to break loop
- BOT graphs communicate stakes
### Scenario 4: "Delay Between Action and Result"
**Symptoms:**
- Decisions based on old information
- Overshooting, oscillation
- "We keep over/under correcting"
**Routing Sequence:**
1. **recognizing-system-patterns** → Identify delay, oscillation pattern
2. **stocks-and-flows-modeling** → Calculate delay time constant, D/R ratio
3. **causal-loop-diagramming** → Mark delays on causal links (||)
4. **systems-archetypes-reference** → "Shifting the Burden to the Intervenor" (long-term fix delayed)
5. **behavior-over-time-graphs** → Show overshoot/undershoot pattern
**Why this sequence:**
- Pattern recognition confirms delay issue
- Stock-flow quantifies delay danger (D/R > 0.5 = crisis)
- CLD visualizes where delays are
- Archetype matches delay-based patterns
- BOT graphs show oscillation
### Scenario 5: "Presenting to Executives"
**Goal:** Get buy-in for systems-based solution
**Routing Sequence:**
1. **behavior-over-time-graphs** → LEAD with this (clear, visual, $$ impacts)
- "Current trajectory: 6.7 weeks to crisis"
- "With intervention: stabilizes at 80% capacity"
2. **systems-archetypes-reference** → Frame as known pattern ("We're in Fixes that Fail")
3. **leverage-points-mastery** → Justify intervention choice ("This is a high-leverage point")
4. **causal-loop-diagramming** → BACKUP ONLY (if asked "why does this happen?")
**Why this sequence:**
- Executives want impact first (BOT graphs)
- Pattern names create shared language (archetypes)
- Leverage points justify resource allocation
- CLDs available if deep dive needed
### Scenario 6: "Multi-Variable System (Technical Debt, Velocity, Morale)"
**Symptoms:**
- Many interacting variables
- Hard to see connections
- Non-obvious causality
**Routing Sequence:**
1. **causal-loop-diagramming** → Map all variables and causal links
2. **stocks-and-flows-modeling** → Calculate multi-stock dynamics (debt, morale, velocity all accumulate)
3. **behavior-over-time-graphs** → Show multi-variable trajectories (separate panels or dual-axis)
4. **leverage-points-mastery** → Identify highest leverage variable
**Why this sequence:**
- CLD handles many variables well
- Stock-flow models accumulation of each
- BOT graphs show multiple trajectories
- Leverage points prioritize where to act
---
## Step-by-Step Workflows
### Workflow 1: Systematic Problem Analysis (80% of use cases)
**Process:**
1. **recognizing-system-patterns** (15 min) - What patterns appear? S-curve? Reinforcing loop?
2. **systems-archetypes-reference** (20 min) - Does this match a known archetype?
3. **causal-loop-diagramming** (30 min) - Map the specific structure
4. **stocks-and-flows-modeling** (45 min) - Quantify key stocks, calculate time constants
5. **leverage-points-mastery** (20 min) - Identify high-leverage interventions
6. **behavior-over-time-graphs** (30 min) - Show current trajectory + intervention scenarios
**Total time:** ~2.5-3 hours
**Output:** Complete systems analysis with quantitative predictions and intervention design
### Workflow 2: Quick Pattern Recognition (When time-limited)
**Process:**
1. **recognizing-system-patterns** (15 min) - Quick pattern ID
2. **systems-archetypes-reference** (20 min) - Match to archetype, use archetype's standard solution
**Total time:** ~35 min
**Output:** Pattern diagnosis + known solution approach
**Trade-off:** No quantification, no custom structure mapping
### Workflow 3: Executive Presentation Prep
**Process:**
1. **stocks-and-flows-modeling** (45 min) - Calculate key numbers (crisis timing, costs, ROI)
2. **behavior-over-time-graphs** (40 min) - Create executive-friendly graphs ($$ impact)
3. **leverage-points-mastery** (15 min) - Justify intervention choice
4. **systems-archetypes-reference** (10 min) - Frame with archetype name
**Total time:** ~110 min
**Output:** Executive presentation with quantified impact
### Workflow 4: Deep Technical Analysis
**Process:**
1. **recognizing-system-patterns** (15 min) - Pattern confirmation
2. **causal-loop-diagramming** (60 min) - Detailed structure mapping, polarity validation
3. **stocks-and-flows-modeling** (90 min) - Multi-stock equations, sensitivity analysis
4. **behavior-over-time-graphs** (45 min) - Multi-scenario comparison
5. **leverage-points-mastery** (30 min) - Evaluate intervention points
**Total time:** ~4 hours
**Output:** Comprehensive technical analysis with validated structure and quantified scenarios
---
## Skill Dependencies and Learning Path
### Learning Path for Beginners
**Start here if new to systems thinking:**
1. **recognizing-system-patterns** (REQUIRED FIRST)
- Foundation for all other skills
- Teaches core concepts: stocks, flows, feedback, delays
- Builds intuition for system behavior
2. **systems-archetypes-reference** (LEARN SECOND)
- Pattern library accelerates analysis
- Provides vocabulary (names for patterns)
- Gives tested solutions
3. Choose path based on needs:
- **Quantitative path** → stocks-and-flows-modeling → behavior-over-time-graphs
- **Structural path** → causal-loop-diagramming → leverage-points-mastery
### Skill Dependencies
**No prerequisites:**
- recognizing-system-patterns (START HERE)
**Requires recognizing-system-patterns:**
- systems-archetypes-reference (builds on patterns)
- causal-loop-diagramming (uses feedback loop concepts)
- stocks-and-flows-modeling (uses stock/flow distinction)
- leverage-points-mastery (uses system structure concepts)
- behavior-over-time-graphs (uses pattern recognition)
**Works better together:**
- stocks-and-flows-modeling + behavior-over-time-graphs (calculate, then visualize)
- causal-loop-diagramming + leverage-points-mastery (map structure, find intervention)
- systems-archetypes-reference + leverage-points-mastery (pattern → known leverage points)
---
## Rationalization Resistance Table
| Rationalization | Reality | Counter-Guidance | Red Flag |
|-----------------|---------|------------------|----------|
| "Just add more resources" | Resource additions often activate balancing loops | "Route to leverage-points-mastery - this is lowest-leverage point (constants)" | Ignoring system structure |
| "This isn't a system, it's a simple bug" | Bugs that persist are symptoms of system structure | "Route to systems-archetypes-reference - likely 'Fixes that Fail'" | Linear thinking on complex problems |
| "We don't have time for analysis" | Crisis timing requires stock-flow calculation | "Route to stocks-and-flows-modeling - 15 min calculation vs wrong 6-month commitment" | Analysis paralysis fear |
| "Our situation is unique" | 90% match archetypes | "Route to systems-archetypes-reference - most 'unique' problems aren't" | Not invented here syndrome |
| "Just draw a quick diagram" | Polarity errors change diagnosis (R vs B) | "Route to causal-loop-diagramming - use systematic 6-step process" | Skipping validation |
| "Intuition says it will get worse" | Intuition fails on delays, non-linear dynamics | "Route to stocks-and-flows-modeling - calculate, don't guess" | Overconfidence in intuition |
| "We need to act NOW" | Acting without understanding wastes resources | "Route to recognizing-system-patterns - 15 min pattern ID prevents months of wrong solution" | Action bias |
| "Too complicated to model" | Most systems can be modeled simply | "Route to stocks-and-flows-modeling - start with 1-2 stocks" | Complexity avoidance |
| "Graphs are for presentations, not analysis" | Graphs reveal patterns invisible in tables | "Route to behavior-over-time-graphs - construction process IS analysis" | Separating analysis from communication |
---
## Red Flags Checklist
Watch for these signs of incorrect approach:
- [ ] **Linear Thinking**: "X causes Y, so fix X" (ignoring feedback loops)
- [ ] **Symptom Treating**: Addressing symptoms without mapping structure
- [ ] **Resource Obsession**: Only considering "add more people/money" solutions
- [ ] **Analysis Paralysis**: Trying to model everything instead of starting simple
- [ ] **Skipping Validation**: Drawing CLDs without polarity double-test
- [ ] **Gut-Feel Quantification**: "Probably double in 6 months" without calculation
- [ ] **Graph Manipulation**: Tweaking scale to make problems look bigger/smaller
- [ ] **Archetype Forcing**: Forcing problem into wrong archetype
- [ ] **Ignoring Delays**: Not marking delays on CLDs or calculating time constants
- [ ] **Single-Skill Fixation**: Using only one tool (e.g., only CLDs, no quantification)
**If any red flag triggered → STOP → Route to appropriate skill(s)**
---
## When NOT to Use This Pack
Clarify boundaries with other approaches:
| Problem Type | Use Instead | Reason |
|--------------|-------------|--------|
| Well-understood algorithm optimization | Standard profiling/optimization | No feedback dynamics |
| One-time decision with immediate result | Decision analysis, expected value | No time dynamics |
| Pure data analysis / statistics | Data science methods | Not about system structure |
| Legal/compliance requirements | Ordis security-architect | Different domain |
| Pure UX research | Lyra ux-designer | Different methodology |
| Code architecture | Axiom system-architect | Code structure, not system dynamics |
**Edge case:** Software architecture CAN have systems dynamics (technical debt accumulation, team coordination). Use **both** system-architect (structure) AND systems-thinking (dynamics).
---
## Integration with Other Packs
### Simulation-Foundations (Yzmir)
- **Use together when:** Need to implement simulation based on systems model
- **Workflow:** systems-thinking (design) → simulation-foundations (implementation)
- **Example:** Model ecosystem with stocks-and-flows → implement with differential-equations-for-games
### System-Architect (Axiom)
- **Use together when:** Software architecture decisions have feedback dynamics
- **Workflow:** system-architect (code structure) + systems-thinking (team/process dynamics)
- **Example:** Microservices architecture (static) + team coordination dynamics (systems thinking)
### Deep-RL (Yzmir)
- **Use together when:** Training RL agents in systems with feedback
- **Workflow:** systems-thinking (environment analysis) → deep-rl (agent design)
- **Example:** Understand ecosystem dynamics with causal-loop-diagramming → train agents with actor-critic-methods
---
## Summary: Start Here
**First time with systems thinking?**
→ **recognizing-system-patterns** (foundation skill, 45-60 min)
**Problem keeps returning despite fixes?**
→ **systems-archetypes-reference** → Find "Fixes that Fail" or "Shifting the Burden"
**Need to predict future states?**
→ **stocks-and-flows-modeling** → Calculate time to crisis, equilibrium
**Need to map system structure?**
→ **causal-loop-diagramming** → Visualize feedback loops
**Need to design intervention?**
→ **leverage-points-mastery** → Find high-leverage points
**Need to communicate dynamics?**
→ **behavior-over-time-graphs** → Show trajectories over time
**Not sure where to start?**
→ Use this router skill! Ask diagnostic questions:
- "Is this problem persisting despite fixes?"
- "Are there delays between action and result?"
- "Do we understand the feedback loops?"
- "What's the goal: understand, map, intervene, or communicate?"
**Most common workflow:**
recognizing-system-patterns → systems-archetypes-reference → causal-loop-diagramming → stocks-and-flows-modeling → leverage-points-mastery → behavior-over-time-graphs
**Time for complete analysis:** 2.5-4 hours (depending on complexity)
**Key principle:** Start with patterns, match to archetypes, map structure, quantify dynamics, find leverage, visualize scenarios.
---
## Systems Thinking Specialist Skills Catalog
After routing, load the appropriate specialist skill for detailed guidance:
1. [recognizing-system-patterns.md](recognizing-system-patterns.md) - Foundation: S-curves, feedback loops, delays, stock-flow thinking, pattern recognition
2. [systems-archetypes-reference.md](systems-archetypes-reference.md) - 10 classic archetypes: Fixes that Fail, Shifting the Burden, Escalation, recurring patterns
3. [leverage-points-mastery.md](leverage-points-mastery.md) - Donella Meadows' 12 leverage points, intervention design, prioritization
4. [stocks-and-flows-modeling.md](stocks-and-flows-modeling.md) - Quantitative modeling: equilibrium analysis, time constants, accumulation dynamics
5. [causal-loop-diagramming.md](causal-loop-diagramming.md) - Structure mapping: 6-step construction, polarity testing, loop identification
6. [behavior-over-time-graphs.md](behavior-over-time-graphs.md) - Trajectory visualization: 7-step construction, scenario comparison, communication