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.
Installs just this skill. Get the whole plugin for auto-invocation.
⚡ How it fires
How this skill gets triggered: by you, by Claude, or both.
Fires itselfClaude auto-loads it when your prompt matches the work.
You can call itInvoke it directly when you want it.
Slash command/thinking-feedback-loops
👁️ Context preview
The summary Claude sees to decide when to auto-load this skill.
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.
📊 Stats
Stars863
Forks126
LanguageJavaScript
LicenseMIT
📦 Ships with thinking-skills
</> SKILL.md
thinking-feedback-loops.SKILL.md
---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)
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.
- `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.
