wordle/.claude/skills/gds-game-architecture/steps/step-04-decisions.md

---

name: 'step-04-decisions' description: 'Facilitate collaborative architectural decision making for game systems'

Path Definitions

workflow_path: '{installed_path}'

File References

thisStepFile: './step-04-decisions.md' nextStepFile: './step-05-crosscutting.md' workflowFile: '{workflow_path}/workflow.md' outputFile: '{output_folder}/game-architecture.md'

Knowledge Bases

decisionCatalog: '{workflow_path}/decision-catalog.yaml' architecturePatterns: '{workflow_path}/architecture-patterns.yaml' engineKnowledge: '{workflow_path}/knowledge/{selected_engine}-engine.md'

Task References

advancedElicitationTask: 'skill:bmad-advanced-elicitation'

partyModeWorkflow: 'skill:bmad-party-mode'

Step 4: Architectural Decisions

Progress: Step 4 of 9 - Next: Cross-cutting Concerns

STEP GOAL:

Facilitate collaborative decision-making for all remaining architectural choices. Each decision must be made WITH the user, not FOR them.

MANDATORY EXECUTION RULES (READ FIRST):

Universal Rules:

• NEVER generate content without user input
• CRITICAL: Read the complete step file before taking any action
• CRITICAL: When loading next step with 'C', ensure entire file is read
• YOU ARE A FACILITATOR, not a content generator
• NEVER mention time estimates
• ✅ YOU MUST ALWAYS SPEAK OUTPUT In your Agent communication style with the config {communication_language}

Role Reinforcement:

• You are a veteran game architect facilitator
• Each decision must be made WITH the user
• Present options, explain trade-offs, accept user choice

Step-Specific Rules:

• Load decision catalog for structured guidance
• Verify technology versions via web search
• Document rationale for every decision

EXECUTION PROTOCOLS:

• Show your analysis before taking any action
• Present A/P/C menu after all decisions documented
• ONLY proceed when user chooses C (Continue)
• Update frontmatter stepsCompleted: [1, 2, 3, 4] before loading next step

COLLABORATION MENUS (A/P/C):

• A (Advanced Elicitation): Challenge decisions and explore alternatives
• P (Party Mode): Get multiple perspectives on choices
• C (Continue): Confirm decisions and proceed

Sequence of Instructions (Do not deviate, skip, or optimize)

1. Load Decision Framework

Load decision catalog if available:

Load {decisionCatalog}, {architecturePatterns}, and {engineKnowledge} (the engine-specific knowledge fragment matching the engine selected in Step 3) to guide the decision process.

Identify required decisions based on game type:

Category	Decisions Needed
State Management	{{if_applicable}}
Data Persistence	Save system, config storage
Networking	{{if_multiplayer}}
AI Systems	{{if_has_ai}}
Asset Loading	Streaming, caching
Scene Structure	Scene graph, loading
UI Framework	In-game, menus
Audio Architecture	Channels, mixing

2. Prioritize Decisions

Create decision priority list:

"Based on your project, here are the architectural decisions we need to make:

CRITICAL (blocks everything): {{critical_decisions}}

IMPORTANT (shapes architecture): {{important_decisions}}

NICE-TO-HAVE (can defer): {{optional_decisions}}

Let's work through these in priority order."

3. Facilitate Each Decision

For each decision, follow this pattern:

"Decision: {{decision_name}}

{{context_about_why_this_matters}}

Options:

Option	Pros	Cons
{{option_1}}	{{pros}}	{{cons}}
{{option_2}}	{{pros}}	{{cons}}
{{option_3}}	{{pros}}	{{cons}}

Recommendation: {{recommendation}} because {{reason}}

What's your preference? (or 'explain more' for details)"

After user decides:

Record:

• Category: {{category}}
• Decision: {{user_choice}}
• Version: {{if_applicable}}
• Rationale: {{user_reasoning}}

4. Game-Specific Decision Categories

State Management:

"How should game state be managed?

Options:

• Singleton Pattern - Simple, global access, harder to test
• State Machine - Clear transitions, good for game modes
• ECS (Entity Component System) - Scalable, decoupled, learning curve
• Redux-style - Predictable, time travel debugging, more boilerplate

For {{game_type}}, {{recommendation}} works well because {{reason}}.

Your choice?"

Save System:

"How should player progress be saved?

Options:

• Local files - JSON/binary, works offline
• Cloud saves - Cross-device, requires backend
• Hybrid - Local primary, cloud sync
• Platform-specific - Steam Cloud, console saves

Your choice?"

Asset Loading:

"How should assets be loaded?

Options:

• Preload all - Simple, longer initial load
• Lazy loading - Fast startup, potential hitches
• Streaming - Seamless, complex implementation
• Scene-based - Load per scene, clear boundaries

Your choice?"

5. Handle Version Verification

For any technology-specific decisions:

Search web: "{{technology}} latest stable version {{current_year}}"

Document:

• Technology: {{name}}
• Verified Version: {{version}}
• Verification Date: {{today}}

6. Generate Decisions Section

After all decisions are made, prepare the content:

## Architectural Decisions

### Decision Summary

| Category | Decision | Version | Rationale |
| -------- | -------- | ------- | --------- |

{{decision_table_rows}}

### State Management

**Approach:** {{state_management_choice}}

{{state_management_details}}

### Data Persistence

**Save System:** {{save_system_choice}}

{{save_system_details}}

### Asset Management

**Loading Strategy:** {{asset_loading_choice}}

{{asset_loading_details}}

### {{Additional_Categories}}

{{additional_decision_details}}

### Architecture Decision Records

{{key_decisions_with_context}}

7. Present Content and Menu

Show the generated content to the user and present:

"I've documented all our architectural decisions.

Here's what I'll add to the document:

[Show the complete markdown content from step 6]

Decisions Made: {{count}} decisions documented

Validation Check:

• Are all critical decisions captured?
• Are versions current and verified?
• Does the rationale reflect your reasoning?

Select an Option: [A] Advanced Elicitation - Challenge decisions, explore alternatives [P] Party Mode - Get different perspectives on choices [C] Continue - Save this and move to Cross-cutting Concerns (Step 5 of 9)"

8. Handle Menu Selection

IF A (Advanced Elicitation):

• Execute {advancedElicitationTask} with the current content
• Ask user: "Accept these changes? (y/n)"
• If yes: Update content, return to A/P/C menu
• If no: Keep original, return to A/P/C menu

IF P (Party Mode):

• Execute {partyModeWorkflow} with the current content
• Ask user: "Accept these changes? (y/n)"
• If yes: Update content, return to A/P/C menu
• If no: Keep original, return to A/P/C menu

IF C (Continue):

• Append the final content to {outputFile}
• Update frontmatter: stepsCompleted: [1, 2, 3, 4]
• Load {nextStepFile}

CRITICAL STEP COMPLETION NOTE

ONLY WHEN [C continue option] is selected and [decisions content saved with frontmatter updated], will you then load and read fully {nextStepFile}.

---

SYSTEM SUCCESS/FAILURE METRICS

SUCCESS:

• All required decisions identified
• User made each decision (not generated)
• Versions verified via web search
• Rationale documented for each decision
• A/P/C menu presented and handled correctly
• Frontmatter updated with stepsCompleted: [1, 2, 3, 4]

SYSTEM FAILURE:

• Making decisions FOR the user
• Using unverified versions
• Missing critical decisions
• Not documenting rationale
• Not presenting A/P/C menu after decisions
• Proceeding without user selecting 'C'

Master Rule: Skipping steps, optimizing sequences, or not following exact instructions is FORBIDDEN and constitutes SYSTEM FAILURE.