The Problem Nobody Could Explain
When COVID hit, I watched smart people — economists, executives, policy experts — struggle to explain what was happening. Each explanation was locally correct but globally useless. "There's too much demand." "There's not enough supply." "Companies are hoarding." "Shipping is broken."
All true. None sufficient.
What was actually happening was a cascade of feedback loops — reinforcing cycles where each disruption amplified others. Low inventory triggered panic buying, which emptied shelves faster, which triggered more panic buying. Delays at one port rippled through a dozen interconnected shipping networks. Companies that optimized for lean supply chains had no buffer when the system swung.
This isn't a new phenomenon. Economists have a name for it: the bullwhip effect. A small change in consumer demand creates progressively larger swings as you move upstream through a supply chain. It was documented in the 1950s. We've known about it for 70 years. And we still couldn't see it coming.
Most systems failures aren't caused by one big mistake. They're caused by perfectly rational local decisions that create catastrophic emergent behavior at the system level.
The thermostat in your house illustrates it on a small scale. Set it to 70°F, and if you have a slow-responding system, it'll overshoot to 74° before the heat cuts off, then dip to 66° before the furnace kicks in again. Simple feedback loop, constant oscillation. Now multiply that by ten thousand interdependent variables and you have a global economy.
The Tool Problem
Here's what frustrated me: the tools to understand and simulate these systems exist. System dynamics is a field built around exactly this kind of thinking. Jay Forrester developed it at MIT in the 1950s. Peter Senge popularized it with The Fifth Discipline. There are rigorous software tools — Vensim, Stella Architect, AnyLogic — that let you model complex feedback systems.
They cost $1,200 a year. They have learning curves measured in weeks. And they were designed for researchers and engineers, not curious generalists.
On the other end of the spectrum, you have free tools that are basically drawing apps. You can sketch a feedback loop diagram, but you can't run it, feel it, or break it.
The gap between "expensive professional simulator" and "free sketch pad" is enormous. And it's where most people give up trying to learn this.
Nothing makes systems thinking genuinely fun to learn. Nothing lets you make decisions, watch consequences ripple out, and develop the intuition that comes from being wrong a dozen times in a safe environment.
Enter Emergent
That's the reason I built Emergent: an interactive game-based platform where you manipulate real-world systems and watch them evolve.
The approach is different from a traditional simulator in three ways:
- Scenarios over blank canvases. Instead of starting from scratch, you get pre-built systems based on real-world complexity — supply chains, ecosystems, cities. The scaffolding is already there. Your job is to experiment, not construct.
- Consequences over equations. You don't need to understand differential equations to feel the delay between pulling a lever and seeing the effect three steps downstream. The simulation shows you.
- Play over study. The entire thing is designed to be intrinsically motivating. You're not reading about feedback loops. You're breaking them.
What Happens in the Ecosystem Scenario
Let me walk you through one scenario: Balance the Ecosystem.
You start with a fragile predator-prey system. Rabbits eat grass. Foxes eat rabbits. The system has a precarious natural equilibrium — not stable exactly, but self-correcting. When the rabbit population gets too high, the foxes multiply. When it crashes, the foxes starve and the rabbits recover.
It looks manageable. It isn't.
Your first instinct will be to help. The rabbit population is declining — add more rabbits. The grass is sparse — reduce grazing. Each intervention feels rational. Each one nudges the system.
What you discover is that the system has a tipping point. Below a certain fox population, rabbits explode. Above a certain rabbit density, they overgraze and collapse the food supply. The tipping point isn't labeled. You find it by crossing it.
The moment you accidentally drive a species to zero in the simulation is the moment systems thinking clicks. Not because you read about irreversibility — because you caused it. You can't unlearn that feeling.
Most first-time players crash the ecosystem within three minutes. Then they restart and try to figure out why. That's the learning loop we wanted to create: fail fast, understand why, try differently.
The Technical Angle: Vanilla JS + SVG
For developers reading this: the entire simulation engine is written in vanilla JavaScript. No frameworks, no libraries, no build pipeline. Nodes are SVG elements. The simulation runs in pure JavaScript using simple differential equations on a discrete time step.
This was a deliberate choice. The alternative was a heavyweight graph library or a React + D3 stack that would have added complexity without adding capability. The actual simulation logic — the feedback loop dynamics — is about 150 lines of JavaScript. The rendering is another 200 lines of SVG manipulation.
The result is a playground that loads in under 200ms, runs entirely client-side with no external dependencies, and works on any device with a browser. That matters for reach. Systems thinking tools shouldn't require a computer science degree to install.
The core loop: each simulation step computes deltas for every node based on incoming weighted edges (positive or negative polarity), clamps values to valid ranges, and records a snapshot for rendering. DFS cycle detection classifies loops as reinforcing or balancing. That's it.
Why This Matters Now
We are living through an era of systems crises. Climate change is a delayed-feedback problem — CO₂ today, consequences in decades. Antibiotic resistance is a tragedy of the commons. Social media polarization is a runaway reinforcing loop. Housing unaffordability is a stock-and-flow problem that simple supply/demand thinking systematically misdiagnoses.
The people making decisions about these problems — in government, in business, in civil society — mostly think in straight lines. Cause and effect. Input and output. Do this, get that.
Systems thinking doesn't require a PhD. It requires pattern recognition that you build through exposure. You can read about delays and nonlinearity, or you can crash an ecosystem fifty times and internalize the intuition. One of those approaches actually works.
That's what Emergent is trying to do. Not teach the textbook. Build the intuition.
Get Early Access to More Scenarios
We're building structured scenario progressions, guided curriculum tracks, and collaborative scenarios. Join the waitlist and be first to know.
Want more examples? The bullwhip effect shows feedback loops destroying supply chains, and our systems thinking intro explains the framework from scratch. Or join the early access list for structured scenario progressions that build systems intuition step by step.