Reinforcing Feedback Loops

What Is a Reinforcing Loop?

A reinforcing feedback loop occurs when the output of a process feeds back into its own input, amplifying the original change. If something is growing, a reinforcing loop makes it grow faster. If something is declining, a reinforcing loop makes it decline faster.

The colloquial version: "The rich get richer." Or its less popular cousin: "The poor get poorer." Same loop structure, different direction.

The word "positive" is misleading. Positive feedback loops can be destructive. A bank run is a reinforcing loop: people withdraw money because they fear the bank will fail, which causes the bank to fail, which causes more people to withdraw money. The loop is "positive" in the mathematical sense. The effect moves in the same direction as the cause.

Reinforcing Loops in Nature

The simplest natural example is population growth. More rabbits produce more offspring. More offspring grow into more rabbits that produce even more offspring. Left unchecked (no predators, unlimited food), the population grows exponentially.

Of course, nature does not leave reinforcing loops unchecked. Balancing loops (the subject of Session 0.5) eventually intervene. But the reinforcing loop itself has no built-in limit. It will keep amplifying until something external constrains it.

Reinforcing Loops in Software Systems

Reinforcing loops appear everywhere in software, both as engines of success and engines of failure.

The diagram above shows the classic network effect loop. More users generate more content. More content attracts more users. Each cycle through the loop increases the total. This is why platforms like YouTube, Reddit, and Stack Overflow are so difficult to compete with. The reinforcing loop gives the incumbent an advantage that compounds over time.

Five Real-World Reinforcing Loops

Notice that "growth" is not always good, and "decline" is not always obvious at first. The technical debt loop often starts small. One shortcut here, one skipped test there. But because each shortcut increases the pressure that causes the next shortcut, the rate of quality decline accelerates.

Exponential Growth and Doubling Time

Reinforcing loops produce exponential change, not linear change. The practical implication is that things move slowly at first, then very fast.

A useful rule of thumb is the Rule of 72: divide 72 by the growth rate (as a percentage) to estimate the doubling time.

• 10% growth per cycle: doubles in ~7.2 cycles
• 20% growth per cycle: doubles in ~3.6 cycles
• 1% growth per cycle: doubles in ~72 cycles

This applies to anything driven by a reinforcing loop. If your technical debt increases development time by 5% each sprint, development time doubles in roughly 14 sprints. If your user base grows 15% month-over-month, it doubles in under 5 months.

Exponential change is hard for humans to intuit. We tend to project linearly. "If we added 1,000 users last month, we will add about 1,000 next month." But if a reinforcing loop is driving the growth, last month's 1,000 users help attract next month's 1,150, which help attract the month after's 1,322. The gap between intuition and reality widens every cycle.

The Danger: Reinforcing Loops Go Both Ways

Every reinforcing loop that can drive growth can also drive collapse. The same network effect loop that builds a platform can destroy it. If users start leaving, there is less content, which causes more users to leave, which means even less content.

Twitter/X after 2023 is a case study. Advertiser departures reduced revenue. Reduced revenue led to staff cuts. Staff cuts degraded product quality and content moderation. Degraded quality pushed away users and more advertisers. The same reinforcing loop that built the platform's value began working in reverse.

For system designers, this has a concrete implication: when you build a system that relies on a reinforcing loop for growth, you need to understand what happens if the loop reverses. A cache warming loop is great for performance under growing load. But what happens during a cold start, or after a cache flush? The inverse loop takes over: cache misses cause slow responses, which may cause timeouts and retries, which increase load, which cause more cache misses.

Identifying Reinforcing Loops

To find reinforcing loops in a system, follow this process:

1. Pick a variable that is changing (user count, error rate, response time, deployment frequency).
2. Ask: what does a change in this variable cause?
3. Follow the chain of effects. Does it eventually loop back to increase or decrease the original variable?
4. If the effect reinforces the original direction of change, you have found a reinforcing loop.

In a causal loop diagram (covered in Session 0.8), reinforcing loops are marked with an "R" in the center. Every arrow in the loop has the same polarity: more leads to more, or less leads to less. If you multiply all the signs and get a positive result, the loop is reinforcing. For a thorough treatment of causal loop diagram conventions, see Sterman's Business Dynamics (2000), Chapters 5-6.

The next session covers balancing loops, which act as brakes on reinforcing loops. Together, reinforcing and balancing loops account for nearly all dynamic behavior in systems.

Further Reading

• John Sterman, Business Dynamics: Systems Thinking and Modeling for a Complex World (McGraw-Hill, 2000). The definitive textbook on system dynamics modeling. Chapters 5-6 cover reinforcing and balancing loops in depth.
• Donella Meadows, Thinking in Systems (Chelsea Green, 2008). Chapters 1-2 introduce feedback loops with intuitive examples.
• Peter Senge, The Fifth Discipline (Doubleday, 1990). Senge's reinforcing loop archetypes ("Limits to Growth", "Success to the Successful") are directly applicable to software platform dynamics.
• The Systems Thinker, "Fine-Tuning Your Causal Loop Diagrams". Practical guide to drawing and reading CLDs correctly.