Initial commit

skills/systems-thinking-leverage/SKILL.md

@@ -0,0 +1,286 @@
+---
+name: systems-thinking-leverage
+description: Use when problems involve interconnected components with feedback loops (reinforcing or balancing), delays, or emergent behavior where simple cause-effect thinking fails. Invoke when identifying leverage points for intervention (where to push for maximum effect with minimum effort), understanding why past solutions failed or had unintended consequences, analyzing system archetypes (fixes that fail, shifting the burden, tragedy of the commons, limits to growth, escalation), mapping stocks and flows (accumulations and rates of change), discovering feedback loop dynamics, finding root causes in complex adaptive systems, designing interventions that work with system structure rather than against it, or when user mentions systems thinking, leverage points, feedback loops, unintended consequences, system dynamics, causal loop diagrams, or complex systems. Apply to organizational systems (employee engagement, scaling challenges, productivity decline), product/technical systems (technical debt accumulation, performance degradation, adoption barriers), social systems (polarization, misinformation spread, community issues), environmental systems (climate, resource depletion, pollution), personal systems (habit formation, burnout, skill development), and anywhere simple linear interventions repeatedly fail while systemic patterns persist.
+---
+# Systems Thinking & Leverage Points
+
+## Purpose
+
+Find high-leverage intervention points in complex systems by mapping feedback loops, identifying system archetypes, and understanding where small changes can produce large effects.
+
+## When to Use
+
+**Invoke this skill when:**
+- Problem involves multiple interconnected parts with feedback loops
+- Past solutions failed or caused unintended consequences
+- Simple cause-effect thinking doesn't capture the dynamics
+- You need to find where to intervene for maximum leverage
+- System exhibits delays, accumulations, or emergent behavior
+- Patterns keep recurring despite different people/contexts (system archetype)
+- Need to understand why things got this way (stock accumulation)
+- Deciding between intervention points (parameters vs. structure vs. goals vs. paradigms)
+
+**Don't use when:**
+- Problem is simple cause-effect with clear solution
+- System has only 1-2 components with no feedback
+- Linear analysis is sufficient
+- Time constraints require immediate action (no time for mapping)
+
+## What Is It?
+
+**Systems thinking** analyzes how interconnected components create emergent behavior through feedback loops, stocks/flows, and delays. **Leverage points** (Donella Meadows) are places to intervene in a system ranked by effectiveness:
+
+**Low leverage** (easy but weak): Parameters (numbers, rates, constants)
+**Medium leverage**: Buffers, stock structures, delays, feedback loop strength
+**High leverage** (hard but powerful): Information flows, rules, self-organization, goals, paradigms
+
+**Example**: Company with high employee turnover (problem).
+
+**Low leverage**: Increase salaries 10% (parameter) → Temporary effect, competitors match
+**Medium leverage**: Improve manager-employee feedback frequency (balancing loop) → Some improvement
+**High leverage**: Change goal from "minimize cost per employee" to "maximize team capability" → Shifts hiring, training, retention decisions system-wide
+
+**Quick example of feedback loops:**
+- **Reinforcing loop** (R): More engaged employees → Better customer experience → More revenue → More investment in employees → More engaged employees (growth or collapse)
+- **Balancing loop** (B): Workload increases → Stress increases → Burnout → Productivity decreases → Workload increases further (goal-seeking)
+- **Delays**: Training today → Skills improve (3-6 months delay) → Productivity increases. Ignoring delay causes impatience and abandoning training too early.
+
+## Workflow
+
+Copy this checklist and track your progress:
+
+```
+Systems Thinking & Leverage Progress:
+- [ ] Step 1: Define system and problem
+- [ ] Step 2: Map system structure
+- [ ] Step 3: Identify leverage points
+- [ ] Step 4: Validate and test interventions
+- [ ] Step 5: Design high-leverage strategy
+```
+
+**Step 1: Define system and problem**
+
+Clarify system boundaries (what's in/out of system), key variables (stocks that accumulate, flows that change them), and problem symptom vs. underlying pattern. Use [System Definition](#system-definition) section below.
+
+**Step 2: Map system structure**
+
+For simple cases → Use [resources/template.md](resources/template.md) for quick causal loop diagram and stock-flow identification. For complex cases → Study [resources/methodology.md](resources/methodology.md) for system archetypes, multi-loop analysis, and time delays.
+
+**Step 3: Identify leverage points**
+
+Apply Meadows' leverage hierarchy (parameters < buffers < structure < delays < balancing loops < reinforcing loops < information < rules < self-organization < goals < paradigms). See [Leverage Points Analysis](#leverage-points-analysis) below and [resources/methodology.md](resources/methodology.md) for techniques.
+
+**Step 4: Validate and test interventions**
+
+Self-assess using [resources/evaluators/rubric_systems_thinking_leverage.json](resources/evaluators/rubric_systems_thinking_leverage.json). Test mental models: what happens if we push here? What are second-order effects? What delays might undermine intervention? See [Validation](#validation) section.
+
+**Step 5: Design high-leverage strategy**
+
+Create `systems-thinking-leverage.md` with system map, leverage point ranking, recommended interventions, and predicted outcomes. See [Delivery Format](#delivery-format) section.
+
+---
+
+## System Definition
+
+Before mapping, clarify:
+
+**1. System Boundary**
+- **What's inside the system?** (components you're analyzing)
+- **What's outside?** (external forces you can't control)
+- **Why this boundary?** (pragmatic scope for intervention)
+
+**2. Key Variables**
+- **Stocks**: Things that accumulate (employee count, technical debt, customer base, trust, knowledge)
+- **Flows**: Rates of change (hiring rate, bug introduction rate, churn rate, relationship building rate)
+- **Goals**: What the system is trying to achieve (may be implicit)
+
+**3. Time Horizon**
+- **Short-term** (weeks-months): Focus on flows and immediate feedback
+- **Long-term** (years): Focus on stocks, paradigms, and structural change
+
+**4. Problem Statement**
+- **Symptom**: What's the observable issue? (e.g., "customer churn is 30%/year")
+- **Pattern**: What's the recurring dynamic? (e.g., "onboarding improvements work briefly then churn returns")
+- **Hypothesis**: What feedback loop might explain this? (e.g., "quick onboarding sacrifices depth → users don't see value → churn → pressure for faster onboarding")
+
+---
+
+## Leverage Points Analysis
+
+**Meadows' 12 Leverage Points** (ascending order of effectiveness):
+
+**12. Parameters** (weak) - Constants, numbers (tax rates, salaries, prices)
+- Easy to change, low resistance
+- Effects are linear and temporary
+- Example: Increase training budget 20%
+
+**11. Buffers** - Stock sizes relative to flows (reserves, inventories)
+- Larger buffers increase stability but reduce responsiveness
+- Example: Increase runway from 6 to 12 months
+
+**10. Stock-and-Flow Structures** - Physical system design
+- Hard to change once built (buildings, infrastructure)
+- Example: Redesign office for collaboration vs. heads-down work
+
+**9. Delays** - Time lags in information flows
+- Reducing delays improves responsiveness (if system is agile)
+- Too-short delays can cause instability
+- Example: Daily feedback vs. annual reviews
+
+**8. Balancing Feedback Loops** - Strength of stabilizing forces
+- Weaken to enable growth, strengthen to prevent overshoot
+- Example: Make incident post-mortems blameless (weaken fear loop)
+
+**7. Reinforcing Feedback Loops** - Strength of amplifying forces
+- Strengthen positive loops (learning), weaken negative loops (burnout)
+- Example: Invest in developer tools → faster builds → more experiments → better tools
+
+**6. Information Flows** - Who has access to what information
+- Make consequences visible to those who can act
+- Example: Show developers the support tickets caused by their code
+
+**5. Rules** - Incentives, constraints, punishments
+- Shape what behaviors are rewarded
+- Example: Tie bonuses to team outcomes not individual metrics
+
+**4. Self-Organization** - Power to add/change/evolve structure
+- Enable system to adapt and evolve
+- Example: Let teams choose their own tools and processes
+
+**3. Goals** - Purpose the system serves
+- Changing goals redirects the entire system
+- Example: Shift from "ship features fast" to "solve user problems sustainably"
+
+**2. Paradigms** - Mindset from which the system arises
+- Assumptions, worldview, mental models
+- Example: Shift from "employees are costs" to "employees are investors of human capital"
+
+**1. Transcending Paradigms** (strongest) - Ability to shift between paradigms
+- Meta-level: recognizing paradigms are just one lens
+- Example: Hold "growth" and "sustainability" paradigms simultaneously, choose contextually
+
+**How to Use This Hierarchy:**
+1. List all possible intervention points
+2. Classify each by leverage level (1-12)
+3. Prioritize high-leverage interventions (1-7) over low-leverage (8-12)
+4. Consider feasibility: High leverage often faces high resistance
+
+---
+
+## Validation
+
+Before finalizing, check:
+
+**System Map Quality:**
+- [ ] All major feedback loops identified (R for reinforcing, B for balancing)?
+- [ ] Stocks and flows distinguished (nouns vs. verbs)?
+- [ ] Delays explicitly noted (with estimated time lag)?
+- [ ] System boundary clear (what's in/out)?
+- [ ] Connections show polarity (+ same direction, - opposite direction)?
+
+**Leverage Point Analysis:**
+- [ ] Multiple intervention points considered (not just first idea)?
+- [ ] Each intervention classified by leverage level (1-12)?
+- [ ] High-leverage interventions identified and prioritized?
+- [ ] Trade-offs acknowledged (leverage vs. feasibility)?
+- [ ] Second-order effects anticipated (what else changes)?
+
+**Archetype Recognition** (if applicable):
+- [ ] Does system match known archetype (fixes that fail, shifting the burden, tragedy of commons, etc.)?
+- [ ] If yes, what's the typical failure mode for this archetype?
+- [ ] What's the high-leverage intervention for this archetype?
+
+**Mental Model Testing:**
+- [ ] What happens if we intervene at this leverage point?
+- [ ] What are unintended consequences (delays, compensating loops)?
+- [ ] Will the system resist this intervention? How?
+- [ ] What needs to change for intervention to stick?
+
+**Minimum Standard:** Use rubric (resources/evaluators/rubric_systems_thinking_leverage.json). Average score ≥ 3.5/5 before delivering.
+
+---
+
+## Delivery Format
+
+Create `systems-thinking-leverage.md` with:
+
+**1. System Overview**
+- Boundary definition
+- Key stocks and flows
+- Problem statement (symptom → pattern → hypothesis)
+
+**2. System Map**
+- Causal loop diagram (text or ASCII representation)
+- Feedback loops identified (R1, R2, B1, B2, etc.)
+- Stock-flow structure (if relevant)
+- Delays noted
+
+**3. Leverage Point Analysis**
+- All candidate interventions listed
+- Classification by leverage level (1-12)
+- Trade-off analysis (leverage vs. feasibility)
+- Recommended high-leverage interventions (rank-ordered)
+
+**4. Intervention Strategy**
+- Primary intervention (highest leverage and feasible)
+- Supporting interventions (reinforce primary)
+- Predicted outcomes (based on feedback loop dynamics)
+- Risks and unintended consequences
+- Success metrics (leading and lagging indicators)
+
+**5. Implementation Considerations**
+- Resistance points (where system will push back)
+- Time horizon (when to expect results given delays)
+- Monitoring plan (what to track to validate model)
+
+---
+
+## Common System Archetypes
+
+If system matches these patterns, leverage points are well-known:
+
+**Fixes That Fail**
+- **Pattern**: Quick fix works initially → Problem returns → Rely more on fix → Problem worsens
+- **Example**: Crunch time to meet deadline → Technical debt → Future deadlines harder → More crunch time
+- **Leverage**: Address root cause (schedule realism), not symptom (work hours)
+
+**Shifting the Burden**
+- **Pattern**: Symptomatic solution (easy) used instead of fundamental solution (hard) → Fundamental solution atrophies → More dependent on symptomatic solution
+- **Example**: Hire contractors (symptomatic) vs. grow internal capability (fundamental)
+- **Leverage**: Invest in fundamental solution, gradually reduce symptomatic solution
+
+**Tragedy of the Commons**
+- **Pattern**: Shared resource → Each actor maximizes individual gain → Resource depletes → Everyone suffers
+- **Example**: Shared codebase → Each team adds dependencies → Build time explodes
+- **Leverage**: Make consequences visible (information flow), add usage limits (rules), or enable self-organization (governance)
+
+**Limits to Growth**
+- **Pattern**: Reinforcing growth → Hits limiting factor → Growth slows/reverses
+- **Example**: Viral growth → Support overwhelmed → Poor experience → Negative word-of-mouth
+- **Leverage**: Anticipate limit, invest in expanding it before growth hits it
+
+For more archetypes, see [resources/methodology.md](resources/methodology.md).
+
+---
+
+## Quick Reference
+
+**Resources:**
+- [resources/template.md](resources/template.md) - Quick-start for simple systems
+- [resources/methodology.md](resources/methodology.md) - Advanced techniques, more archetypes, multi-loop analysis
+- [resources/evaluators/rubric_systems_thinking_leverage.json](resources/evaluators/rubric_systems_thinking_leverage.json) - Quality criteria
+
+**Key Concepts:**
+- **Stocks**: Accumulations (nouns) - employee count, technical debt, trust
+- **Flows**: Rates of change (verbs) - hiring rate, bug introduction rate
+- **Reinforcing loops** (R): Amplify change (growth or collapse)
+- **Balancing loops** (B): Resist change (goal-seeking, stabilizing)
+- **Delays**: Time between cause and effect (minutes to years)
+- **Leverage**: Where to intervene for maximum effect per effort
+
+**Red Flags:**
+- Treating symptoms instead of root causes (low leverage)
+- Ignoring feedback loops (interventions backfire)
+- Missing delays (impatience, premature abandonment)
+- Intervening at wrong leverage point (pushing parameters when structure needs changing)
+- Not anticipating unintended consequences (system pushback)

skills/systems-thinking-leverage/resources/evaluators/rubric_systems_thinking_leverage.json

@@ -0,0 +1,166 @@
+{
+  "criteria": [
+    {
+      "name": "System Boundary Definition",
+      "weight": 1.2,
+      "description": "Is the system boundary clearly defined with pragmatic rationale for inclusion/exclusion?",
+      "levels": {
+        "5": "System boundary explicitly stated (what's in/out), rationale provided (why this scope), pragmatically scoped for intervention (actionable), acknowledges what's excluded and why (external forces, out of control). Boundary is neither too narrow (misses key feedback) nor too broad (unwieldy analysis).",
+        "4": "Boundary clear with rationale. Mostly pragmatic scope. Some acknowledgment of exclusions. Minor boundary issues (slightly too narrow or broad but workable).",
+        "3": "Boundary stated but rationale unclear or weak. Scope may be too narrow (misses important feedback loops) or too broad (includes uncontrollable elements). Limited acknowledgment of exclusions.",
+        "2": "Boundary vague or arbitrary. No clear rationale for inclusion/exclusion. Scope inappropriate (misses critical components or includes irrelevant ones). Exclusions not acknowledged.",
+        "1": "No system boundary defined or completely inappropriate scope. Analysis lacks focus. Unclear what's being analyzed."
+      }
+    },
+    {
+      "name": "Stock-Flow Distinction",
+      "weight": 1.3,
+      "description": "Are stocks (accumulations) and flows (rates of change) correctly identified and distinguished?",
+      "levels": {
+        "5": "Stocks clearly identified as accumulations (nouns: employee count, technical debt, trust). Flows clearly identified as rates of change (verbs: hiring rate, bug introduction rate). Stocks and flows connected (flows change stocks). Units specified (e.g., people, bugs/sprint). No confusion between stocks and flows.",
+        "4": "Stocks and flows mostly distinguished. Connections shown. Units mostly specified. Minor confusion (1-2 misclassifications).",
+        "3": "Some stocks and flows identified but distinctions inconsistent. Some connections shown. Units often missing. Noticeable confusion (treating stocks as flows or vice versa).",
+        "2": "Stocks and flows mixed up frequently. Connections unclear. Units rarely specified. Fundamental confusion (e.g., 'morale is flowing').",
+        "1": "No distinction between stocks and flows or entirely incorrect. Variables listed without understanding accumulation vs. rate."
+      }
+    },
+    {
+      "name": "Feedback Loop Identification",
+      "weight": 1.5,
+      "description": "Are feedback loops (reinforcing and balancing) correctly identified with proper polarity?",
+      "levels": {
+        "5": "At least one reinforcing loop (R) and one balancing loop (B) identified. Loop polarity correct (R = even # of negative links, B = odd # of negative links). Link polarity marked (+ same direction, - opposite direction). Loop effects described (R amplifies change growth/collapse, B resists change seeks goal). Loops labeled (R1, R2, B1, B2) for reference. Interconnections between loops shown.",
+        "4": "R and B loops identified. Polarity mostly correct. Effects described. Loops labeled. Some interconnections shown. Minor polarity errors (1-2 links).",
+        "3": "Loops identified but polarity inconsistent or incorrect. Effects vaguely described. Limited labeling. Interconnections missing or unclear. Loops may be isolated (not showing system structure).",
+        "2": "Loops present but polarity frequently wrong. Effects not described or incorrect (e.g., calling B loop 'reinforcing'). No labeling. Loops disconnected. Fundamental misunderstanding of feedback.",
+        "1": "No feedback loops identified or entirely incorrect. Linear cause-effect thinking only (A→B→C, no feedback)."
+      }
+    },
+    {
+      "name": "Delay Recognition",
+      "weight": 1.2,
+      "description": "Are time delays explicitly noted with estimated duration and impact on system dynamics?",
+      "levels": {
+        "5": "Delays explicitly marked in loops (e.g., [~~] notation or stated). Time lag quantified (not just 'delayed' but '3-6 months', '2 weeks'). Delay types distinguished (physical, information, perception). Impact of delays explained (can cause oscillations, overshoot, impatience leading to premature abandonment). Critical delays highlighted (where they most affect system behavior).",
+        "4": "Delays noted and mostly quantified. Impact explained. Some type distinction. Critical delays identified. Minor gaps (some delays not quantified).",
+        "3": "Delays mentioned but often not quantified ('delayed' without timeframe). Impact vaguely described. No type distinction. Critical vs. non-critical delays not distinguished.",
+        "2": "Delays rarely mentioned or acknowledged. Not quantified. Impact not described. System treated as if cause and effect are immediate.",
+        "1": "No delay recognition. Analysis assumes instantaneous response. Ignores time lag entirely."
+      }
+    },
+    {
+      "name": "System Archetype Recognition",
+      "weight": 1.3,
+      "description": "If system matches a known archetype, is it recognized and leveraged for insights?",
+      "levels": {
+        "5": "System archetype identified if applicable (Fixes That Fail, Shifting Burden, Tragedy of Commons, Limits to Growth, etc.). Archetype-specific dynamics described (how it plays out in this context). Typical failure mode acknowledged ('this archetype usually fails when...'). Archetype-specific high-leverage intervention identified. If no archetype match, explicitly stated (not forced).",
+        "4": "Archetype recognized. Dynamics described. Failure mode noted. Intervention suggested. May slightly force-fit archetype.",
+        "3": "Archetype mentioned but dynamics unclear or generic. Failure mode not described. Intervention not archetype-specific. Some force-fitting.",
+        "2": "Archetype misidentified (wrong pattern) or dynamics misunderstood. Intervention doesn't match archetype. Heavy force-fitting (trying to make system fit archetype when it doesn't).",
+        "1": "No archetype recognition when obvious pattern exists OR archetype mentioned but completely misapplied. N/A if system genuinely doesn't match known archetypes (rare)."
+      }
+    },
+    {
+      "name": "Leverage Point Classification",
+      "weight": 1.5,
+      "description": "Are interventions classified by Meadows' leverage hierarchy and prioritized accordingly?",
+      "levels": {
+        "5": "All candidate interventions listed (not just one idea). Each classified by leverage level (1-12 using Meadows' hierarchy: parameters, buffers, structure, delays, feedback loops, information, rules, self-organization, goals, paradigms). High-leverage interventions (1-7) identified and prioritized over low-leverage (8-12). Rationale for classification clear (why this is a 'goal' vs. 'parameter' intervention). Trade-offs acknowledged (leverage vs. feasibility, impact vs. resistance).",
+        "4": "Multiple interventions listed. Classification by leverage level. High-leverage prioritized. Rationale mostly clear. Trade-offs noted. Minor misclassifications (1-2).",
+        "3": "Some interventions listed but incomplete. Classification attempted but inconsistent or incorrect. High-leverage mentioned but not consistently prioritized. Rationale vague. Trade-offs minimally addressed.",
+        "2": "Few interventions (first idea only). Classification missing or wrong. No prioritization by leverage. Defaults to parameter-tweaking (level 12) without considering higher-leverage points. Trade-offs ignored.",
+        "1": "Single intervention (no alternatives considered) or interventions not classified. No understanding of leverage hierarchy. Only low-leverage interventions (parameters) suggested."
+      }
+    },
+    {
+      "name": "Intervention-Loop Alignment",
+      "weight": 1.4,
+      "description": "Are interventions clearly linked to specific loops and leverage mechanisms explained?",
+      "levels": {
+        "5": "Each intervention explicitly linked to loop it affects (e.g., 'strengthens B1 by adding feedback', 'weakens R2 by removing incentive'). Mechanism explained (how intervention changes loop dynamics). Predicted effect on loop behavior (loop will slow/accelerate, goal will shift). Second-order effects anticipated (intervention affects Loop A, which then affects Loop B). Works with system structure, not against it.",
+        "4": "Interventions linked to loops. Mechanism explained. Predicted effects stated. Some second-order effects noted. Mostly works with structure.",
+        "3": "Some linkage to loops but often vague ('improves the system'). Mechanism unclear. Predicted effects not specific. Second-order effects rarely considered. May work against structure (fighting feedback).",
+        "2": "Interventions disconnected from loop analysis. No mechanism explanation. No predicted effects. Ignores second-order effects. Likely works against system (e.g., pushing parameters when structure needs changing).",
+        "1": "No connection between intervention and system structure. Intervention not informed by feedback loop analysis. Linear thinking ('fix symptom') despite system analysis."
+      }
+    },
+    {
+      "name": "Unintended Consequences Anticipation",
+      "weight": 1.3,
+      "description": "Are potential unintended consequences and system resistance identified and mitigated?",
+      "levels": {
+        "5": "Unintended consequences explicitly anticipated (what else might change?). Traced through other loops in system ('if we change X, loop B will activate and cause Y'). System resistance identified (who/what will push back? compensating loops?). Mitigation strategies for consequences and resistance. Time horizon for consequences (immediate, delayed). Monitoring plan to detect consequences early.",
+        "4": "Consequences anticipated. Traced through some loops. Resistance identified. Some mitigation. Time horizon noted. Monitoring mentioned.",
+        "3": "Consequences mentioned but not thoroughly traced. Resistance vaguely acknowledged. Limited mitigation. Time horizon unclear. Monitoring not specified.",
+        "2": "Consequences barely considered ('should work'). Resistance ignored. No mitigation. No monitoring. Overly optimistic (assumes intervention works as planned without pushback).",
+        "1": "No consideration of unintended consequences or resistance. Assumes linear impact (change X → Y happens, nothing else changes). Ignores system complexity."
+      }
+    },
+    {
+      "name": "Time Horizon Realism",
+      "weight": 1.1,
+      "description": "Are realistic timelines for impact set, accounting for delays and loop dynamics?",
+      "levels": {
+        "5": "Expected timeline for impact stated (short-term, medium-term, long-term). Timeline accounts for delays in system (e.g., 'training impact visible in 3-6 months due to skill development delay'). Distinguishes leading indicators (early signals) from lagging indicators (final outcomes). Warns against premature judgment ('don't expect results before X because delay is Y'). Phased expectations (what happens when).",
+        "4": "Timeline stated. Accounts for major delays. Leading vs. lagging indicators distinguished. Some warnings about premature judgment. Phased expectations.",
+        "3": "Timeline vague ('should improve over time'). Limited delay consideration. Indicators mentioned but not distinguished. No warnings about premature judgment.",
+        "2": "Timeline not specified or unrealistic (expects immediate impact despite delays). Ignores delays. No indicator distinction. Sets up for impatience.",
+        "1": "No time horizon discussion. Assumes immediate impact. Will lead to 'it didn't work' conclusion before delays complete."
+      }
+    },
+    {
+      "name": "Actionability & Implementation Clarity",
+      "weight": 1.2,
+      "description": "Are recommendations specific, actionable, and implementable?",
+      "levels": {
+        "5": "Interventions specific (clear what to do, not vague 'improve X'). Actionable (who does what, when, how). Implementation sequencing provided (Phase 1, 2, 3 or simultaneous). Success metrics defined (how to know it's working). Responsibility assigned or suggested (who owns this). Resource requirements acknowledged (time, budget, authority needed). Feasible given constraints.",
+        "4": "Specific and actionable. Sequencing provided. Metrics defined. Responsibility suggested. Resources acknowledged. Feasible.",
+        "3": "Somewhat specific but gaps ('improve culture' without how). Partially actionable. Limited sequencing. Metrics vague. Responsibility unclear. Feasibility questionable.",
+        "2": "Vague recommendations ('fix the problem', 'align incentives' without specifics). Not actionable (no clear steps). No sequencing, metrics, or ownership. Feasibility ignored.",
+        "1": "No actionable recommendations or so vague they're meaningless ('think systemically'). No implementation guidance."
+      }
+    }
+  ],
+  "guidance": {
+    "complexity": {
+      "simple": "Simple system (3-5 variables, 1-2 clear loops, single domain, no major delays). Target score ≥3.5 average. All criteria ≥3.",
+      "moderate": "Moderate complexity (5-10 variables, 3-5 loops with some nesting, archetype present, noticeable delays). Target score ≥4.0 average. All criteria ≥3.",
+      "complex": "Complex system (10+ variables, many interconnected loops, multiple archetypes, significant delays, multi-stakeholder). Target score ≥4.5 average for excellence. All criteria ≥4."
+    },
+    "minimum_thresholds": {
+      "critical_criteria": "System Boundary (≥3), Stock-Flow Distinction (≥3), Feedback Loop Identification (≥3), Leverage Point Classification (≥3) are CRITICAL. If any < 3, analysis is fundamentally flawed.",
+      "overall_average": "Must be ≥3.5 across all criteria before delivering. Higher threshold (≥4.0) for moderate systems, (≥4.5) for complex systems or high-stakes decisions."
+    },
+    "weight_interpretation": "Criteria weights (1.1x to 1.5x) reflect importance. Feedback Loop Identification (1.5x) and Leverage Point Classification (1.5x) are most critical. Stock-Flow Distinction (1.3x), Archetype Recognition (1.3x), Intervention-Loop Alignment (1.4x), and Unintended Consequences (1.3x) are highly important. Boundary (1.2x), Delay (1.2x), Actionability (1.2x), Time Horizon (1.1x) are important but less central."
+  },
+  "common_failure_modes": {
+    "linear_thinking": "Feedback Loop Identification: 1-2. Analysis is linear (A→B→C) without feedback loops (A→B→C→A). Fix: Ask 'how does C affect A? Is there a loop?'",
+    "parameter_only_interventions": "Leverage Point Classification: 1-2. All interventions are parameter tweaks (increase budget 10%, add 2 people). Fix: Use Meadows' hierarchy. Prioritize levels 1-7 (goals, rules, information, self-organization) over 12 (parameters).",
+    "vague_boundary": "System Boundary: 1-2. Boundary unclear ('the whole company', 'everything related to X'). Fix: Be specific. What components are in? What's out? Why this scope for intervention?",
+    "stock_flow_confusion": "Stock-Flow Distinction: 1-2. Treating stocks as flows ('morale is flowing', 'trust increases') or vice versa. Fix: Stocks are nouns (accumulations measured at a point in time). Flows are verbs (rates measured per time period).",
+    "missing_delays": "Delay Recognition: 1-2. Assumes immediate effect. Impatient conclusions ('tried for a week, didn't work'). Fix: Estimate delays. Quantify ('3-6 months'). Warn about premature abandonment.",
+    "no_unintended_consequences": "Unintended Consequences: 1-2. Assumes intervention works as planned, no side effects. Fix: Trace intervention through all loops. Ask 'what else changes? Who pushes back?'",
+    "isolated_loops": "Feedback Loop Identification: 2-3. Loops identified but disconnected (each loop in isolation, no interaction). Fix: Show how loops interconnect. Which loops modulate or conflict with others?",
+    "wrong_archetype": "Archetype Recognition: 1-2. Force-fits system into archetype that doesn't match. Fix: Archetypes are lenses, not laws. If doesn't fit cleanly, don't force it. Multiple archetypes can coexist.",
+    "intervention_not_linked_to_loops": "Intervention-Loop Alignment: 1-2. Recommendations disconnected from loop analysis. Fix: For each intervention, state which loop it affects and how (strengthens/weakens, changes goal, adds information flow).",
+    "unrealistic_timelines": "Time Horizon: 1-2. Expects immediate results despite delays. Fix: Set phased expectations. Short-term (1-3 mo): X. Medium-term (3-12 mo): Y. Long-term (1+ yr): Z.",
+    "vague_recommendations": "Actionability: 1-2. 'Improve culture', 'align incentives' without specifics. Fix: Make actionable. Who does what by when? How measured? What resources needed?"
+  },
+  "self_check_questions": [
+    "System Boundary: Is it clear what's in/out of the system? Why this boundary?",
+    "Stocks vs. Flows: Can I distinguish accumulations (stocks, nouns) from rates (flows, verbs)?",
+    "Feedback Loops: Have I identified at least one R loop and one B loop? Is polarity correct?",
+    "Delays: Are delays explicitly noted and quantified (not just 'delayed' but '3 months')?",
+    "Archetypes: Does system match a known archetype? If so, which one and how?",
+    "Leverage Points: Are interventions classified by level (1-12)? Are high-leverage (1-7) prioritized?",
+    "Intervention-Loop Link: Can I explain which loop each intervention affects and how?",
+    "Unintended Consequences: What else might change if I intervene? Who/what will resist?",
+    "Time Horizon: When will results be visible, accounting for delays? Am I being realistic?",
+    "Actionability: Are recommendations specific enough to implement (who, what, when, how)?",
+    "Dominant Loop: Which loop drives current behavior? Which will dominate next?",
+    "Trade-offs: Do I acknowledge leverage vs. feasibility trade-offs?",
+    "Second-Order Effects: Have I traced intervention through multiple loops (not just first-order)?",
+    "Overall: Would a systems thinking expert accept this analysis as sound?"
+  ],
+  "evaluation_notes": "Systems Thinking & Leverage quality assessed across 10 weighted criteria. Critical criteria (System Boundary, Stock-Flow, Feedback Loops, Leverage Points) must be ≥3 or analysis is fundamentally flawed. Minimum standard: ≥3.5 average for simple systems, ≥4.0 for moderate, ≥4.5 for complex. Feedback Loop Identification (1.5x) and Leverage Point Classification (1.5x) are highest-weighted criteria. Common failures: linear thinking (no feedback loops), parameter-only interventions (ignoring high-leverage points), missing delays (unrealistic timelines), vague boundaries, stock-flow confusion, no unintended consequence anticipation. Quality analysis distinguishes stocks (accumulations) from flows (rates), identifies R and B loops with correct polarity, classifies interventions by Meadows' hierarchy (1-12), links interventions to specific loops and mechanisms, anticipates second-order effects and resistance, sets realistic timelines accounting for delays, and provides actionable recommendations with clear implementation guidance."
+}

skills/systems-thinking-leverage/resources/methodology.md

@@ -0,0 +1,494 @@
+# Advanced Systems Thinking & Leverage Methodology
+
+## Workflow
+
+Copy this checklist and track your progress:
+
+```
+Advanced Systems Thinking Progress:
+- [ ] Step 1: Advanced system mapping techniques
+- [ ] Step 2: Identify system archetypes
+- [ ] Step 3: Analyze multi-loop interactions
+- [ ] Step 4: Model time delays and tipping points
+- [ ] Step 5: Design archetype-specific interventions
+```
+
+**Step 1**: Use [1. Advanced Causal Loop Techniques](#1-advanced-causal-loop-techniques) for complex multi-loop systems.
+
+**Step 2**: Match your system to [2. System Archetypes Library](#2-system-archetypes-library) (10 common patterns).
+
+**Step 3**: Apply [3. Multi-Loop Interaction Analysis](#3-multi-loop-interaction-analysis) to understand loop conflicts and synergies.
+
+**Step 4**: Use [4. Time Delays & Tipping Points](#4-time-delays--tipping-points) to model non-linear dynamics.
+
+**Step 5**: Implement archetype-specific strategies from [5. Intervention Strategies by Archetype](#5-intervention-strategies-by-archetype).
+
+---
+
+## 1. Advanced Causal Loop Techniques
+
+### Link Polarity Analysis
+
+**Every link in a causal loop has polarity:**
+- **Positive (+)**: Variables move in same direction (A↑ causes B↑, A↓ causes B↓)
+- **Negative (-)**: Variables move in opposite directions (A↑ causes B↓, A↓ causes B↑)
+
+**Loop polarity (overall):**
+- **Reinforcing (R)**: Even number of negative links (0, 2, 4, ...) → Amplifies change
+- **Balancing (B)**: Odd number of negative links (1, 3, 5, ...) → Resists change, seeks goal
+
+**Example:**
+```
+Quality → (+) → Customer Satisfaction → (+) → Referrals → (+) → New Customers → (+) → Revenue → (+) → Investment in Quality → (+) → Quality
+```
+Links: 6 positive, 0 negative → **Reinforcing** (growth or collapse loop)
+
+**Example:**
+```
+Inventory → (-) → Gap from Target → (+) → Order Rate → (+) → Inventory
+```
+Links: 2 positive, 1 negative → **Balancing** (seeks target inventory level)
+
+### Nested Loops
+
+**Real systems have multiple interconnected loops:**
+
+**Technique**: Identify primary loop, then secondary loops that modulate it.
+
+**Example - Product Development:**
+
+**R1 (Growth)**: `Better Product → More Users → More Revenue → More Investment → Better Product`
+
+**B1 (Quality Gate)**: `Feature Count → (+) → Complexity → (+) → Bugs → (-) → User Satisfaction → (-) → Revenue`
+
+**Analysis**: R1 drives growth, but B1 limits it if quality isn't maintained. High-leverage intervention: Strengthen B1 by making complexity visible earlier (information flow).
+
+### Variable Typology
+
+**Exogenous** (external) - Low leverage, must adapt | **Stock** (accumulates) - High leverage but slow | **Flow** (rate) - Medium leverage | **Policy** (rule) - High leverage
+
+**Strategic focus**: Intervene on policies (high leverage) rather than stocks (slow) or exogenous variables (uncontrollable).
+
+---
+
+## 2. System Archetypes Library
+
+### Overview
+
+**System archetypes** are recurring patterns across different domains. Recognizing them provides:
+- Predictable failure modes
+- Known high-leverage interventions
+- Time-tested solutions
+
+**Ten Common Archetypes:**
+
+### Archetype 1: Fixes That Fail
+
+**Pattern**: Quick fix addresses symptom → Problem temporarily improves → Unintended consequence worsens problem → Need for fix increases
+
+**Structure**:
+- R loop: Problem → Quick Fix → Symptom Relief (immediate)
+- B loop (delayed): Quick Fix → Unintended Consequence → Problem (long-term)
+
+**Example**: Crunch time → Ship features → Technical debt → Slower development → More crunch time
+
+**High-leverage intervention**: Address root cause (realistic scheduling, refactoring time), not symptom (work hours)
+
+**Warning sign**: Solutions that work initially but need repeating at increasing frequency
+
+### Archetype 2: Shifting the Burden
+
+**Pattern**: Symptomatic solution (easy, fast) vs. Fundamental solution (hard, slow) → Symptomatic solution chosen repeatedly → Capability for fundamental solution atrophies → Dependency on symptomatic solution increases
+
+**Structure**:
+- B1 (quick): Problem → Symptomatic Solution → Problem (temporary relief)
+- B2 (slow): Problem → Fundamental Solution → Problem (lasting fix)
+- R (addictive): Use of Symptomatic Solution → Atrophy of Fundamental Solution Capability
+
+**Example**: Hire contractors (symptomatic) vs. Build internal capability (fundamental) → Internal capability declines → More contractor dependency
+
+**High-leverage intervention**: Invest in fundamental solution while gradually reducing symptomatic solution. Don't cut symptomatic cold-turkey.
+
+**Warning sign**: "We keep throwing money at this problem" or "We can't function without [workaround]"
+
+### Archetype 3: Eroding Goals
+
+**Pattern**: Performance gap → Pressure → Lower goal instead of improving performance → Gap closes (temporarily) → Lowered expectations become new normal
+
+**Structure**:
+- B1 (easy): Gap → Lower Goal → Gap Closes
+- B2 (hard): Gap → Improve Performance → Gap Closes
+
+**Example**: Team velocity declining → Lower sprint commitment → "New normal" → Capability erodes further
+
+**High-leverage intervention**: Anchor goals to external standard (customer needs, market), not internal capability. Make goal erosion visible.
+
+**Warning sign**: "Let's be more realistic" becoming repeated refrain
+
+### Archetype 4: Escalation
+
+**Pattern**: A's actions threaten B → B retaliates → A feels more threatened → A escalates → B escalates → Spiral
+
+**Structure**: Two reinforcing loops feeding each other
+
+**Example**: Team A adds abstraction to isolate from Team B → Team B adds abstraction to protect from A → Integration cost explodes
+
+**High-leverage intervention**: One party unilaterally de-escalates (paradigm shift from competitive to cooperative)
+
+**Warning sign**: "Arms race" dynamics, tit-for-tat retaliation
+
+### Archetype 5: Success to the Successful
+
+**Pattern**: A and B compete for resource → A gains slight advantage → Resource flows to A → A's advantage grows → B starved → Winner-take-all
+
+**Structure**: Two reinforcing loops, one winning
+
+**Example**: Successful product gets more investment → More features, marketing → More success. Failing product starved → Decline accelerates
+
+**High-leverage intervention**: Diversification rules (minimum investment per option), explicit exploration budget
+
+**Warning sign**: "Betting on winners" strategy leading to monoculture
+
+### Archetype 6: Tragedy of the Commons
+
+**Pattern**: Shared resource → Each actor maximizes individual gain (rational) → Resource depletes → Everyone suffers
+
+**Structure**: Multiple reinforcing loops (individual gains) deplete shared stock
+
+**Example**: Shared codebase → Each team adds dependencies → Build time/complexity explodes → Everyone slowed
+
+**High-leverage interventions**:
+- **Information flow**: Make total resource usage visible to all users
+- **Rules**: Usage limits, quotas, or pricing
+- **Self-organization**: Enable collective governance
+
+**Warning sign**: "Prisoner's dilemma" dynamics, externalities not accounted for
+
+### Archetype 7: Limits to Growth
+
+**Pattern**: Reinforcing loop drives growth → Hits limiting constraint → Growth slows or reverses
+
+**Structure**:
+- R (growth): Success → Investment → More Success
+- B (limit): Success → Resource Constraint → Slows Success
+
+**Example**: Viral product growth → Support overwhelmed → Bad experience → Negative word-of-mouth → Growth reverses
+
+**High-leverage intervention**: Anticipate limit before hitting it. Invest in expanding constraint proactively.
+
+**Warning sign**: S-curve growth pattern, "growing pains"
+
+### Archetype 8: Growth and Underinvestment
+
+**Pattern**: Growth → Need for capacity → Underinvestment (cost-cutting) → Performance degrades → Lower growth
+
+**Structure**: R loop (growth) weakened by inadequate investment in capacity
+
+**Example**: Customer growth → Need more support staff → Hire slowly to control costs → Service quality drops → Churn increases
+
+**High-leverage intervention**: Invest ahead of demand (leading indicator), not reactively
+
+**Warning sign**: Chronic capacity shortages, "doing more with less" leading to quality drops
+
+### Archetype 9: Accidental Adversaries
+
+**Pattern**: A's actions inadvertently harm B → B takes protective action that harms A → Cycle repeats
+
+**Structure**: Two balancing loops that conflict
+
+**Example**: Engineering builds for technical elegance → Product complains features take too long → Engineering feels constrained, quality drops → Product complains about bugs
+
+**High-leverage intervention**: Make interdependence visible. Joint success metrics. Communication.
+
+**Warning sign**: Silos blaming each other, misaligned incentives
+
+### Archetype 10: Rule Beating
+
+**Pattern**: Rule created to achieve goal → Rule becomes target → Gaming behavior optimizes for rule, not goal → Goal not achieved
+
+**Structure**: B loop seeks rule compliance, not goal achievement (Goodhart's Law: "When measure becomes target, it ceases to be a good measure")
+
+**Example**: "Close 10 tickets/day" KPI → Developers close easy tickets, defer hard ones → Customer problems unsolved
+
+**High-leverage intervention**: Tie metrics to actual goals (outcomes), not proxies (outputs). Multi-dimensional metrics.
+
+**Warning sign**: "Teaching to the test", optimizing metrics while performance declines
+
+---
+
+## 3. Multi-Loop Interaction Analysis
+
+### Loop Dominance
+
+**In systems with multiple loops, ask:**
+1. **Which loop is dominant now?** (Drives current behavior)
+2. **Which loop will dominate next?** (After current limit hits)
+3. **What shifts dominance?** (Trigger conditions)
+
+**Example - Startup:**
+- **Early stage**: R loop (product-market fit → growth) dominant
+- **Scale stage**: B loop (operational complexity → slow down) becomes dominant
+- **Mature stage**: B loop (market saturation → plateau) dominates
+
+**Intervention timing**: Strengthen next-dominant loop before transition (build ops capability before scaling hits)
+
+### Loop Conflict vs. Synergy
+
+**Conflict**: Loops work against each other
+- **Example**: R1 (ship fast) vs. B1 (maintain quality) → Tension
+- **Resolution**: Higher-order goal that integrates both (sustainable velocity)
+
+**Synergy**: Loops reinforce each other
+- **Example**: R1 (learning improves skill) + R2 (skill improves confidence) → Virtuous cycle
+- **Leverage**: Activate both loops simultaneously
+
+### Archetype Combinations
+
+**Real systems often combine archetypes:**
+
+**Fixes That Fail + Shifting the Burden**:
+- Quick fix becomes symptomatic solution
+- Fundamental solution capability atrophies
+- Dependency deepens
+
+**Example**: Manual workarounds (quick fix) prevent automation investment (fundamental) → More manual work needed → Less time for automation
+
+**Intervention**: Reserve capacity for fundamental solutions (20% time, dedicated team)
+
+---
+
+## 4. Time Delays & Tipping Points
+
+### Types of Delays
+
+| Delay Type | Description | Example | Impact on System |
+|------------|-------------|---------|------------------|
+| **Physical** | Material transport, construction | Shipping, building | Predictable, manageable |
+| **Information** | Data collection, reporting | Metrics lag, surveys | Can reduce with better systems |
+| **Decision** | Analysis, approval cycles | Committee reviews | Process improvement opportunity |
+| **Perception** | Recognition that change occurred | "This isn't working" realization | Most dangerous - causes premature abandonment |
+
+**Perception delays are most problematic** because people conclude "intervention failed" before effects manifest.
+
+**Mitigation**: Set realistic timelines. Track leading indicators. Communicate expected delays upfront.
+
+### Tipping Points
+
+**Definition**: Threshold where small additional change causes large, often irreversible shift in system state.
+
+**Warning signs of approaching tipping point:**
+- Non-linear acceleration (change rate increasing)
+- Increased variability (system becoming unstable)
+- Slower recovery from perturbations (resilience declining)
+- Bifurcation signs (system choosing between two stable states)
+
+**Example - Team Morale:**
+- Stable state: High morale, productive
+- Tipping point: Key person leaves, others question staying
+- New stable state: Low morale, attrition spiral
+
+**Intervention strategies:**
+- **Preventive**: Increase buffer before tipping point (resilience)
+- **Early warning**: Monitor leading indicators (voluntary turnover, engagement scores)
+- **Circuit breaker**: Automatic intervention if approaching threshold
+
+### Stock-Induced Oscillations
+
+**Pattern**: Stock accumulates → Corrective action taken → Overcompensation due to delay → Stock depletes → Opposite action → Oscillation
+
+**Example - Hiring:**
+```
+Backlog accumulates (3 months) → Hire burst → Training delay (6 months) →
+Meanwhile backlog shrunk → Overstaffed → Layoffs → Cycle repeats
+```
+
+**Fix**:
+1. Reduce information delays (real-time backlog metrics)
+2. Smooth flow adjustments (hire steadily, not in bursts)
+3. Increase stock buffers (reduce sensitivity to fluctuations)
+
+---
+
+## 5. Intervention Strategies by Archetype
+
+### Strategy Matrix
+
+| Archetype | Low-Leverage (Avoid) | High-Leverage (Prioritize) |
+|-----------|---------------------|----------------------------|
+| **Fixes That Fail** | Keep applying fix harder | Address root cause; make unintended consequences visible early |
+| **Shifting Burden** | Cut symptomatic solution cold-turkey | Invest in fundamental while gradually reducing symptomatic |
+| **Eroding Goals** | Accept lower standards | Anchor goals externally; make goal erosion visible and costly |
+| **Escalation** | Match escalation | Unilateral de-escalation; shift to cooperative paradigm |
+| **Success to Successful** | "Back the winner" harder | Enforce diversity (quotas, exploration budget) |
+| **Tragedy of Commons** | Appeal to altruism | Make usage visible; add usage rules; enable self-governance |
+| **Limits to Growth** | Push growth harder | Anticipate limit proactively; invest in expanding constraint ahead |
+| **Growth & Underinvestment** | Cut costs to preserve margins | Invest ahead of demand (leading indicators) |
+| **Accidental Adversaries** | Optimize local metrics | Joint metrics; make interdependence visible; align incentives |
+| **Rule Beating** | Add more rules and enforcement | Tie metrics to actual goals (outcomes not outputs); multi-dimensional |
+
+### Leverage Point Tactics by Level
+
+**Level 12 (Parameters) - Weak:**
+- Tactic: Adjust numbers (budget +10%, salary +5%)
+- When useful: Temporary relief, testing hypotheses
+- Limitation: Competitors match, effects fade
+
+**Level 9 (Delays) - Medium:**
+- Tactic: Speed up feedback (daily standups vs. monthly reviews)
+- When useful: System is stable, faster feedback helps
+- Limitation: Too-fast feedback can destabilize (overreaction)
+
+**Level 6 (Information Flows) - Strong:**
+- Tactic: Show consequences to decision-makers (developers see support tickets their code causes)
+- When useful: Information asymmetry causing bad decisions
+- Limitation: Requires action authority, not just visibility
+
+**Level 5 (Rules) - Strong:**
+- Tactic: Change incentives (team outcomes vs. individual metrics)
+- When useful: Behavior misaligned with goals
+- Limitation: Can be gamed (Rule Beating archetype)
+
+**Level 3 (Goals) - Very Strong:**
+- Tactic: Redefine system purpose ("maximize learning" vs. "minimize failures")
+- When useful: Current goal produces perverse outcomes
+- Limitation: High resistance (threatens identity)
+
+**Level 2 (Paradigms) - Strongest:**
+- Tactic: Shift mental models ("employees are costs" → "employees are investors of human capital")
+- When useful: Deep cultural/strategic transformation needed
+- Limitation: Hardest to change, requires patience and evidence
+
+### Intervention Sequencing
+
+**For complex systems, sequence interventions:**
+
+**Phase 1: Stabilize (Balancing loops)**
+- Stop the bleeding (address immediate crises)
+- Strengthen balancing loops that prevent collapse
+- Reduce destabilizing delays
+
+**Phase 2: Improve (Parameters, Flows)**
+- Optimize current structure
+- Improve information flows
+- Adjust parameters for better performance
+
+**Phase 3: Transform (Structure, Goals, Paradigms)**
+- Redesign stock-flow structures
+- Change system goals
+- Shift underlying paradigms
+
+**Example - Turnaround:**
+1. **Stabilize**: Stop cash burn (balancing loop), reduce critical bugs (prevent churn)
+2. **Improve**: Speed up deployment (reduce delay), improve customer feedback flow (information)
+3. **Transform**: Shift from "ship features fast" to "solve customer problems sustainably" (goal/paradigm)
+
+---
+
+## 6. Modeling Techniques
+
+### Behavior Over Time (BOT) Graphs
+
+**Purpose**: Visualize how variables change over time to reveal patterns.
+
+**Technique**:
+1. Select key variables (stocks and critical flows)
+2. Plot expected trajectory (time on X-axis, value on Y-axis)
+3. Mark intervention points
+4. Show multiple scenarios (baseline, with intervention)
+
+**Patterns to look for:**
+- **Exponential growth/decay**: Dominant reinforcing loop
+- **S-curve**: Growth hitting limit
+- **Oscillation**: Delayed balancing loops (stock-induced)
+- **Overshoot and collapse**: Reinforcing growth + hard limit + delay
+- **Steady state**: Balanced flows
+
+### Scenario Planning with Systems Thinking
+
+**Use cases**: Long-term strategy, uncertainty, multiple futures
+
+**Process**:
+1. **Identify key uncertainties** (which exogenous variables could vary?)
+2. **Create scenarios** (2-4 plausible futures based on uncertainty combinations)
+3. **Map each scenario's dominant loops** (which archetypes activate?)
+4. **Design robust strategy** (works across scenarios) or adaptive strategy (pivot points)
+
+**Example - Market Uncertainty:**
+- **Scenario A** (High demand): Limits to Growth archetype → Invest in capacity ahead
+- **Scenario B** (Low demand): Eroding Goals archetype → Maintain quality standards
+- **Robust strategy**: Flexible capacity (cloud vs. data center), core quality processes that scale up/down
+
+### Reference Modes
+
+**Definition**: Generic behavior patterns used to diagnose systems.
+
+**Common reference modes:**
+- **Linear growth**: Constant flow, no feedback
+- **Exponential growth**: Unconstrained reinforcing loop
+- **S-curve growth**: Reinforcing loop hits balancing loop (limit)
+- **Overshoot and oscillation**: Growth with delayed balancing loop
+- **Overshoot and collapse**: Growth, hard limit, insufficient recovery
+
+**Diagnostic use**: Match your system's actual behavior over time to reference mode → Infer loop structure → Identify leverage points
+
+---
+
+## 7. Advanced Leverage Tactics
+
+### Counterintuitive Interventions
+
+**System thinking often reveals surprising leverage points:**
+
+**1. Slow down to speed up**
+- Reduce deployment frequency → Allow time for quality → Fewer rollbacks → Faster net progress
+- Paradox: Balancing loop (quality) strengthens reinforcing loop (learning)
+
+**2. Weaken feedback to enable change**
+- Reduce real-time monitoring during experimentation → Allow failure → Learning increases
+- Paradox: Too-strong balancing loops prevent exploration
+
+**3. Strengthen delays strategically**
+- Add cooling-off period before decisions → Reduce impulsive actions → Better outcomes
+- Paradox: Delay usually bad, but prevents overreaction oscillations
+
+**4. Reduce efficiency to increase resilience**
+- Maintain slack capacity (not 100% utilized) → Buffer against shocks → Faster recovery
+- Paradox: "Waste" increases long-term throughput
+
+### Multi-Stakeholder Systems
+
+**Challenge**: Different actors see different loops (paradigm diversity).
+
+**Technique - Participatory Modeling:**
+1. Bring stakeholders together
+2. Each draws their view of the system (causal loops)
+3. Integrate into unified map (reveals blind spots)
+4. Identify conflicts (where loops oppose)
+5. Find synergies (where loops align)
+6. Design interventions that work for all
+
+**Benefit**: Shared mental model → Aligned interventions → Less resistance
+
+### Adaptive Leverage
+
+**Principle**: Leverage points shift as system evolves.
+
+**Example - Product Lifecycle:**
+- **Early stage**: Paradigm/goals leverage (define what product does)
+- **Growth stage**: Stock-flow structure leverage (scale architecture)
+- **Maturity stage**: Information/rules leverage (optimize operations)
+- **Decline stage**: Goals leverage (pivot or exit)
+
+**Implication**: Revisit leverage analysis periodically. Yesterday's high-leverage point may be low-leverage today.
+
+---
+
+## 8. Common Pitfalls in Advanced Systems Thinking
+
+**Paralysis by analysis** - Fix: Time-box, start simple (3-5 variables), iterate
+**Missing dominant loop** - Fix: Identify which loop explains 80% of behavior
+**Ignoring paradigms** - Fix: Ask "what mental model drives this?"
+**Overcomplicating** - Fix: Start simple, add complexity only if needed
+**Confusing archetype with reality** - Fix: Archetypes are lenses, not laws
+**Static thinking** - Fix: Use behavior-over-time graphs, model evolution
+**Intervention without testing** - Fix: Pilot small, monitor, adapt

skills/systems-thinking-leverage/resources/template.md

@@ -0,0 +1,399 @@
+# Systems Thinking & Leverage Points Template
+
+## Workflow
+
+Copy this checklist and track your progress:
+
+```
+Systems Thinking Template Progress:
+- [ ] Step 1: Define system boundaries and variables
+- [ ] Step 2: Create causal loop diagram
+- [ ] Step 3: Identify stocks, flows, and delays
+- [ ] Step 4: Find leverage points
+- [ ] Step 5: Validate and finalize
+```
+
+**Step 1**: Fill out [Section 1: System Definition](#1-system-definition) to clarify boundaries, stocks, flows, and problem pattern.
+
+**Step 2**: Use [Section 2: Causal Loop Diagram](#2-causal-loop-diagram) to map feedback loops (R for reinforcing, B for balancing).
+
+**Step 3**: Complete [Section 3: Stock-Flow Analysis](#3-stock-flow-analysis) to identify what accumulates and at what rates.
+
+**Step 4**: Apply [Section 4: Leverage Point Ranking](#4-leverage-point-ranking) using Meadows' hierarchy to find high-leverage interventions.
+
+**Step 5**: Verify quality using [Quality Checklist](#quality-checklist) before delivering systems-thinking-leverage.md.
+
+---
+
+## 1. System Definition
+
+### System Boundary
+
+**What's inside the system** (components you're analyzing and can influence):
+
+[List the key components, actors, processes that are within your scope of analysis and intervention]
+
+**What's outside the system** (external forces you can't control but affect the system):
+
+[List external factors, constraints, or environmental conditions that influence the system but are beyond your control]
+
+**Why this boundary?**
+
+[Explain the pragmatic rationale for this scope - what makes this a useful boundary for analysis and intervention?]
+
+### Key Variables
+
+**Stocks** (things that accumulate - nouns):
+
+| Stock Name | Current Level | Description | Measurement Unit |
+|------------|---------------|-------------|------------------|
+| [e.g., Employee count] | [e.g., 250] | [What it represents] | [e.g., # people] |
+| [e.g., Technical debt] | [e.g., High] | [Description] | [e.g., story points, hours] |
+| [Stock 3] | [Level] | [Description] | [Unit] |
+| [Stock 4] | [Level] | [Description] | [Unit] |
+
+**Flows** (rates of change - verbs):
+
+| Flow Name | Current Rate | Affects Stock | Direction |
+|-----------|--------------|---------------|-----------|
+| [e.g., Hiring rate] | [e.g., 5/month] | [Employee count] | [Inflow ↑ / Outflow ↓] |
+| [e.g., Attrition rate] | [e.g., 3/month] | [Employee count] | [Outflow ↓] |
+| [Flow 3] | [Rate] | [Stock name] | [Direction] |
+| [Flow 4] | [Rate] | [Stock name] | [Direction] |
+
+**System Goals** (implicit or explicit):
+
+- Primary goal: [What is the system fundamentally trying to achieve?]
+- Secondary goals: [What other goals compete with or support the primary goal?]
+- Whose goals? [Which stakeholders' goals drive system behavior?]
+
+### Time Horizon
+
+**Analysis timeframe**: [Short-term (weeks-months) / Medium-term (quarters-year) / Long-term (years)]
+
+**Why this timeframe?** [Explain what you're trying to understand or influence within this time period]
+
+### Problem Statement
+
+**Symptom** (observable issue):
+
+[What's the visible problem? Include metrics if available. e.g., "Customer churn rate is 30%/year, up from 15% last year"]
+
+**Pattern** (recurring dynamic):
+
+[What's the underlying pattern or behavior over time? e.g., "Each time we improve onboarding, churn drops briefly (2-3 months) then returns to previous level"]
+
+**Hypothesis** (suspected feedback loop):
+
+[What feedback loop might explain this pattern? e.g., "Pressure to reduce churn → Quick onboarding fixes → Users don't understand value prop → Churn returns → More pressure for quick fixes"]
+
+---
+
+## 2. Causal Loop Diagram
+
+### Feedback Loops Identified
+
+**Reinforcing Loop R1: [Name]**
+
+```
+[Variable A] → (+/-) → [Variable B] → (+/-) → [Variable C] → (+/-) → [Variable A]
+```
+
+- **Description**: [How does this loop amplify change? What does it reinforce?]
+- **Polarity**: [+ means same direction, - means opposite direction]
+- **Effect**: [Growth or collapse? What happens if this loop dominates?]
+- **Time to complete loop**: [How long for one full cycle?]
+
+**Example:** `Engaged Employees → (+) → Customer Satisfaction → (+) → Revenue → (+) → Investment → (+) → Engaged Employees` (virtuous growth cycle)
+
+**Reinforcing Loop R2: [Name]** (if applicable)
+[Same structure as R1]
+
+**Balancing Loop B1: [Name]**
+
+```
+[Variable A] → (+/-) → [Variable B] → (+/-) → [Goal Gap] → (+/-) → [Corrective Action] → (+/-) → [Variable A]
+```
+
+- **Description**: [How does this loop resist change? What goal is it trying to maintain?]
+- **Goal**: [Target state this loop seeks]
+- **Effect**: [Stabilizes around what value?]
+- **Time to complete loop**: [How long for feedback?]
+
+**Example:** `Workload → (+) → Stress → (+) → Sick Days → (-) → Workload` (temporary relief, not solving root cause)
+
+**Balancing Loop B2: [Name]** (if applicable) - [Same structure as B1]
+
+### System Dynamics Map
+
+**ASCII Causal Loop Diagram:**
+
+```
+        +
+    A -----> B
+    ^        |
+    |        | +
+    |        v
+    +        C
+    |        |
+    |        | -
+    |        v
+    D <----- E
+
+R: A → B → C → A (Reinforcing)
+B: C → E → D → A (Balancing with delay [~~])
+```
+
+**Key:**
+- `→` with `+` means same direction (A increases → B increases)
+- `→` with `-` means opposite direction (C increases → E decreases)
+- `R` marks reinforcing loops (amplify change)
+- `B` marks balancing loops (resist change, goal-seeking)
+- `[~~]` marks delays (time lag between cause and effect)
+
+**Your diagram:**
+
+```
+[Draw your causal loop diagram here using ASCII art or describe the major connections]
+
+
+```
+
+---
+
+## 3. Stock-Flow Analysis
+
+### Stock Accumulation Dynamics
+
+For each major stock, trace how it changes:
+
+**Stock: [Stock Name]**
+
+**Inflows** (what increases it):
+- Flow 1: [Name] at rate [X/time period]
+- Flow 2: [Name] at rate [Y/time period]
+
+**Outflows** (what decreases it):
+- Flow 1: [Name] at rate [X/time period]
+- Flow 2: [Name] at rate [Y/time period]
+
+**Current state**: [Accumulating / Depleting / Stable]
+
+**Why?** [Are inflows > outflows (accumulating), inflows < outflows (depleting), or balanced (stable)?]
+
+**Delays:**
+- From [Flow/Action] to [Stock change]: [Time lag, e.g., "3-6 months"]
+- From [Flow/Action] to [Stock change]: [Time lag]
+
+**Implications**: [What happens if this stock continues accumulating/depleting? What's the consequence?]
+
+**Example:** Technical Debt stock - Inflows: quick fixes (20/sprint) + shaky features (10/sprint) = 30/sprint. Outflows: refactoring (5/sprint) + root-cause fixes (3/sprint) = 8/sprint. Net: +22/sprint accumulating. Delays: 3-6 months to slowdown, 1-2 sprints for improvement. Implication: In 6 months, debt slows development 50%, reinforcing quick-fix pressure.
+
+---
+
+## 4. Leverage Point Ranking
+
+### Candidate Interventions
+
+List all possible places to intervene:
+
+| Intervention | Description | Leverage Level (1-12) | Feasibility (High/Med/Low) | Expected Impact (High/Med/Low) |
+|--------------|-------------|-----------------------|----------------------------|--------------------------------|
+| [Intervention 1] | [Brief description] | [1-12, see hierarchy below] | [H/M/L] | [H/M/L] |
+| [Intervention 2] | [Description] | [Level] | [Feasibility] | [Impact] |
+| [Intervention 3] | [Description] | [Level] | [Feasibility] | [Impact] |
+| [Intervention 4] | [Description] | [Level] | [Feasibility] | [Impact] |
+| [Intervention 5] | [Description] | [Level] | [Feasibility] | [Impact] |
+
+**Meadows' Leverage Point Hierarchy** (for classification):
+- **12**: Parameters (numbers, rates) - LOW leverage
+- **11**: Buffers (stock sizes vs. flows)
+- **10**: Stock-flow structures (physical design)
+- **9**: Delays (time lags)
+- **8**: Balancing feedback loop strength
+- **7**: Reinforcing feedback loop strength
+- **6**: Information flows (who knows what)
+- **5**: Rules (incentives, constraints)
+- **4**: Self-organization (adapt/evolve capability)
+- **3**: Goals (system purpose)
+- **2**: Paradigms (mindset, mental models)
+- **1**: Transcending paradigms (paradigm fluidity) - HIGH leverage
+
+### High-Leverage Interventions (Priority)
+
+**Primary Intervention: [Name]**
+
+- **Leverage level**: [1-7, high leverage]
+- **Mechanism**: [How does this intervention work? Which loop does it affect?]
+- **Why high leverage?** [Explain why this is more effective than adjusting parameters]
+- **Feasibility challenges**: [What makes this hard? Who will resist?]
+- **Time to impact**: [How long until results visible, accounting for delays?]
+- **Success metrics**: [How will you know it's working? Leading and lagging indicators]
+
+**Supporting Intervention 1: [Name]**
+
+- **Leverage level**: [Level]
+- **How it supports primary**: [Explain complementary effect]
+- **Rationale**: [Why combine these interventions?]
+
+**Supporting Intervention 2: [Name]**
+
+[Same structure as Supporting Intervention 1]
+
+### Low-Leverage Interventions (Avoid or Deprioritize)
+
+**Why avoid:**
+
+| Intervention | Leverage Level | Why It's Low Leverage | Better Alternative |
+|--------------|----------------|------------------------|---------------------|
+| [e.g., Increase budget 10%] | [12 - Parameter] | [Temporary, competitors can match] | [Change hiring goal from "fill seats" to "build capability"] |
+| [Intervention 2] | [Level] | [Reason] | [Alternative] |
+
+---
+
+## 5. Intervention Strategy
+
+### Recommended Approach
+
+**Primary intervention**: [Name from high-leverage section above]
+
+**Supporting interventions**: [List 1-3 complementary interventions]
+
+**Sequencing**: [What order? Simultaneous or phased?]
+
+1. [First action and timing]
+2. [Second action and timing]
+3. [Third action and timing]
+
+**Rationale**: [Why this sequence? What dependencies exist?]
+
+### Predicted Outcomes
+
+**Short-term** (1-3 months): [Immediate effects? Which loops activate? Worse before better?]
+
+**Medium-term** (3-12 months): [Reinforcing loop momentum? Delays complete? Resistances emerge?]
+
+**Long-term** (1+ years): [New equilibrium? New limits? System evolution?]
+
+### Risks & Unintended Consequences
+
+**Risk 1**: [What could go wrong?]
+- **Likelihood**: [High / Medium / Low]
+- **Impact if occurs**: [Severity]
+- **Mitigation**: [How to prevent or reduce risk]
+
+**Risk 2**: [Unintended consequence from intervention]
+- **Mechanism**: [Which loop or delay causes this?]
+- **Mitigation**: [How to monitor and adjust]
+
+**Risk 3**: [System resistance or pushback]
+- **Source**: [Who or what will resist?]
+- **Mitigation**: [How to address resistance]
+
+### Success Metrics
+
+**Leading indicators** (early signals intervention is working):
+1. [Metric to track weekly/monthly]
+2. [Metric to track]
+3. [Metric to track]
+
+**Lagging indicators** (longer-term outcomes):
+1. [Metric to track quarterly/annually]
+2. [Metric to track]
+3. [Metric to track]
+
+**How to interpret**: [What trends indicate success vs. failure? What adjustments might be needed?]
+
+### Monitoring & Adaptation Plan
+
+**Check-in frequency**: [Weekly / Bi-weekly / Monthly]
+
+**What to monitor:**
+- [Key stock levels]
+- [Flow rates]
+- [Loop activation signs (is reinforcing loop building momentum?)]
+- [Delay timers (have we waited long enough for effect to show?)]
+- [Resistance signals (pushback, workarounds)]
+
+**Adaptation triggers**: [Under what conditions do we adjust strategy?]
+
+**Responsible party**: [Who monitors and makes adjustment calls?]
+
+---
+
+## Quality Checklist
+
+Before finalizing, verify:
+
+### System Definition
+- [ ] System boundary clearly stated (what's in/out)?
+- [ ] Boundary rationale pragmatic (useful scope for intervention)?
+- [ ] Stocks identified (things that accumulate - nouns)?
+- [ ] Flows identified (rates of change - verbs)?
+- [ ] Stocks and flows connected (flows change which stocks)?
+- [ ] System goals stated (implicit or explicit)?
+- [ ] Time horizon appropriate for problem and intervention?
+
+### Causal Loop Diagram
+- [ ] At least one reinforcing loop (R) identified?
+- [ ] At least one balancing loop (B) identified?
+- [ ] Polarity marked (+ same direction, - opposite direction)?
+- [ ] Loop effects described (growth/collapse for R, goal-seeking for B)?
+- [ ] Delays explicitly noted where they exist?
+- [ ] Diagram shows interconnections (not just isolated pairs)?
+
+### Stock-Flow Analysis
+- [ ] For each major stock: inflows and outflows listed?
+- [ ] Current state assessed (accumulating/depleting/stable)?
+- [ ] Delays from flows to stock changes estimated?
+- [ ] Implications of accumulation/depletion stated?
+- [ ] Time lags quantified (not just "delayed" but "3 months")?
+
+### Leverage Point Analysis
+- [ ] Multiple intervention points considered (not just first idea)?
+- [ ] Each intervention classified by leverage level (1-12)?
+- [ ] High-leverage interventions (1-7) prioritized over low-leverage (8-12)?
+- [ ] Feasibility vs. leverage trade-offs acknowledged?
+- [ ] Parameter-tweaking (level 12) avoided as primary strategy?
+
+### Intervention Strategy
+- [ ] Primary intervention is high-leverage (levels 1-7)?
+- [ ] Supporting interventions complement primary (not duplicate)?
+- [ ] Predicted outcomes based on loop dynamics (not just wishful thinking)?
+- [ ] Short, medium, long-term effects distinguished?
+- [ ] Delays accounted for in outcome timeline?
+- [ ] Unintended consequences anticipated (second-order effects)?
+- [ ] System resistance identified (who/what will push back)?
+- [ ] Success metrics include leading and lagging indicators?
+- [ ] Monitoring plan specified (frequency, what to track, adaptation triggers)?
+
+### System Archetype Recognition (if applicable)
+- [ ] Does system match a known archetype (fixes that fail, shifting burden, tragedy of commons, limits to growth)?
+- [ ] If yes, typical failure mode acknowledged?
+- [ ] Archetype-specific high-leverage intervention identified?
+
+### Overall Quality
+- [ ] Problem statement clear (symptom → pattern → hypothesis)?
+- [ ] Analysis grounded in feedback loop logic (not just list of causes)?
+- [ ] Interventions address structure, not just symptoms?
+- [ ] Assumptions stated explicitly (what must be true for this to work)?
+- [ ] Confidence appropriate (not overconfident given complexity)?
+- [ ] Actionable recommendations (clear what to do, when, how to measure)?
+
+**Minimum Standard**: If any checklist item is unchecked and relevant to your system, address it before finalizing. Use rubric (evaluators/rubric_systems_thinking_leverage.json) for detailed scoring. Average score ≥ 3.5/5.
+
+---
+
+## Common Mistakes to Avoid
+
+**❌ Treating symptoms not root causes** - "Add more people" (parameter) vs. "Eliminate low-value work" (goal/rules). Fix: Ask "what feedback loop creates this symptom?"
+
+**❌ Ignoring delays** - "Tried for 2 weeks, didn't work" (but skill development takes 3-6 months). Fix: Estimate delays, wait appropriately.
+
+**❌ Single-loop thinking** - Only seeing growth (R loop), missing limit (B loop). Fix: Look for both R and B loops. Every R hits a limit.
+
+**❌ Confusing stocks and flows** - "Morale is flowing" (morale = stock, recognition = flow). Fix: Stocks are nouns (accumulations), flows are verbs (rates).
+
+**❌ Low-leverage interventions** - Tweaking parameters when structure/goals/paradigms need changing. Fix: Use hierarchy (1-12), prioritize 1-7 over 8-12.
+
+**❌ Unintended consequences** - "Speed up releases" → Technical debt → Slower releases. Fix: Trace second-order effects through all loops.