Systems Thinking — Skills

Reusable Claude Code skills for systems thinking, drawn from the AI + Systems Thinking course (Empatika, Season 2026) by Bayram Annakov. Installable as a Claude Code plugin marketplace, also runnable as copy-paste mega-prompts in Codex / ChatGPT / Cursor.

The course is hands-on: participants draw stock-flow diagrams by hand, run live multiplayer simulations, and use these AI skills as a critic, builder, and amplifier — never as a designer. The skills enforce that pedagogy: they refuse to draw the diagram for you.

Available skills

`/ai-systems-coach` — Stock-flow diagram critic & archetype identifier (ships with W2)

You draw the diagram. The skill grades it.

Critiques a hand-drawn stock-flow / causal-loop diagram, identifies the system archetype (Limits to Growth, Shifting the Burden, Fixes that Fail), and surfaces Meadows leverage points. Outputs a Mermaid diagram, validates stocks, flags missing delays, prepares a clean stock-flow specification for Workshop 3 simulation.

Refuses to design a diagram from scratch, invent variables you didn't name, or force-fit an archetype.

Example:

/ai-systems-coach

Stock: Active Customers
Inflow: New signups (driven by referrals from Active Customers)
Outflow: Churn (driven by Service Quality, which drops past Capacity)
R: Active Customers → Referrals → New signups → Active Customers
B: Active Customers → Service Quality (delay 2 weeks) → Churn → Active Customers

`/leverage-finder` — Map your model to Meadows' 12 leverage points (ships with W4)

You bring a model and a goal. The skill returns 3 candidate interventions, ranked.

Takes a stock-flow model you have already built and a measurable goal you have already stated, then maps elements of your model to Donella Meadows' 12 leverage points and returns the 3 highest-leverage candidate interventions for your goal.

The skill enforces the asymmetry lesson structurally: at least one of the 3 candidates must be at knob ≤5 (rules, info flow, goals, paradigm). Most teams reach for parameters (knob 12) first because they have numbers to tune; the skill forces you to consider stronger leverage you can't see as easily.

Three structural rules:

Phase 0 gate — no measurable goal, no output. The skill refuses to rank leverage without a stated purpose. "Improve the system" gets pushed back with three sharpening questions.
No inventing structure — only maps stocks, flows, and parameters the model already contains. Won't add elements the user didn't draw.
Forced choice — returns exactly 3 candidates, not a long list. Forcing the choice is part of the discipline.

Each candidate is formatted as: Meadows knob (number + name), what to change in the user's model, why it has leverage for the stated goal, one concrete experiment testable in 2 weeks, one caveat. Closes with an asymmetry paragraph noting which candidate is strongest and which feels most natural — those usually don't match.

Refuses: to invent stocks/flows/parameters not in the model, to write code, to march through all 12 leverage points as a checklist, to return more than 3 candidates.

`/ai-stockflow-builder` — Commission a runnable simulation app (ships with W3)

The skill emits a brief. Your AI agent (Claude Code or Codex) builds the app. You own the equations.

Walks you from a stock-flow diagram (or /ai-systems-coach output) to an interactive single-HTML-file simulation web app with sliders, chart, and equation chips — via three phases:

Readback — skill reads your model back in plain English, surfaces ambiguity, forces ≥1 disagreement before any code
Brief — skill emits a copy-paste commissioning brief; you paste it into Claude Code or Codex; your agent builds model.html with React via CDN, Recharts, Euler integration with dt=1
Extraction test — you hand-compute t=1 from defaults and compare to the agent's app at t=1; mismatch = AI broke equations = stop and find where

If you don't have a diagram, Phase 0 — Interview mode asks Socratic questions and your answers become the model. The skill never proposes a stock or flow you didn't name.

Two-pass discipline:

Pass	Caps
Pass 1 (Simplified)	exactly 1 stock, 2 flows, 2 parameters, ≤30 time steps, linear equations only — no `min()`, ternaries, or delays
Pass 2 (Full)	no caps; extends Pass 1

When your model violates a Pass 1 cap, the skill runs a trim conversation — it proposes which entities to drop, demote to constants, or defer to Pass 2. Pass 1 forces "minimum viable model" discipline; Pass 2 layers complexity. Most workshops use Pass 1 first, then Pass 2 as a follow-up.

Refuses: to write the app itself (your agent does), invent missing parameters, deploy, stylize, or run the simulation.