A Systemic Approach to Systemic Design - Mike Sellers

Main ideas / lessons

• Games are systems. A game consists of multiple interacting systems (combat, economy, movement, etc.), and players build mental models of how those systems work.
• Player understanding drives engagement.
  • If a player’s mental model mostly matches the system, they feel they “get it,” leading to engagement and fun.
  • If it doesn’t match, players feel violations of expectations, and the game becomes less fun.
• Systems-thinking helps designers be intentional. While auto/pilot “tacit” systems use is common, designers benefit from defining systems more explicitly to create more meaningful, engaging, longer-lasting games.
• Why “systems” is hard to use well: the term is vague, and related terms (e.g., dynamics, emergence, complexity) are often used loosely. Better definitions lead to better design.
• Systems are not just collections of parts—relationships matter. People often notice “things” but miss relationships. Similarly, a system’s “thingness” (e.g., a Conway’s Game of Life glider) emerges from lower-level rules.

Key systemic properties

• Parts: components with internal state (attributes) and behaviors (ways to interact).
• Organization / hierarchy: subsystems exist inside larger systems (“parts within parts”).
• Feedback loops: interactions between parts create nonlinear outcomes.
  • Reinforcing loops (e.g., Monopoly): success accelerates success (rich get richer).
  • Balancing loops: growth is limited and self-regulating (limits to growth).
  • Many patterns create unintended consequences, runaways, and resource depletion dynamics.
• Emergence: higher-level properties appear that aren’t obvious when looking only at individual lower-level parts.
• Distributed organized behavior: no single “leader” produces system-level order (examples: termite mounds, flocking, hurricanes, neural-like paths).

Meaning arises at a higher level

• In games, meaning is not just “sword does 6 damage.”
• Meaning comes from the game system + player, where interactions produce a lived experience.
• Even when designers don’t intend it, players will create their own meanings anyway (example: The Sims stories players generated that weren’t explicitly “written” into the game).

---

Methodology / framework presented: “Parts → Loops → Holes”

The proposal reframes common game design frameworks (e.g., Mechanics/Dynamics/Aesthetics and Function/Behavior/Structure) into a systemic approach using:

1. Parts
2. Loops
3. Holes (the player-facing experience where meaning emerges)

1) Parts (nouns/verbs; internal state + behaviors)

• Define game objects/components (“nouns and verbs”).
• Each part must have:
  • Internal state (attributes), analogous to programming object properties (e.g., HP, speed).
  • Behaviors enabling interactions with other parts.
• Parts must be designed so their interactions can generate emergent effects (not just isolated actions).
• Practical requirement: parts should be implementable (e.g., reducible to a spreadsheet or otherwise concretely specified).

Interaction design at this level

• Use feedback loops that arise from how parts interact.
• Include complementary roles (e.g., tank/DPS/CC archetypes).
• Consider balancing strategies like “rock-paper-scissors” style interactions:
  • Classic perfect imbalance: any pair is imbalanced, but the whole system is balanced.
  • Games may expand this concept (e.g., rock-paper-lizard-Spock variants) to achieve balance via emergence.
• Avoid atomistic designs:
  • Too much “everything deals damage” can remove meaningful interactions and kill systemic behavior.

2) Loops (how parts influence each other over time)

• Loops are the system-level interaction patterns created by part interactions.
• Nonlinear outcomes emphasized through:
  • Reinforcing vs balancing loops
  • Unintended consequence loops (solution creates delayed new problems)
  • Runaways / rich get richer
  • Tragedy of the commons (individual success consumes a shared resource)

“Complex” vs “complicated” distinction

• Complicated (serialized, cause → B → cause → C → …) is less interesting.
• Complex tends toward cyclic/nonlinear interdependence (A affects B affects C affects A), producing more interesting outcomes and emergence.

Design checks at the loop level

• Ensure adequate feedback so complex behavior can form.
• Verify the system doesn’t break if the player does “one wrong thing.”
• Ensure the player can make meaningful decisions (otherwise it isn’t a true game).

3) Holes (the player experience; meaning and learning)

• “Holes” represent what the player thinks, feels, learns, and ultimately how meaning forms.
• Meaning is emergent from the game system + the player (both are subsystems in the larger system).
• Players create meaning whether or not designers intend it, so designers should:
  • provide consistent systems that support the kind of experience/meaning they want,
  • while accepting players may reinterpret meaning.

Design checks at the hole level

• Is the experience cohesive, or “hodg-podgy”?
• Does the game have a “heart” (meaning), e.g.:
  • small meaning pulses (Tetris stacking)
  • larger narrative/cosmic meaning (Portal Companion Cube/Portal challenges)
• The argument: games can have varying depth of meaning, but they must maintain:
  • consistent systems
  • consistent mental models
  • consistent meaning within context

---

Practical checkpoints (student/designer “systemic design” questions)

Parts checklist

• Have you defined the parts?
• Do you know the hierarchy: parts within parts within parts?
• Have you specified each part’s:
  • internal state (attributes)
  • behaviors
  • attributes needed for interaction
• Are the parts implementable (not just “hand-wavy”)?
• Do parts have reasons/methods to interact to create significant effects?
  • Are interactions more than just damage?
• Are parts reasonably balanced/complementary?
  • Avoid cases where one part/weapon beats everything (extreme imbalance).
• Is there an intentional balance approach?
  • perfect imbalance (whole balance produced by internal imbalance), or another method?

Loops checklist

• Do you have adequate feedback among loops to produce complex behavior?
• Does your system create a space/path for player actions (not just scripted steps)?
• Is it resilient when players act differently or make mistakes?
• Do players have meaningful decisions driven by loop behavior?

Holes checklist

• Is the player’s experience cohesive?
• Does it match what the designer intended, supported by the underlying parts + loops?
• Ultimately: does the experience have meaning to the player (“heart”)?

---

Why systemic design is rare (constraints / risks)

• It’s riskier than one-off content:
  • one-off content is cheaper and more predictable initially, but brittle and non-reusable.
• Systems are hard to see while being built:
  • they don’t “look like much” until near completion, making iteration necessary.
• Requires tolerance for failure and time/organizational support.
• “Backside of a magic trick” effect:
  • once the designer understands the system, it stops feeling like magic to them,
  • but players may still experience it as emergent wonder.

---

Claimed benefits

• More cohesive, deep design
• More engaging gameplay and immersion
• More endless replayability via recombination of systemic parts
• Avoidance of expensive static content pipelines
• Longer engagement → potentially more business success
• Broader value: systemic thinking improves how people understand systems beyond games (21st-century importance)

---

Sources / speakers featured (at end)

• Mike Sellers (speaker; professor of practice in game design)
• Isaac Newton (gravity and system of the world; derived gravitational equation)
• Gottfried Wilhelm Leibniz / Isaac Newton context: (the subtitle credits Hal’s data; likely referring to Halley; unclear from subtitles)
• John H. Holland / Alexander (John) Nesbet / John N. Holland (emergence definition attributed to Holland; subtitle text is messy)
• Sten Conway → John Conway (Conway’s Game of Life)
• John Nesbitt (possibly mis-subtitled; only John Holland is clearly used for the emergence definition)
• Paul S. → Paul Stefan (cited as a designer with a systems-design metaphor: turn a spreadsheet into a game and back)
• Marti / Paul Stefan (as above; name unclear in subtitles)

Examples referenced (works/systems, not speakers)

• Conway’s Game of Life (glider)
• Monopoly (reinforcing loop example)
• Limits to Growth (balancing loop concept)
• Dwarf Fortress and EVE Online (opaque learning wall examples)
• Rampart (arcade game example)
• The Sims and The Sims 2 (player-generated stories example)
• Candy Crush (meaning within context)
• Portal and Tetris (meaning examples)
• Termite mounds, hurricanes, murmurations of starlings (distributed behavior examples)
• Las Vegas (runaway / rich-get-richer example)
• British “cobra heads” story (unintended consequences historical anecdote)