The General Threshold: Any Loop That Feeds Itself

Last lesson we stood on the reactor floor and watched a lump of uranium decide, at a single kilogram, whether to sit there or level a city. The whole argument turned on one number: k, the average number of fresh neutrons from one split atom that go on to split another. Below 1 the reaction shrinks each generation and dies; above 1 it doubles and doubles and consumes everything.

Now here’s the trick that turns a physics footnote into a thinking tool. Read back through that argument and cross out every word that mentions atoms. Neutron, fission, uranium — gone. What’s left is a naked shape: an event that, on average, triggers some number of copies of itself, and a threshold where that number crosses 1. Nothing in the logic needed the atoms. Replace “neutron” with “any event that triggers more of itself” and the entire machine survives intact. This lesson is where critical mass stops being about bombs and becomes about everything that grows on itself — which, as you’re about to see, is a very long list.

Lift-off: nothing here was ever about atoms

You already own the engine of this lesson — you met it in the prerequisite course as a reinforcing loop. Recall the one-line definition: a reinforcing loop is any feedback loop where each trip around makes the next trip bigger. More begets more. Output feeds back as a larger input, so the effect doesn’t happen once and stop — it grows on itself. The snowball, the microphone screech, compound interest: all the same wiring.

Critical mass is not a different idea from that. It is the sharpest possible question you can ask about a reinforcing loop: is the per-step gain above 1 or below it? A reinforcing loop says “more leads to more.” Critical mass says “yes, but how much more — more than one-for-one, or less?” That single distinction decides whether “more begets more” is a runaway or a fizzle.

• If each unit of activity produces, on average, more than one unit of the same activity, the loop compounds upward without limit — a runaway.
• If each unit produces, on average, less than one, the loop still runs “more → more” for a moment, but each wave is smaller than the last, and it decays to a stop.

So the uranium and the savings account and the rumour are not three analogies that happen to rhyme. They are one loop, asked one question. The reinforcing loop is the machine; critical mass is the dial on the front of it, and the dial has a hard notch at 1.

Meet k, the general amplification factor

Physicists call it k. Epidemiologists call it R (or R0). Growth teams call it the viral coefficient. It’s all the same quantity, and it deserves one clean, domain-free definition:

From that single definition falls a law with no exceptions, valid in every domain the loop appears in:

• k > 1 → the process explodes. Each generation is bigger than the last. Compounding takes over and it runs away exponentially until it hits some outside limit.
• k < 1 → the process dies. Each generation is smaller than the last. It decays geometrically to a stop, no matter how loudly it started.
• k = 1 → the razor’s edge. Each generation exactly replaces the last. The process is self-sustaining: neither growing nor shrinking, holding steady forever in principle. This is the knife-edge — and because it’s a single point, real systems almost never sit on it for long; they drift to one side and commit.

The reason a hair’s-breadth change around k = 1 flips the entire outcome is that you’re not adding, you’re multiplying, over and over. Starting from a seed and iterating: after $n$ generations the wave size is (seed) $\times\, k^n$. Raise $0.9$ to the hundredth power and you get a number so close to zero it’s a rounding error; raise $1.1$ to the hundredth power and you get roughly 14,000. Same “small” difference in k, opposite ends of the universe after enough rounds. That’s why $k>1$ and $k<1$ aren’t “a bit more” and “a bit less” — they’re two entirely different fates.

Worked example 1: the referral loop

Let’s put real numbers on it. Imagine an app that grows only by word of mouth. Each new user, on average, invites some number of friends — call it $b$ (for “brought”) — and a fraction $s$ of those invitees actually sign up and go on to invite others themselves. Only the ones who invite others keep the loop alive, so the effective amplification factor is:

$k = b \times s$

Reach times conversion. That’s the whole model. Watch what a small change in $s$ does.

Case A — sub-critical. Each user invites $b = 3$ friends, and a fraction $s = 0.25$ convert into new inviters. So $k = 3 \times 0.25 = 0.75$. Start with a seed of 100 users:

Each wave is three-quarters the size of the one before. The app is growing — it keeps adding new users every generation — but the growth is visibly running out of steam, and it’s heading to zero. In the boardroom this reads as “we had a great launch and then it just… faded.” It faded because $k < 1$.

Case B — super-critical. Same app, but a slicker onboarding lifts the convert-and-reinvite fraction to $s = 0.4$. Now $k = 3 \times 0.4 = 1.2$. Same seed of 100:

Now each wave is bigger than the last, and the gap widens every round. Nothing about the app changed except a conversion rate creeping from 0.25 to 0.4 — one design tweak — and it flipped the company from a slow death to unbounded growth. The difference between the two tables is the difference between $k = 0.75$ and $k = 1.2$: not “20% better,” but “alive instead of dead.”

Worked example 2: the rumour, same shape, different costume

Swap out every noun and the machine is untouched. A rumour spreads because each person who hears it tells some number of others — call it $n$ — and a fraction $f$ of those bother to retell it. The ones who retell are the next generation of tellers, so:

$k = n \times f$

Reach times retell-rate — the identical structure as $b \times s$, just renamed. That’s not a coincidence; it’s the point. Recall the pretest: rumour A had $n = 4$, $f = 0.2$, giving $k = 4 \times 0.2 = 0.8$ (dead by lunch), while rumour B had $n = 3$, $f = 0.5$, giving $k = 3 \times 0.5 = 1.5$ (all over the building). Notice that the louder rumour — the one told to more people each time — is the one that died, because whispering to four people who shrug is worse than telling three who each grab a colleague. Reach without retelling is a firework: bright, brief, over. It’s the product that decides, never one factor alone.

This is the whole reason critical mass earns a spot in the latticework instead of a physics textbook: once you can spot the ”$k =$ reach $\times$ passthrough” shape, you read epidemics, memes, referral loops, and gossip with a single question. What’s the reach, what fraction carries it forward, and does their product clear 1?

The geometric-series insight: fizzles have a finite reach

Here’s a subtlety that turns “it died” from a shrug into a number you can compute. When $k < 1$, the process doesn’t just trail off vaguely — it adds up to a specific, finite total and then genuinely stops. You can predict exactly how far a doomed loop will get before it gives up.

Take the sub-critical case: a seed of size $S$, each wave $k$ times the last with $k < 1$. The total number of events ever, summed across all generations, is $S + Sk + Sk^2 + Sk^3 + \dots$, and that sum converges to a tidy closed form:

$\text{total} \approx \frac{S}{1 - k}$

Put a number on it. Seed $S = 10$, amplification $k = 0.8$. The total reach is $\dfrac{10}{1 - 0.8} = \dfrac{10}{0.2} = 50$ events, ever — then it’s done. Ten seeds, decaying at 0.8 a wave, touch about fifty things in total and stop. A stronger-but-still-doomed loop at $k = 0.9$ from the same seed reaches $\dfrac{10}{0.1} = 100$ — twice as far, still finite, still dead in the end.

This is why sub-critical things feel like they “almost worked.” They don’t collapse instantly; they spread meaningfully, rack up a real (finite) reach, and then flatten out — exactly the profile of a campaign that “had legs for a while” or a product that “found some traction” before stalling. It got its $S/(1-k)$ and no more. And notice the cliff hidden in that formula: as $k$ creeps toward 1, the denominator $1-k$ shrinks toward zero, so the finite total blows up toward infinity. At $k = 0.99$ a seed of 10 reaches a thousand before dying. The closer you crawl to the threshold from below, the more enormous — but still ultimately finite — the fizzle. Cross the line, and “enormous but finite” becomes “unbounded.” That’s critical mass, written as a fraction.

An emergent runaway: no coordinator required

The other prerequisite course, on emergence, hands you the last piece for free. A runaway is a textbook emergent phenomenon: a global, macro-level pattern — “the whole thing exploded” — produced entirely by a local, micro-level rule with nobody in charge.

The local rule is embarrassingly small: each unit, on average, causes a bit more than one more unit like itself. No atom knows it’s in a bomb. No app user is trying to make the company go viral. No gossip is orchestrating the office. Each part follows its tiny local rule — split a neighbour, invite a friend, retell the story — using only what’s right next to it, with no view of the whole and no intention to produce the runaway. The exponential explosion is a side effect that piles up out of the interactions, a pattern that lives at the level of the group and in no single part.

So critical mass sits precisely at the intersection of your two prerequisites: it’s a reinforcing loop (more → more) whose emergent macro-behaviour — fizzle or runaway — is decided by whether the local per-unit rule averages above or below 1. Grown from below, tipped by a single number, coordinated by no one.

The pitfall: amount is not k

Here is the mistake this lesson exists to inoculate you against, and it’s a subtle one because it hides inside a reasonable-sounding instinct: do not confuse the amount of activity — the seed size — with k. They are different axes, and it’s k that decides the fate.

• A giant seed with $k < 1$ still dies. Launch to a million users at $k = 0.8$ and you reach a finite $\dfrac{1{,}000{,}000}{0.2} = 5$ million and then stop, cold. A huge splash is still a splash; it can’t out-shout a sub-critical loop. The size only changed how big the finite cap was, not whether there was one.
• A tiny seed with $k > 1$ still explodes. One infected traveller with $k = 2$ seeds a pandemic; a handful of early users with $k > 1$ eventually take the market. A small start is slow, not doomed.

Where seed size genuinely does matter is at the edges of what k decides:

1. It sets whether and when the loop gets going. A bigger seed reaches any given size sooner (it’s multiplying from a higher base), and — crucially, as you saw with the reactor — near the threshold a bigger seed makes it physically harder for the process to leak away before it catches, which is the actual reason a bomb needs a critical mass and not just critical fuel.
2. Near the edge, luck bites small seeds. When $k$ is only just above 1, the per-generation average hides real randomness. A seed of one or two events can die out by sheer bad luck — the first few “children” happen to be zero — even though the expected value says grow. This is why $k > 1$ guarantees explosion only in expectation, and why a small super-critical spark sometimes sputters out.

But keep the claim precise and don’t overreach: once $k$ is fixed comfortably above 1 and the seed is past that early luck-of-the-draw zone, the fate is sealed — it will run away, seed size only tuning the timing. The headline stays clean: seed size affects whether and when; k decides which of the two universes you end up in.

Feel the threshold flip again — now as a general k

You met this grid last lesson as a reactor. Look at it again with the new eyes this lesson gives you: forget atoms entirely. Each hot cell is any event that triggers copies of itself — a user inviting friends, a person retelling a rumour, a clapper prompting neighbours to stand. The slider is the general k: the average number of next-generation events each event sets off. Everything you’ve learned collapses into one motion of your hand.

Run it well below 1.00 and watch the fizzle spread a bit, add up its finite reach, and quit — that’s $S/(1-k)$ happening in front of you. Nudge k just past 1.00 and the same seed now sweeps the grid without stopping. Then do the pitfall experiment: crank the seed way up but leave k below 1 — it reaches further, then still dies. Shrink the seed to almost nothing but push k above 1 — it starts slow, sometimes sputters (there’s the small-seed luck), but when it catches, it takes everything. Amount changes the size of the story; k decides its ending.

Recap quiz

Where this goes next

You’ve done the pivotal move of the whole course: you lifted critical mass off the reactor floor and turned it into a question you can ask about any self-feeding loop — what’s its k, and which side of 1 is it on? You can now compute that k from reach and passthrough, predict exactly how far a doomed loop will crawl before it quits ($S/(1-k)$), and tell the seed size apart from the fate.

Next up is Lesson 3: Tipping Points Everywhere — the grand tour, where this one shape struts out in costume after costume: epidemics and their R0, viral content, the adoption S-curve and network effects, standing ovations and bank runs and bandwagons, autocatalytic chemistry, and the awkward silence in a meeting nobody will break. One threshold, a dozen disguises. Once you’ve seen it wearing all of them, you’ll never un-see it. See you there.