@polderlabs/bizar 10.6.0 → 10.7.0

package/config/skills/thinking-feedback-loops/SKILL.md

@@ -0,0 +1,464 @@
+---
+name: thinking-feedback-loops
+description: Use when a system shows runaway growth/collapse, oscillates around a target, or resists change, and you need to find the loop driving it. Identifies reinforcing/balancing loops and delays.
+---
+
+# Feedback Loop Analysis
+
+## Overview
+
+Feedback loop analysis (Donella Meadows, "Thinking in Systems") explains how a dynamic system behaves over time. Loops either amplify change (reinforcing) or stabilize toward a goal (balancing); delays between cause and effect produce oscillation. When a system grows uncontrollably, collapses, oscillates, or refuses to change, the loop structure is the cause.
+
+**Core Principle:** System behavior emerges from feedback structure. To change behavior, change the loops.
+
+## Trigger Card
+
+When a system shows dynamic behavior (runaway growth, oscillation, resistance to change):
+
+1. **Classify the behavior:** growing/collapsing → look for a reinforcing loop; oscillating → look for a balancing loop with delay; stuck → look for a dominant balancing loop.
+2. **Trace the loop:** what variable feeds back into itself? Map causal connections with direction (+/-).
+3. **Find the leverage:** shorten a delay, change a loop's gain, or add a balancing loop to a runaway reinforcing one.
+
+If there's no dynamic behavior (static, one-time cause), skip — just fix it. For overall system mapping, use `thinking-systems`. For choosing where to intervene in an already-mapped loop, use `thinking-leverage-points`.
+
+## When to Use
+
+- A system shows runaway growth or collapse (suspect a dominant reinforcing loop)
+- It oscillates around a target instead of settling (suspect delays in a balancing loop)
+- It is stuck/resistant to change (suspect a dominant balancing loop)
+- An "obvious" fix backfired and you need to know why
+
+```
+System behavior is puzzling or problematic?
+  → Is it growing/shrinking unexpectedly?   → Look for REINFORCING LOOPS
+  → Is it oscillating around a target?      → Look for DELAYS in BALANCING LOOPS
+  → Is it stuck/resistant to change?        → Look for dominant BALANCING LOOPS
+```
+
+## When NOT to Use
+
+- **You need to map the overall system structure** (components, stocks, flows, cross-service causes) — use `thinking-systems` instead. Feedback loops zooms in on the specific dynamic loops driving behavior; systems maps the full territory first.
+- **You're looking for where to intervene** in an already-mapped system — use `thinking-leverage-points` (Meadows' 12-level hierarchy). Feedback loops tells you *which loop is dominant*; leverage-points tells you *where in that loop to act*.
+- The symptom has a single static cause with no loop (a fixed bug, a one-time bad config) → just fix it.
+- Behavior isn't changing over time—there's nothing dynamic to model.
+
+## Core Concepts
+
+### 1. Reinforcing Loops (Positive Feedback)
+
+Reinforcing loops amplify change in the same direction—growth or decline. They create exponential behavior: the more you have, the more you get (or lose).
+
+**Structure:** A → increases B → increases A (or: A → decreases B → decreases A)
+
+```
+┌─────────────────────────────────────────────────────────┐
+│              REINFORCING LOOP (R)                       │
+│                                                         │
+│         ┌──────────┐         ┌──────────┐              │
+│         │  Users   │───(+)──▶│  Content │              │
+│         └──────────┘         └────┬─────┘              │
+│              ▲                    │                     │
+│              │                   (+)                    │
+│              │                    │                     │
+│              └────────────────────┘                     │
+│                                                         │
+│   More users → More content → More users (Growth)      │
+│   OR: Fewer users → Less content → Fewer users (Death) │
+└─────────────────────────────────────────────────────────┘
+```
+
+**Characteristics:**
+
+- Exponential growth or collapse
+- Self-fulfilling prophecies
+- "Rich get richer" dynamics
+- Virtuous cycles (when beneficial)
+- Vicious cycles (when harmful)
+
+**Software Examples:**
+
+```
+Retry Storm Loop:
+Service slow → Clients retry → More load → Service slower → More retries
+(Vicious cycle toward outage)
+
+Technical Debt Loop:
+Shortcuts → Bugs → Firefighting → Less time → More shortcuts
+(Vicious cycle toward collapse)
+
+Cache Stampede Loop:
+Cache miss → Backend load → Slower fills → More misses → More load
+(Reinforcing under expiry)
+```
+
+### 2. Balancing Loops (Negative Feedback)
+
+Balancing loops counteract change, pushing the system toward a goal or equilibrium. They create goal-seeking behavior.
+
+**Structure:** Gap between actual and goal → corrective action → reduces gap
+
+```
+┌─────────────────────────────────────────────────────────┐
+│              BALANCING LOOP (B)                         │
+│                                                         │
+│   ┌──────────┐                    ┌──────────┐         │
+│   │   Goal   │                    │  Actual  │         │
+│   │  State   │                    │  State   │         │
+│   └────┬─────┘                    └────┬─────┘         │
+│        │                               │                │
+│        └──────────┬────────────────────┘                │
+│                   ▼                                     │
+│             ┌──────────┐                               │
+│             │   Gap    │                               │
+│             └────┬─────┘                               │
+│                  │                                      │
+│                 (-)                                     │
+│                  ▼                                      │
+│           ┌────────────┐                               │
+│           │ Corrective │                               │
+│           │   Action   │────────▶ Closes gap           │
+│           └────────────┘                               │
+└─────────────────────────────────────────────────────────┘
+```
+
+**Characteristics:**
+
+- Goal-seeking behavior
+- Resistance to change
+- Stability (when working well)
+- Oscillation (when delays exist)
+
+**Software Examples:**
+
+```
+Auto-scaling Loop:
+Load increases → Gap from target → Scale up → Load per instance decreases
+(Goal: maintain target response time)
+
+Backpressure Loop:
+Queue depth rises → Producers throttled → Arrival rate drops → Queue drains
+(Goal-seeking to bounded queue)
+
+Circuit Breaker Loop:
+Error rate exceeds threshold → Breaker opens → Load sheds → Service recovers
+(Goal: maintain availability)
+```
+
+### 3. Delays
+
+Delays are the time between cause and effect. They are the primary source of oscillation and instability in systems.
+
+```
+┌─────────────────────────────────────────────────────────┐
+│                   DELAY EFFECTS                         │
+│                                                         │
+│   Action ───────[DELAY]─────────▶ Effect               │
+│                                                         │
+│   Short delay: System responds smoothly                 │
+│   Long delay: Overshoot and oscillation                │
+│                                                         │
+│   Examples:                                             │
+│   • Code deploy → [Cache TTL] → Users see change       │
+│   • New hire → [Ramp-up time] → Productivity impact    │
+│   • Feature ship → [Adoption] → Metric movement        │
+│   • Training → [Skill development] → Performance gain  │
+└─────────────────────────────────────────────────────────┘
+```
+
+**Why Delays Cause Oscillation:**
+
+```
+Without delay:
+  Gap detected → Correction → Gap closes → Done
+
+With delay:
+  Gap detected → Correction → [DELAY] → Gap persists →
+  More correction → [DELAY] → Original correction arrives →
+  Overshoot → Gap in opposite direction → Oscillation
+```
+
+**Classic Example: Shower Temperature**
+
+```
+Too cold → Turn hot → [Delay: water travels through pipes] →
+Still cold → Turn hotter → Hot water arrives → Too hot! →
+Turn cold → [Delay] → Still hot → Turn colder →
+Cold water arrives → Too cold! → Oscillation continues
+```
+
+## Common System Patterns
+
+### Pattern 1: Exponential Growth
+
+**Structure:** Single dominant reinforcing loop
+
+```
+┌─────────┐      ┌─────────┐
+│ Revenue │─(+)─▶│ Invest- │
+│         │      │  ment   │
+└────▲────┘      └────┬────┘
+     │                │
+    (+)              (+)
+     │                │
+     └────────────────┘
+         Growth
+```
+
+**Behavior:** J-curve growth (or collapse if running in reverse)
+
+**Examples:**
+
+- Startup hypergrowth phase
+- Viral spread
+- Compounding interest
+- Technical debt accumulation
+
+**Intervention:** Find or create balancing loops before runaway
+
+### Pattern 2: Goal-Seeking (with Oscillation)
+
+**Structure:** Balancing loop with significant delay
+
+```
+┌────────┐      ┌────────┐
+│  Goal  │      │ Actual │
+└───┬────┘      └───┬────┘
+    │               │
+    └───────┬───────┘
+            ▼
+         [Gap]
+            │
+           (-)
+            │
+            ▼
+    ┌────────────┐
+    │ Correction │───[DELAY]───▶ Effect
+    └────────────┘
+```
+
+**Behavior:** Oscillation around goal, amplitude depends on delay length
+
+**Examples:**
+
+- Inventory management (bullwhip effect)
+- Hiring cycles (overhire → layoffs → understaffed → overhire)
+- Feature prioritization swings
+- Performance optimization iterations
+
+**Intervention:** Shorten delays, reduce correction magnitude, accept longer settling time
+
+### Pattern 3: Limits to Growth
+
+**Structure:** Reinforcing loop eventually hits a balancing constraint
+
+```
+    ┌─────────────────────────────────────┐
+    │                                     │
+    ▼                                     │
+┌────────┐                          ┌─────┴────┐
+│ Growth │──(+)──▶ Success ──(-)──▶│ Resource │
+│ Effort │                          │  Limit   │
+└────────┘                          └──────────┘
+    │
+    └──(+)──▶ Results (initially)
+```
+
+**Behavior:** S-curve—growth, plateau, then stagnation or decline
+
+**Examples:**
+
+- Market saturation
+- Team scaling limits
+- System capacity constraints
+- Feature exhaustion
+
+**Intervention:** Identify and address the constraint before hitting it
+
+### Pattern 4: Shifting the Burden
+
+**Structure:** Symptomatic solution undermines fundamental solution
+
+```
+                    ┌──────────────┐
+                    │   Problem    │
+                    │   Symptom    │
+                    └──────┬───────┘
+                           │
+              ┌────────────┼────────────┐
+              ▼            │            ▼
+      ┌───────────┐        │    ┌───────────────┐
+      │  Quick    │        │    │  Fundamental  │
+      │   Fix     │        │    │   Solution    │
+      └─────┬─────┘        │    └───────┬───────┘
+            │              │            │
+           (+)             │           (+)
+            │              │            │
+            ▼              │            ▼
+    Symptom relief ────────┘    Root cause fixed
+            │                          ▲
+           (-)                         │
+            ▼                          │
+    Motivation to ─────────────────────┘
+    fix root cause
+```
+
+**Behavior:** Addiction to quick fixes; fundamental capability atrophies
+
+**Examples:**
+
+- Heroic firefighting vs. systemic reliability
+- Overtime vs. hiring/process improvement
+- Manual workarounds vs. automation
+- External consultants vs. internal capability
+
+**Intervention:** Deliberately invest in fundamental solution while managing symptoms
+
+### Pattern 5: Escalation (Arms Race)
+
+**Structure:** Two competing reinforcing loops
+
+```
+┌─────────┐      ┌─────────┐
+│ Party A │──▶   │ Party B │
+│ Action  │  ▲   │ Action  │
+└────┬────┘  │   └────┬────┘
+     │       │        │
+    (+)      │       (+)
+     │       │        │
+     └───────┴────────┘
+         Threat
+```
+
+**Behavior:** Mutual escalation until resource exhaustion or intervention
+
+**Examples:**
+
+- Feature wars between competitors
+- Meeting proliferation
+- Process/bureaucracy accumulation
+- Alert fatigue spirals
+
+**Intervention:** Break the loop through agreement, constraint, or reframing
+
+## Identifying Loops in Systems
+
+### Step 1: Map the Variables
+
+List all relevant quantities that change over time:
+
+```
+Team productivity system:
+- Team size
+- Individual workload
+- Code quality
+- Technical debt
+- Bug rate
+- Firefighting time
+- Feature velocity
+- Morale
+```
+
+### Step 2: Draw Causal Connections
+
+For each pair, ask: "Does A affect B? In which direction?"
+
+```
+(+) Same direction: A increases → B increases, A decreases → B decreases
+(-) Opposite direction: A increases → B decreases
+```
+
+### Step 3: Trace the Loops
+
+Follow the arrows back to starting point. Count the negative signs:
+
+```
+Even number of (-) = Reinforcing loop
+Odd number of (-) = Balancing loop
+```
+
+### Step 4: Identify Dominant Loops
+
+The system behavior is driven by currently dominant loops:
+
+- Growing exponentially? Reinforcing loop dominates
+- Oscillating? Balancing loop with delay
+- Stable? Balancing loop working well
+- Declining? Reinforcing loop in reverse
+
+## Leverage Points
+
+Once you've found the dominant loop, intervene at the highest-leverage point you can move: changing a delay or a loop's gain beats tuning a parameter; changing a rule beats both. For Meadows' full 12-level hierarchy, see `thinking-leverage-points`—don't re-derive it here.
+
+## Application Framework
+
+### Analyzing a Problematic System
+
+```markdown
+## Feedback Loop Analysis: [System Name]
+
+### Current Behavior
+[Describe: growing, declining, oscillating, stuck]
+
+### Key Variables
+- [List stocks and flows]
+
+### Loop Diagram
+[Draw or describe the loops]
+
+### Identified Loops
+| Loop Name | Type | Variables | Currently Dominant? |
+|-----------|------|-----------|---------------------|
+|           |      |           |                     |
+
+### Delays Present
+| Delay | Duration | Effect |
+|-------|----------|--------|
+|       |          |        |
+
+### Leverage Points
+| Level | Intervention | Expected Effect |
+|-------|-------------|-----------------|
+|       |             |                 |
+
+### Recommended Intervention
+[Highest-leverage, lowest-risk option]
+```
+
+## Integration with Systems Thinking
+
+- `thinking-systems`: Map the overall system structure and trace cross-service causes
+- `thinking-feedback-loops`: Identify and analyze the specific loop driving the dynamic behavior
+- `thinking-leverage-points`: Choose where to intervene (Meadows' 12-level hierarchy)
+
+## Verification Checklist
+
+- [ ] Identified key variables that change over time
+- [ ] Mapped causal connections with direction (+/-)
+- [ ] Traced at least one reinforcing loop
+- [ ] Traced at least one balancing loop
+- [ ] Identified significant delays
+- [ ] Determined currently dominant loop
+- [ ] Identified leverage points at multiple levels
+- [ ] Selected intervention with appropriate leverage
+- [ ] Considered unintended effects of intervention
+
+## Key Questions
+
+- "What feeds back into itself here?"
+- "Is this self-reinforcing or self-correcting?"
+- "What's the goal this system is seeking?"
+- "Where are the delays, and how long are they?"
+- "Which loop is currently dominant?"
+- "What would shift dominance to a different loop?"
+- "What's the highest-leverage intervention available?"
+- "If I change X, what loops are affected?"
+
+## Meadows' Wisdom
+
+"We can't control systems or figure them out. But we can dance with them."
+
+"The least obvious part of the system, its function or purpose, is often the most crucial determinant of the system's behavior."
+
+"Pay attention to what is important, not just what is quantifiable."
+
+Systems are not puzzles to be solved but patterns to be understood and influenced. Effective intervention requires humility about control and attention to feedback.