القائمة
Router for systems-as-experience - emergence, sandbox, optimization, discovery, narrative, modding
التثبيت باستخدام Codex أو Claude انسخ هذا Prompt والصقه في Codex أو Claude أو مساعد آخر ليراجع صفحة Skill ويثبّتها لك.
استنادا إلى تصنيف SOC المهني
| name | using-systems-as-experience |
| description | Router for systems-as-experience - emergence, sandbox, optimization, discovery, narrative, modding |
Your entry point to the systems-as-experience skillpack. Routes you to the right combination of specialized skills for your game design challenge.
This meta-skill:
Traditional game design: Systems support content
Systems-as-experience: Systems ARE the content
✅ Use systems-as-experience when:
❌ Don't use systems-as-experience when:
Hybrid approach: Most games blend both (BotW has authored Ganon encounter + emergent physics sandbox)
IMPORTANT: All reference sheets are located in the SAME DIRECTORY as this SKILL.md file.
When this skill is loaded from:
skills/using-systems-as-experience/SKILL.md
Reference sheets like emergent-gameplay-design.md are at:
skills/using-systems-as-experience/emergent-gameplay-design.md
NOT at:
skills/emergent-gameplay-design.md ← WRONG PATH
| Skill | When to Use | Examples | Time |
|---|---|---|---|
| emergent-gameplay-design ⭐ | Every systems-driven game starts here | BotW, Dwarf Fortress, Minecraft | 3-4h |
| sandbox-design-patterns | Open-ended creativity games | Minecraft, Factorio, KSP | 2-3h |
| strategic-depth-from-systems | Competitive games, build diversity | Path of Exile, StarCraft, Dota | 2-3h |
| Skill | When to Use | Examples | Time |
|---|---|---|---|
| optimization-as-play | Factory games, efficiency puzzles | Factorio, Satisfactory, Opus Magnum | 2-4h |
| discovery-through-experimentation | Exploration, hidden depth | BotW, Outer Wilds, Noita | 2-4h |
| player-driven-narratives | Simulation games, emergent storytelling | Dwarf Fortress, Rimworld, CK3 | 2-4h |
| Skill | When to Use | Examples | Time |
|---|---|---|---|
| modding-and-extensibility | Long-term community content | Skyrim, Minecraft, Factorio | 2-3h |
| community-meta-gaming | Competitive, theorycrafting communities | Path of Exile, EVE Online, Dark Souls | 2-3h |
START: What type of game are you building?
├─ SANDBOX / CREATIVITY GAME
│ └─> emergent-gameplay-design + sandbox-design-patterns
│ + optimization-as-play (if optimization core)
│ + discovery-through-experimentation (if discovery-driven)
│ + modding-and-extensibility (if mod support)
├─ COMPETITIVE / STRATEGIC GAME
│ └─> emergent-gameplay-design + strategic-depth-from-systems
│ + community-meta-gaming (if competitive scene planned)
├─ SIMULATION / MANAGEMENT GAME
│ └─> emergent-gameplay-design + player-driven-narratives
│ + optimization-as-play (if optimization gameplay)
├─ EXPLORATION / DISCOVERY GAME
│ └─> emergent-gameplay-design + discovery-through-experimentation
│ + sandbox-design-patterns (if sandbox elements)
└─ MULTIPLAYER SOCIAL GAME
└─> player-driven-narratives + community-meta-gaming
| Game Type | Primary Skill | Secondary Skills | Examples |
|---|---|---|---|
| Sandbox Builder | sandbox-design-patterns | emergent, optimization, discovery | Minecraft, Terraria |
| Factory Game | optimization-as-play | emergent, sandbox | Factorio, Satisfactory |
| Physics Sandbox | emergent-gameplay-design | discovery, sandbox | BotW, Noita |
| Colony Sim | player-driven-narratives | emergent, optimization | Rimworld, DF |
| Competitive Strategy | strategic-depth-from-systems | emergent, meta-gaming | PoE, Dota |
| Exploration Game | discovery-through-experimentation | emergent, sandbox | Outer Wilds, Subnautica |
| MMO Sandbox | player-driven-narratives | meta-gaming, modding | EVE Online |
See routing-scenarios.md for 22 detailed examples:
Problem: Jumping to optimization-as-play without emergent-gameplay-design foundation Symptom: Optimization game with no depth (one optimal solution) Fix: ALWAYS start with emergent-gameplay-design for orthogonal systems, THEN apply optimization
Problem: Trying to use all 8 skills on every project Symptom: Scope creep, conflicting design goals, nothing gets finished Fix: Use routing logic above. Most projects need 2-4 skills, not all 8.
Problem: Going straight to Wave 2/3 skills without Wave 1 Symptom: Surface-level implementation without systemic depth Fix: emergent-gameplay-design is FOUNDATIONAL for most projects. Read it first.
Problem: Trying to make EVERYTHING systemic (including authored narrative) Symptom: Losing authored emotional moments, pacing issues Fix: Most games blend systems + authored content. Use routing logic for systems portion only.
Problem: Thinking "I'll just add emergence" will take 30 minutes Symptom: Rushed implementation, no playtesting, shallow system Fix: Each skill requires 2-4 hours minimum. Budget 8-15 hours for multi-skill projects.
| Need | Use |
|---|---|
| Emergence requires simulation | emergent-gameplay-design + simulation-tactics |
| Systems need math foundation | strategic-depth-from-systems + yzmir/game-theory |
| Systems need feel/polish | optimization-as-play + lyra/game-feel |
Emergence (Core):
Depth:
Discovery:
Community:
The Golden Rule:
"Design systems that interact, then let players surprise you."
After routing, load the appropriate specialist sheet for detailed guidance. 8 specialist sheets:
Go build systems that surprise you.
Use when working on a Python task and unsure which specialist to load - routes to type-system, mypy-resolution, project-tooling, delinting, testing, async, scientific-computing, ML-workflows, debugging-and-profiling, or Textual-TUI specialists based on symptoms
Use when starting any UX/UI design task — visual design, IA, interaction, accessibility (WCAG 2.2), user research across mobile, web, desktop, game, and AI surfaces, plus first-principles audience-derived needs analysis. Routes to 11 specialist sheets.
Use when a Claude is taking **standing ownership** of a software product across many sessions — discovery, strategy, specs, and value validation — deciding *what to build, why, for whom,* and *whether it worked*, with continuity, decision provenance, and an authority boundary that escalates irreversible or outward-facing actions to the human owner. Owns the product disciplines: opportunity assessment (JTBD, problem validation, business case), vision/strategy/positioning and intent-roadmapping, PRDs with falsifiable acceptance criteria, delivery orchestration and acceptance, product-value metrics and experimentation, and the product anti-pattern catalog. Orchestrates rather than reimplements: routes sequencing/flow/WSJF to `/axiom-program-management`, plans to `/axiom-planning`, solution/architecture to `/axiom-solution-architect`, research method to `/lyra-ux-designer`. Do **not** load to build one feature, choose an architecture, or manage delivery flow for already-decided work.
This skill should be used when the user asks to "track work", "create an issue", "find something to work on", "what should I work on next", "triage bugs", "close an issue", "check what's blocked", "plan a milestone", "review sprint progress", "coordinate agents", or when working in a project that uses filigree for issue tracking. Provides workflow patterns, team coordination protocols, and operational guidance for the filigree issue tracker.
Use when designing a system that spans more than one process, machine, or failure domain and a partition, crash, or duplicate must not silently corrupt state. Use when you see split-brain, lost writes under partition, duplicate processing, stuck or half-applied sagas, retry storms, dual writes drifting apart, or "works in staging, melts under load." Architecture-level — how to design correctness under partial failure, not how to deploy it. Single-service API internals → `axiom-web-backend`; CI/CD and ops → `axiom-devops-engineering`; replay/seed determinism → `axiom-determinism-and-replay`; broker/event-sourcing mechanics → the event-driven pack.
Use when designing a system whose past behaviour must be recoverable as a fact — RL training substrates, multi-agent simulations, deterministic game engines, replay-debuggable services, multiplayer lockstep, or any pipeline where "I cannot reproduce that bug" is unacceptable. Use when teams disagree about what "snapshot", "seed", or "replay" mean across modules. Use when cross-machine or cross-process determinism is required, or a regulator will ask "what was the input at tick T?". Architecture-level — how to design a deterministic system. For verifying an existing simulation against known patterns, use `/check-determinism` from yzmir-simulation-foundations instead.