codex-game-studios/skills/brainstorm/DETAILS.md

# Brainstorm Workflow

When this skill is invoked:

1. **Parse the argument** for an optional genre/theme hint (e.g., `roguelike`,
   `space survival`, `cozy farming`). If `open` or no argument, start from
   scratch. Also resolve the review mode (once, store for all gate spawns this run):
   1. If `--review [full|lean|solo]` was passed → use that
   2. Else read `production/review-mode.txt` → use that value
   3. Else → default to `lean`

   See `../../references/studio-docs/director-gates.md` for the full check pattern.

2. **Check for existing concept work**:
   - Read `design/gdd/game-concept.md` if it exists (resume, don't restart)
   - Read `design/gdd/game-pillars.md` if it exists (build on established pillars)

3. **Run through ideation phases** interactively, asking the user questions at
   each phase. Do NOT generate everything silently — the goal is **collaborative
   exploration** where the AI acts as a creative facilitator, not a replacement
   for the human's vision.

   **Use Codex `request_user_input`** at key decision points throughout brainstorming:
   - Constrained taste questions (genre preferences, scope, team size)
   - Concept selection ("Which 2-3 concepts resonate?") after presenting options
   - Direction choices ("Develop further, explore more, or prototype?")
   - Pillar ranking after concepts are refined
   Write full creative analysis in conversation text first, then call
   `request_user_input` to capture the decision with concise labels.

   Codex structured input requirements:
   - Ask 1-3 short questions per `request_user_input` call.
   - Each question must include `header` (12 or fewer characters), `id` (snake_case),
     `question` (one sentence), and 2-3 mutually exclusive `options`.
   - Each option must include `label` (1-5 words) and `description` (one short sentence).
   - Put the recommended option first and suffix its label with `(Recommended)` when
     there is a recommendation.
   - Do not add an explicit `Other` option in Codex app runs; the client supplies the
     free-form Other path. For app-server integrations, the equivalent free-form
     option is represented by `isOther`.
   - If a Claude reference choice list has more than 3 options, split it into a
     first 2-3 option category question plus a follow-up `request_user_input` call,
     or rely on the Codex free-form Other path for uncommon cases.

   Professional studio brainstorming principles to follow:
   - Withhold judgment — no idea is bad during exploration
   - Encourage unusual ideas — outside-the-box thinking sparks better concepts
   - Build on each other — "yes, and..." responses, not "but..."
   - Use constraints as creative fuel — limitations often produce the best ideas
   - Time-box each phase — keep momentum, don't over-deliberate early

---

### Phase 1: Creative Discovery

Start by understanding the person, not the game. Ask these questions
conversationally (not as a checklist):

**Emotional anchors**:
- What's a moment in a game that genuinely moved you, thrilled you, or made
  you lose track of time? What specifically created that feeling?
- Is there a fantasy or power trip you've always wanted in a game but never
  quite found?

**Taste profile**:
- What 3 games have you spent the most time with? What kept you coming back?
  *(Ask this as plain text — the user must be able to type specific game names freely.
  Do NOT put this in `request_user_input` with preset options.)*
- Are there genres you love? Genres you avoid? Why?
- Do you prefer games that challenge you, relax you, tell you stories,
  or let you express yourself? *(Use `request_user_input` for this — constrained choice.
  Use 2-3 grouped options plus Codex's free-form Other path.)*

**Practical constraints** (shape the sandbox before brainstorming).
Bundle these into one Codex `request_user_input` call with three questions:

```json
{
  "questions": [
    {
      "header": "Experience",
      "id": "target_experience",
      "question": "What kind of experience do you most want players to have?",
      "options": [
        {"label": "Challenge", "description": "Players seek mastery, pressure, and earned wins."},
        {"label": "Story", "description": "Players seek discovery, drama, and authored moments."},
        {"label": "Expression", "description": "Players seek creativity, agency, or relaxed flow."}
      ]
    },
    {
      "header": "Timeline",
      "id": "timeline",
      "question": "What's your realistic development timeline?",
      "options": [
        {"label": "Weeks", "description": "A jam-scale prototype or tiny polished game."},
        {"label": "Months", "description": "A focused indie scope with selective polish."},
        {"label": "1+ years", "description": "A larger project that needs strong scope control."}
      ]
    },
    {
      "header": "Dev level",
      "id": "dev_level",
      "question": "Where are you in your dev journey?",
      "options": [
        {"label": "First game", "description": "Keep systems simple and learning-friendly."},
        {"label": "Shipped before", "description": "Use moderate scope and proven patterns."},
        {"label": "Professional", "description": "Assume stronger production and technical context."}
      ]
    }
  ]
}
```

Do not use tabs or more than three options per question in Codex.

**Synthesize** the answers into a **Creative Brief** — a 3-5 sentence
summary of the person's emotional goals, taste profile, and constraints.
Read the brief back and confirm it captures their intent.

---

### Phase 2: Concept Generation

Using the creative brief as a foundation, generate **3 distinct concepts**
that each take a different creative direction. Use these ideation techniques:

**Technique 1: Verb-First Design**
Start with the core player verb (build, fight, explore, solve, survive,
create, manage, discover) and build outward from there. The verb IS the game.

**Technique 2: Mashup Method**
Combine two unexpected elements: [Genre A] + [Theme B]. The tension between
the two creates the unique hook. (e.g., "farming sim + cosmic horror",
"roguelike + dating sim", "city builder + real-time combat")

**Technique 3: Experience-First Design (MDA Backward)**
Start from the desired player emotion (aesthetic goal from MDA framework:
sensation, fantasy, narrative, challenge, fellowship, discovery, expression,
submission) and work backward to the dynamics and mechanics that produce it.

For each concept, present:
- **Working Title**
- **Elevator Pitch** (1-2 sentences — must pass the "10-second test")
- **Core Verb** (the single most common player action)
- **Core Fantasy** (the emotional promise)
- **Unique Hook** (passes the "and also" test: "Like X, AND ALSO Y")
- **Primary MDA Aesthetic** (which emotion dominates?)
- **Estimated Scope** (small / medium / large)
- **Why It Could Work** (1 sentence on market/audience fit)
- **Biggest Risk** (1 sentence on the hardest unanswered question)

Present all three. Then use Codex `request_user_input` to capture the selection.

**CRITICAL**: Codex `request_user_input` only supports 1-3 short questions and
2-3 options per question. Do not use tabs, form fields, or a 5-option list.
Use exactly this shape:

```json
{
  "questions": [
    {
      "header": "Concept",
      "id": "concept_choice",
      "question": "Which concept is the strongest starting point?",
      "options": [
        {"label": "Concept 1", "description": "[Title] — [one-line reason it fits]."},
        {"label": "Concept 2", "description": "[Title] — [one-line reason it fits]."},
        {"label": "Concept 3", "description": "[Title] — [one-line reason it fits]."}
      ]
    },
    {
      "header": "Next move",
      "id": "concept_next_move",
      "question": "How should we proceed with that direction?",
      "options": [
        {"label": "Develop it", "description": "Use the selected concept as the foundation."},
        {"label": "Combine", "description": "Blend the selected concept with elements from another."},
        {"label": "Fresh set", "description": "Generate three new directions from the brief."}
      ]
    }
  ]
}
```

If the user wants a custom blend, use the Codex free-form Other path.

Never pressure toward a choice — let them sit with it.

---

### Phase 3: Core Loop Design

For the chosen concept, use structured questioning to build the core loop.
The core loop is the beating heart of the game — if it isn't fun in
isolation, no amount of content or polish will save the game.

**30-Second Loop** (moment-to-moment):

Ask these with Codex `request_user_input` — derive the options from the chosen
concept, don't hardcode them:

1. **Core action feel** — prompt: "What's the primary feel of the core action?" Generate exactly 2-3 options that fit the concept's genre and tone. Use the Codex free-form Other path for custom answers.

2. **Key design dimension** — identify the most important design variable for this specific concept (e.g., world reactivity, pacing, player agency) and ask about it. Generate exactly 2-3 options that match the concept. Use the Codex free-form Other path for custom answers.

After capturing answers, analyze: Is this action intrinsically satisfying? What makes it feel good? (Audio feedback, visual juice, timing satisfaction, tactical depth?)

**5-Minute Loop** (short-term goals):
- What structures the moment-to-moment play into cycles?
- Where does "one more turn" / "one more run" psychology kick in?
- What choices does the player make at this level?

**Session Loop** (30-120 minutes):
- What does a complete session look like?
- Where are the natural stopping points?
- What's the "hook" that makes them think about the game when not playing?

**Progression Loop** (days/weeks):
- How does the player grow? (Power? Knowledge? Options? Story?)
- What's the long-term goal? When is the game "done"?

**Player Motivation Analysis** (based on Self-Determination Theory):
- **Autonomy**: How much meaningful choice does the player have?
- **Competence**: How does the player feel their skill growing?
- **Relatedness**: How does the player feel connected (to characters,
  other players, or the world)?

---

### Phase 4: Pillars and Boundaries

Game pillars are used by real AAA studios (God of War, Hades, The Last of
Us) to keep hundreds of team members making decisions that all point the
same direction. Even for solo developers, pillars prevent scope creep and
keep the vision sharp.

Collaboratively define **3-5 pillars**:
- Each pillar has a **name** and **one-sentence definition**
- Each pillar has a **design test**: "If we're debating between X and Y,
  this pillar says we choose __"
- Pillars should feel like they create tension with each other — if all
  pillars point the same way, they're not doing enough work

Then define **3+ anti-pillars** (what this game is NOT):
- Anti-pillars prevent the most common form of scope creep: "wouldn't it
  be cool if..." features that don't serve the core vision
- Frame as: "We will NOT do [thing] because it would compromise [pillar]"

**Pillar confirmation**: After presenting the full pillar set, use Codex `request_user_input`:
- Prompt: "Do these pillars feel right for your game?"
- Options: `[A] Lock these in` / `[B] Revise one` / `[C] Discuss further`

If the user selects B or C, make the revision or discuss the concern, then use
Codex `request_user_input` again:
- Prompt: "Pillars updated. Ready to lock these in?"
- Options: `[A] Lock these in` / `[B] Revise another` / `[C] Discuss further`

Repeat until the user selects [A] Lock these in.

**Review mode check** — apply before spawning CD-PILLARS and AD-CONCEPT-VISUAL:
- `solo` → skip both. Note: "CD-PILLARS skipped — Solo mode. AD-CONCEPT-VISUAL skipped — Solo mode." Proceed to Phase 5.
- `lean` → skip both (not PHASE-GATEs). Note: "CD-PILLARS skipped — Lean mode. AD-CONCEPT-VISUAL skipped — Lean mode." Proceed to Phase 5.
- `full` → spawn as normal.

**After pillars and anti-pillars are agreed, spawn BOTH `creative-director` AND `art-director` via Codex custom-agent delegation in parallel before moving to Phase 5. Issue both custom-agent requests simultaneously — do not wait for one before starting the other.**

- **`creative-director`** — gate **CD-PILLARS** (`../../references/studio-docs/director-gates.md`)
  Pass: full pillar set with design tests, anti-pillars, core fantasy, unique hook.

- **`art-director`** — gate **AD-CONCEPT-VISUAL** (`../../references/studio-docs/director-gates.md`)
  Pass: game concept elevator pitch, full pillar set with design tests, target platform (if known), any reference games or visual touchstones the user mentioned.

Collect both verdicts, then present them together using one Codex
`request_user_input` call with up to two questions:
- Question **"Pillars"**: present creative-director feedback. Options mirror the standard CD-PILLARS handling — `Lock in` / `Revise one` / `Discuss`.
- Question **"Visual"**: present the art-director's 2-3 named visual direction options. If there are three named directions, use those three options and rely on the Codex free-form Other path for combine/custom answers. If there are only two named directions, use those two plus `Combine`.

The user's selected visual anchor (the named direction or their custom description) is stored as the **Visual Identity Anchor** — it will be written into the game-concept document and becomes the foundation of the art bible.

If the creative-director returns CONCERNS or REJECT on pillars, resolve pillar issues before asking for the visual anchor selection — visual direction should flow from confirmed pillars.

---

### Phase 5: Player Type Validation

Using the Bartle taxonomy and Quantic Foundry motivation model, validate
who this game is actually for:

- **Primary player type**: Who will LOVE this game? (Achievers, Explorers,
  Socializers, Competitors, Creators, Storytellers)
- **Secondary appeal**: Who else might enjoy it?
- **Who is this NOT for**: Being clear about who won't like this game is as
  important as knowing who will
- **Market validation**: Are there successful games that serve a similar
  player type? What can we learn from their audience size?

---

### Phase 6: Scope and Feasibility

Ground the concept in reality:

- **Target platform**: Use Codex `request_user_input` — "What platforms are you targeting for this game?"
  Options: `PC` / `Mobile` / `Console/Web`. Use the Codex free-form Other path for multiple platforms or a specific store target.
  Record the answer — it directly shapes the engine recommendation and will be passed to `/setup-engine`.
  Note platform implications if relevant (e.g., mobile means Unity is strongly preferred; console means Godot has limitations; web means Godot exports cleanly).

- **Engine experience**: Use Codex `request_user_input` — "Do you already have an engine you work in?"
  Options: `Godot` / `Unity` / `Unreal`. Use the Codex free-form Other path for "No preference" or another engine.
  - If they pick an engine → record it as their preference and move on. Do NOT second-guess it.
  - If "No preference" → tell them: "Run `/setup-engine` after this session — it will walk you through the full decision based on your concept and platform target." Do not make a recommendation here.
- **Art pipeline**: What's the art style and how labor-intensive is it?
- **Content scope**: Estimate level/area count, item count, gameplay hours
- **MVP definition**: What's the absolute minimum build that tests "is the
  core loop fun?"
- **Biggest risks**: Technical risks, design risks, market risks
- **Scope tiers**: What's the full vision vs. what ships if time runs out?

**Review mode check** — apply before spawning TD-FEASIBILITY:
- `solo` → skip. Note: "TD-FEASIBILITY skipped — Solo mode." Proceed directly to scope tier definition.
- `lean` → skip (not a PHASE-GATE). Note: "TD-FEASIBILITY skipped — Lean mode." Proceed directly to scope tier definition.
- `full` → spawn as normal.

**After identifying biggest technical risks, spawn `technical-director` via Codex custom-agent delegation using gate TD-FEASIBILITY (`../../references/studio-docs/director-gates.md`) before scope tiers are defined.**

Pass: core loop description, platform target, engine choice (or "undecided"), list of identified technical risks.

Present the assessment to the user. If HIGH RISK, offer to revisit scope before finalising. If CONCERNS, note them and continue.

**Review mode check** — apply before spawning PR-SCOPE:
- `solo` → skip. Note: "PR-SCOPE skipped — Solo mode." Proceed to document generation.
- `lean` → skip (not a PHASE-GATE). Note: "PR-SCOPE skipped — Lean mode." Proceed to document generation.
- `full` → spawn as normal.

**After scope tiers are defined, spawn `producer` via Codex custom-agent delegation using gate PR-SCOPE (`../../references/studio-docs/director-gates.md`).**

Pass: full vision scope, MVP definition, timeline estimate, team size.

Present the assessment to the user. If UNREALISTIC, offer to adjust the MVP definition or scope tiers before writing the document.

---

4. **Generate the game concept document** using the template at
   `../../references/studio-docs/templates/game-concept.md`. Fill in ALL sections from the
   brainstorm conversation, including the MDA analysis, player motivation
   profile, and flow state design sections.

   **Include a Visual Identity Anchor section** in the game concept document with:
   - The selected visual direction name
   - The one-line visual rule
   - The 2-3 supporting visual principles with their design tests
   - The color philosophy summary

   This section is the seed of the art bible — it captures the "everything must
   move" decision before it can be forgotten between sessions.

5. Use Codex `request_user_input` for write approval:
- Prompt: "Game concept is ready. May I write it to `design/gdd/game-concept.md`?"
- Options: `[A] Yes — write it` / `[B] Not yet — revise a section first`

If [B]: ask which area to revise using Codex `request_user_input` with 2-3
category options such as `Identity`, `Loop`, and `Scope/Risks`, then ask a
follow-up question if the category needs narrowing. Use the Codex free-form
Other path for a custom section.

After revising, show the updated section as a diff or clear before/after, then use Codex `request_user_input` — "Ready to write the updated concept document?"
Options: `[A] Yes — write it` / `[B] Revise another section`
Repeat until the user selects [A].

If yes, generate the document using the template at `../../references/studio-docs/templates/game-concept.md`, fill in ALL sections from the brainstorm conversation, and write the file, creating directories as needed.

**Scope consistency rule**: The "Estimated Scope" field in the Core Identity table must match the full-vision timeline from the Scope Tiers section — not just say "Large (9+ months)". Write it as "Large (X–Y months, solo)" or "Large (X–Y months, team of N)" so the summary table is accurate.

6. **Suggest next steps** (in this order — this is the professional studio
   pre-production pipeline). List ALL steps — do not abbreviate or truncate:

**Path A — Design-First** (recommended if the concept is well-defined):
   1. "Run `/setup-engine` to configure the engine and populate version-aware reference docs"
   2. "Run `/art-bible` to create the visual identity specification — do this BEFORE writing GDDs. **The art bible is required before the Technical Setup gate.** It gates asset production and shapes technical architecture decisions (rendering, VFX, UI systems)."
   3. "Use `/design-review design/gdd/game-concept.md` to validate concept completeness before going downstream"
   4. "Discuss vision with the `creative-director` custom agent for pillar refinement"
   5. "Decompose the concept into individual systems with `/map-systems` — maps dependencies, assigns priorities, and creates the systems index"
   6. "Author per-system GDDs with `/design-system` — guided, section-by-section GDD writing for each system identified in step 5"
   7. "Plan the technical architecture with `/create-architecture` — produces the master architecture blueprint and Required ADR list"
   8. "Record key architectural decisions with `/architecture-decision (×N)` — write one ADR per decision in the Required ADR list from `/create-architecture`"
   9. "Run `/architecture-review` — bootstraps the TR registry and Requirements Traceability Matrix from your GDDs and ADRs (required before the Pre-Production gate)"
   10. "Validate readiness to advance with `/gate-check` — phase gate before committing to production"

**Path B — Prototype-First** (use if the core mechanic is unproven or the concept needs validation):
   1. "Run `/setup-engine` to configure the engine"
   2. "Run `/prototype [core-mechanic]` — validate the core idea is fun before writing any GDDs (1–3 days throwaway code)"
   3. "If prototype PROCEEDS: run `/art-bible`, then continue with Path A steps 5–10 above, using prototype learnings to inform your GDDs"
   4. "If prototype PIVOTS: return to `/brainstorm` with the learnings and reshape the concept"
   5. "After full design and architecture, build the `/vertical-slice` to validate production readiness before committing to sprints"

7. **Output a summary** with the chosen concept's elevator pitch, pillars,
   primary player type, engine recommendation, biggest risk, and file path.

Verdict: **COMPLETE** — game concept created and handed off for next steps.

---

## Context Window Awareness

This is a multi-phase skill. If context reaches or exceeds 70% during any phase,
append this notice to the current response before continuing:

> **Context is approaching the limit (≥70%).** The game concept document is saved
> to `design/gdd/game-concept.md`. Open a fresh Codex session to continue
> if needed — progress is not lost.

---

## Recommended Next Steps

After the game concept is written, follow the pre-production pipeline in order:
1. `/setup-engine` — configure the engine and populate version-aware reference docs
2. `/art-bible` — establish visual identity before writing any GDDs
3. `/map-systems` — decompose the concept into individual systems with dependencies
4. `/design-system [first-system]` — author per-system GDDs in dependency order
5. `/create-architecture` — produce the master architecture blueprint
6. `/architecture-review` — bootstrap TR registry and Requirements Traceability Matrix
7. `/gate-check pre-production` — validate readiness before committing to production