mirror of https://github.com/Donchitos/Claude-Code-Game-Studios.git synced 2026-06-27 04:51:46 +00:00

Files

Donchitos b139bcf087 Add director gates system: shared review checkpoints across all workflow skills

Creates .claude/docs/director-gates.md as a central registry of 18 named gate
prompts (CD-*, TD-*, PR-*, LP-*, QL-*, ND-*, AD-*) covering all 7 production
stages. Skills now reference gate IDs instead of embedding inline director prompts,
eliminating drift when prompts need updating.

Updated 15 skills to use gate IDs: brainstorm, map-systems, design-system,
architecture-decision, create-architecture, create-epics, create-stories,
sprint-plan, milestone-review, playtest-report, prototype, story-done,
gate-check, setup-engine, start.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

2026-03-29 17:24:06 +11:00

9.2 KiB

Raw Blame History

name, description, argument-hint, user-invocable, allowed-tools

name	description	argument-hint	user-invocable	allowed-tools
start	First-time onboarding — asks where you are, then guides you to the right workflow. No assumptions.	[no arguments]	true	Read, Glob, Grep, AskUserQuestion

Guided Onboarding

This skill is read-only — it reports findings but writes no files.

This skill is the entry point for new users. It does NOT assume you have a game idea, an engine preference, or any prior experience. It asks first, then routes you to the right workflow.

Phase 1: Detect Project State

Before asking anything, silently gather context so you can tailor your guidance. Do NOT show these results unprompted — they inform your recommendations, not the conversation opener.

Check:

Engine configured? Read .claude/docs/technical-preferences.md. If the Engine field contains [TO BE CONFIGURED], the engine is not set.
Game concept exists? Check for design/gdd/game-concept.md.
Source code exists? Glob for source files in src/ (*.gd, *.cs, *.cpp, *.h, *.rs, *.py, *.js, *.ts).
Prototypes exist? Check for subdirectories in prototypes/.
Design docs exist? Count markdown files in design/gdd/.
Production artifacts? Check for files in production/sprints/ or production/milestones/.

Store these findings internally to validate the user's self-assessment and tailor recommendations.

Phase 2: Ask Where the User Is

This is the first thing the user sees. Use AskUserQuestion with these exact options so the user can click rather than type:

Prompt: "Welcome to Claude Code Game Studios! Before I suggest anything, I'd like to understand where you're starting from. Where are you at with your game idea right now?"
Options:
- A) No idea yet — I don't have a game concept at all. I want to explore and figure out what to make.
- B) Vague idea — I have a rough theme, feeling, or genre in mind (e.g., "something with space" or "a cozy farming game") but nothing concrete.
- C) Clear concept — I know the core idea — genre, basic mechanics, maybe a pitch sentence — but haven't formalized it into documents yet.
- D) Existing work — I already have design docs, prototypes, code, or significant planning done. I want to organize or continue the work.

Wait for the user's selection. Do not proceed until they respond.

Phase 3: Route Based on Answer

If A: No idea yet

The user needs creative exploration before anything else.

Acknowledge that starting from zero is completely fine
Briefly explain what /brainstorm does (guided ideation using professional frameworks — MDA, player psychology, verb-first design). Mention that it has two modes: /brainstorm open for fully open exploration, or /brainstorm [hint] if they have even a vague theme (e.g., "space", "cozy", "horror").
Recommend running /brainstorm open as the next step, but invite them to use a hint if something comes to mind
Show the recommended path: Concept phase:
- /brainstorm open — discover your game concept
- /setup-engine — configure the engine (brainstorm will recommend one)
- /map-systems — decompose the concept into systems
- /design-system — author a GDD for each MVP system
- /review-all-gdds — cross-system consistency check
- /gate-check — validate readiness before architecture work Architecture phase:
- /architecture-decision — record key technical decisions (one per system)
- /create-control-manifest — compile decisions into an actionable rules sheet
- /architecture-review — validate architecture coverage Production phase:
- /create-epics — map systems to epics
- /create-stories — break epics into implementable stories
- /sprint-plan — plan the first sprint

If B: Vague idea

Ask them to share their vague idea — even a few words is enough
Validate the idea as a starting point (don't judge or redirect)
Recommend running /brainstorm [their hint] to develop it
Show the recommended path: Concept phase:
- /brainstorm [hint] — develop the idea into a full concept
- /setup-engine — configure the engine
- /map-systems — decompose the concept into systems
- /design-system — author a GDD for each MVP system
- /review-all-gdds — cross-system consistency check
- /gate-check — validate readiness before architecture work Architecture phase:
- /architecture-decision — record key technical decisions (one per system)
- /create-control-manifest — compile decisions into an actionable rules sheet
- /architecture-review — validate architecture coverage Production phase:
- /create-epics — map systems to epics
- /create-stories — break epics into implementable stories
- /sprint-plan — plan the first sprint

If C: Clear concept

Ask them to describe their concept in one sentence — genre and core mechanic. Use plain text, not AskUserQuestion (it's an open response).
Acknowledge the concept, then use AskUserQuestion to offer two paths:
- Prompt: "How would you like to proceed?"
- Options:
  - Formalize it first — Run /brainstorm [concept] to structure it into a proper game concept document
  - Jump straight in — Go to /setup-engine now and write the GDD manually afterward
Show the recommended path: Concept phase:
- /brainstorm or /setup-engine (their pick)
- /design-review — validate the concept doc
- /map-systems — decompose the concept into individual systems
- /design-system — author a GDD for each MVP system
- /review-all-gdds — cross-system consistency check
- /gate-check — validate readiness before architecture work Architecture phase:
- /architecture-decision — record key technical decisions (one per system)
- /create-control-manifest — compile decisions into an actionable rules sheet
- /architecture-review — validate architecture coverage Production phase:
- /create-epics — map systems to epics
- /create-stories — break epics into implementable stories
- /sprint-plan — plan the first sprint

If D: Existing work

Share what you found in Phase 1:
- "I can see you have [X source files / Y design docs / Z prototypes]..."
- "Your engine is [configured as X / not yet configured]..."
Sub-case D1 — Early stage (engine not configured or only a game concept exists):
- Recommend /setup-engine first if engine not configured
- Then /project-stage-detect for a gap inventory
Sub-case D2 — GDDs, ADRs, or stories already exist:
- Explain: "Having files isn't the same as the template's skills being able to use them. GDDs might be missing required sections. /adopt checks this specifically."
- Recommend:
  1. /project-stage-detect — understand what phase and what's missing entirely
  2. /adopt — audit whether existing artifacts are in the right internal format
Show the recommended path for D2:
- /project-stage-detect — phase detection + existence gaps
- /adopt — format compliance audit + migration plan
- /setup-engine — if engine not configured
- /design-system retrofit [path] — fill missing GDD sections
- /architecture-decision retrofit [path] — add missing ADR sections
- /architecture-review — bootstrap the TR requirement registry
- /gate-check — validate readiness for next phase

Phase 4: Confirm Before Proceeding

After presenting the recommended path, use AskUserQuestion to ask the user which step they'd like to take first. Never auto-run the next skill.

Prompt: "Would you like to start with [recommended first step]?"
Options:
- Yes, let's start with [recommended first step]
- I'd like to do something else first

Phase 5: Hand Off

When the user confirms their next step, respond with a single short line: "Type [skill command] to begin." Nothing else. Do not re-explain the skill or add encouragement. The /start skill's job is done.

Verdict: COMPLETE — user oriented and handed off to next step.

Edge Cases

User picks D but project is empty: Gently redirect — "It looks like the project is a fresh template with no artifacts yet. Would Path A or B be a better fit?"
User picks A but project has code: Mention what you found — "I noticed there's already code in src/. Did you mean to pick D (existing work)?"
User is returning (engine configured, concept exists): Skip onboarding entirely — "It looks like you're already set up! Your engine is [X] and you have a game concept at design/gdd/game-concept.md. Want to pick up where you left off? Try /sprint-plan or just tell me what you'd like to work on."
User doesn't fit any option: Let them describe their situation in their own words and adapt.

Collaborative Protocol

Ask first — never assume the user's state or intent
Present options — give clear paths, not mandates
User decides — they pick the direction
No auto-execution — recommend the next skill, don't run it without asking
Adapt — if the user's situation doesn't fit a template, listen and adjust

9.2 KiB Raw Blame History