What it is. The redesign that swallows every idea you cut from the first version. v1 shipped lean because you couldn’t fit more; v2 is where the backlog goes to be vindicated — and it drowns.

Why it hurts. The constraint that made v1 legible is gone, but the taste that constraint forced on you doesn’t automatically scale. You mistake “more surface” for “more depth” and ship something bigger in every dimension and smaller in focus.

The smell

The follow-up grows on every axis at once — more verbs, more resources, more menus, more systems talking to systems — and the core loop it was supposed to deepen gets harder to describe, not easier. Coined for software architecture; games have their own graveyard.

How it happens

• The cut list becomes the spec. Every “we’ll do it next time” from v1 is now a promised feature. Nobody re-asks whether it deserved cutting.
• Success is read as permission. v1 worked, so anything adjacent must also work. The thing that actually worked — one tight loop — gets no credit.
• Ambition replaces the pillars. process-pillars said “no” for you the first time. In the sequel there are no pillars, just a wishlist, so nothing says no.
• Prestige inflates the brief. Now you have a team/budget/engine, so the design expands to fill them. Capacity, not player need, sets scope.
• Systems get coupled for completeness. Every subsystem must touch every other or it “feels shallow” — which is how you get antipattern-currency-spaghetti and antipattern-feature-soup as byproducts.

The tell (check YOUR design)

If the honest answer to “what does this version say no to?” is nothing, you are building the second system.

The fix

• Restraint is the design, not the shortfall. Treat negative space as a feature you author on purpose. See pattern-restraint-and-negative-space.
• Re-derive from the mechanic, not the backlog. Run process-intent-to-brief and process-the-twist as if v1 didn’t exist; keep only what the new twist demands.
• Reinstate pillars with teeth. process-pillars must be able to kill a beloved feature. If it can’t, it’s decoration.
• Deepen one axis, hold the rest. Pick the single dimension the sequel earns — more depth per verb, or more verbs, or more content — not all three. process-composition shows what stays fixed.
• Cut features that don’t compound. If a system doesn’t feed the core loop, it’s antipattern-false-depth; delete it. Volume without interaction is antipattern-content-desert wearing a bigger coat.
• Guard against the coupling reflex. Systems earn a connection by making the loop better, not by existing. Otherwise you inherit antipattern-power-creep and antipattern-stat-inflation for free.

Twist seams (design with the effect, not against it)

• A sequel, but it subtracts (twist: the design headline is what you removed) — the follow-up ships fewer systems, deeper. anchor-into-the-breach is a smaller board than a 4X and stronger for it; anchor-tetris never got “more shapes.”
• The big version, but one loop only (twist: scale content, freeze the verb set) — anchor-slay-the-spire and anchor-balatro add cards, not new modes; the process-core-loop loop is identical at hour 1 and hour 100. Contrast system-build-diversity that grows within a fixed loop vs. bolting on parallel loops.
• More ambition, but the same run length (twist: hold the session envelope constant) — everything new must fit the minutes a player already spends. anchor-vampire-survivors added weapons, not a second campaign. See system-session-structure.

Seen in…

• Franchise bloat. Sequels that answer “what worked?” with “more of everything” — sprawling skill webs, doubled currencies, a system for every review-bullet. The player’s minute-to-minute got busier, not better. This is the sequel that added a crafting tree, a base-building layer, and a card mini-game onto a game that was fun because it did one thing.
• The reverse — sequels that resisted it. anchor-hades to its follow-up: same run-based process-core-loop, refined not reinvented. anchor-civilization entries win or lose on whether the new system replaces an old one rather than stacking on it. anchor-portal earned its sequel with a focused set of new elements built on the same portal verb, not a sprawl of unrelated systems.
• Workshop-scale versions. Ambitious follow-ups whose marketing lists forty systems and whose core loop nobody can summarize — the tell every time.

Verify / guard

This is a fun problem before it’s a content problem — an unnamed core loop fails the first gate in [[design/FUN.md]]. Before handoff via process-refine-and-handoff, run the tell table above and confirm the sequel can state, in one sentence, what it is and what it dropped. If it can only add, it isn’t a deeper system — it’s a longer list.