Update Core Design Pillars

Core-Design-Pillars.md

@@ -1,15 +1,31 @@
-**Commitment as a design axis.** When actions have recovery frames and no universal escape, the game punishes reaction in favor of anticipation. This principle extends beyond combat. Build choices, dialogue paths, and resource allocation should carry the same weight: decisions are not reversible on demand, and the cost of a wrong read is real. Across all systems, the skill being tested is the same. Read the situation, commit, and live with the outcome.
+**Commitment as a design axis.**
 
-**Anticipation rewarded defensively and offensively.** Correctly reading an opponent's action carries a double payoff: avoiding damage and opening an offensive window. The skill loop becomes self-reinforcing. Better reads produce better output, which incentivizes further investment in reading. Commitment and defensive timing are not separate systems but two expressions of the same underlying principle: anticipation is the primary skill the game tests.
+Every decision asks the player to live with it. In combat, recovery frames and no universal escape punish reaction and reward anticipation. In quest preparation, loadout and resource decisions made before entering a situation determine what is available under pressure. The skill is the same in both contexts: read ahead, commit, and absorb the outcome.
 
-**Distinct systems over varied implementations.** A roster built around different verbs rather than different numbers ensures each option teaches the player something non-transferable. Breadth becomes genuine rather than cosmetic.
+**Anticipation rewarded defensively and offensively.**
 
-**Multiplicative playstyle design.** Layering a modifier system on top of a base system generates combinatorial depth without proportional development cost. The legibility cost is real and requires mitigation at the UI and onboarding level, not in the systems themselves.
+Correctly reading an opponent's action carries a double payoff: avoiding damage and opening an offensive window. The skill loop becomes self-reinforcing. Better reads produce better output, which incentivizes further investment in reading. Commitment and defensive timing are not separate systems but two expressions of the same underlying principle: anticipation is the primary skill the game tests.
 
-**Adversarial AI as a readable system.** Enemies with behavioral states that respond to player actions are a second language the player must learn. Damage changes behavior; behavior reveals new patterns; knowledge becomes a form of progression. The design obligation this creates: behavioral states must be legible before they are understood. Unreadable states punish rather than teach.
+**Distinct systems over varied implementations.** 
 
-**Tutorialization debt.** When a game's depth exceeds what it teaches, mastery becomes self-directed by default. This is acceptable under three conditions: variables must be isolatable, failure must be consequence-free, and the full system must be reachable through play alone. Players who engage with that space progress; players who don't, plateau. The filter is on willingness to experiment, not willingness to seek external resources.
+A roster built around different verbs rather than different numbers ensures each option teaches the player something non-transferable. Breadth becomes genuine rather than cosmetic.
 
-**Core loop integrity.** The intended skill loop must be what the game actually tests. Cooldown abilities that let players bypass core mechanics in low-stakes content obscure what mastery means and delay its development. Progression systems must reinforce the loop, not route around it.
+**Multiplicative playstyle design.**
 
-**Generative pacing.** Intervals between action spikes must be engaging in their own right, not merely tolerated. Resource gathering, crafting, and side content are not filler between peaks. If they feel like dead time, they are dead time, regardless of intent. The design obligation is that downtime be productive, legible, and intrinsically motivated. It must also be optional: players with sufficient resources should be able to skip it entirely and stay on the action. Forced downtime is a tax; voluntary downtime is a feature.
+Layering a modifier system on top of a base system generates combinatorial depth without proportional development cost. The legibility cost is real and requires mitigation at the UI and onboarding level, not in the systems themselves.
+
+**Adversarial AI as a readable system.**
+
+Enemies with behavioral states that respond to player actions are a second language the player must learn. Damage changes behavior; behavior reveals new patterns; knowledge becomes a form of progression. The design obligation this creates: behavioral states must be legible before they are understood. Unreadable states punish rather than teach.
+
+**Tutorialization debt.**
+
+When a game's depth exceeds what it teaches, mastery becomes self-directed by default. This is acceptable under three conditions: variables must be isolatable, failure must be consequence-free, and the full system must be reachable through play alone. Players who engage with that space progress; players who don't, plateau. The filter is on willingness to experiment, not willingness to seek external resources.
+
+**Core loop integrity.**
+
+The intended skill loop must be what the game actually tests. Cooldown abilities that let players bypass core mechanics in low-stakes content obscure what mastery means and delay its development. Progression systems must reinforce the loop, not route around it.
+
+**Generative pacing.** 
+
+Intervals between action spikes must be engaging in their own right, not merely tolerated. Resource gathering, crafting, and side content are not filler between peaks. If they feel like dead time, they are dead time, regardless of intent. The design obligation is that downtime be productive, legible, and intrinsically motivated. It must also be optional: players with sufficient resources should be able to skip it entirely and stay on the action. Forced downtime is a tax; voluntary downtime is a feature.