Game Studio Agent Architecture — complete setup (Phases 1-7)

48 coordinated Claude Code subagents for indie game development:
- 3 leadership agents (creative-director, technical-director, producer)
- 10 department leads (game-designer, lead-programmer, art-director, etc.)
- 23 specialist agents (gameplay, engine, AI, networking, UI, tools, etc.)
- 12 engine-specific agents (Godot, Unity, Unreal with sub-specialists)

Infrastructure:
- 34 skills (slash commands) for workflows, reviews, and team orchestration
- 8 hooks for commit validation, asset checks, session management
- 11 path-scoped rules enforcing domain-specific standards
- 28 templates for design docs, reports, and collaborative protocols

Key features:
- User-driven collaboration protocol (Question → Options → Decision → Draft → Approval)
- Engine version awareness with knowledge-gap detection (Godot 4.6 pinned)
- Phase gate system for development milestone validation
- CLAUDE.md kept under 80 lines with extracted doc imports

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

.claude/skills/project-stage-detect/SKILL.md

@@ -0,0 +1,184 @@
+---
+name: project-stage-detect
+description: "Automatically analyze project state, detect stage, identify gaps, and recommend next steps based on existing artifacts."
+argument-hint: "[optional: role filter like 'programmer' or 'designer']"
+user-invocable: true
+allowed-tools: Read, Glob, Grep, Bash
+---
+
+# Project Stage Detection
+
+This skill scans your project to determine its current development stage, completeness
+of artifacts, and gaps that need attention. It's especially useful when:
+- Starting with an existing project
+- Onboarding to a codebase
+- Checking what's missing before a milestone
+- Understanding "where are we?"
+
+---
+
+## Workflow
+
+### 1. Scan Key Directories
+
+Analyze project structure and content:
+
+**Design Documentation** (`design/`):
+- Count GDD files in `design/gdd/*.md`
+- Check for game-concept.md, game-pillars.md
+- Analyze completeness (Overview, Detailed Design, Edge Cases, etc.)
+- Count narrative docs in `design/narrative/`
+- Count level designs in `design/levels/`
+
+**Source Code** (`src/`):
+- Count source files (language-agnostic)
+- Identify major systems (directories with 5+ files)
+- Check for core/, gameplay/, ai/, networking/, ui/ directories
+- Estimate lines of code (rough scale)
+
+**Production Artifacts** (`production/`):
+- Check for active sprint plans
+- Look for milestone definitions
+- Find roadmap documents
+
+**Prototypes** (`prototypes/`):
+- Count prototype directories
+- Check for READMEs (documented vs undocumented)
+- Assess if prototypes are archived or active
+
+**Architecture Docs** (`docs/architecture/`):
+- Count ADRs (Architecture Decision Records)
+- Check for overview/index documents
+
+**Tests** (`tests/`):
+- Count test files
+- Estimate test coverage (rough heuristic)
+
+### 2. Classify Project Stage
+
+Based on scanned artifacts, determine stage:
+
+| Stage | Indicators |
+|-------|-----------|
+| **Concept** | No code or minimal prototype, maybe idea docs |
+| **Pre-production** | Design docs started, prototypes, no main src/ |
+| **Production** | Active src/, sprint plans, growing systems |
+| **Post-Launch** | Released, production/ has release history, maintenance focus |
+
+### 3. Collaborative Gap Identification
+
+**DO NOT** just list missing files. Instead, **ask clarifying questions**:
+
+- "I see combat code (`src/gameplay/combat/`) but no `design/gdd/combat-system.md`. Was this prototyped first, or should we reverse-document?"
+- "You have 15 ADRs but no architecture overview. Should I create one to help new contributors?"
+- "No sprint plans in `production/`. Are you tracking work elsewhere (Jira, Trello, etc.)?"
+- "Prototypes directory has 3 projects with no READMEs. Were these experiments, or do they need documentation?"
+
+### 4. Generate Stage Report
+
+Use template: `docs/templates/project-stage-report.md`
+
+**Report structure**:
+```markdown
+# Project Stage Analysis
+
+**Date**: [date]
+**Stage**: [Concept/Pre-production/Production/Post-Launch]
+
+## Completeness Overview
+- Design: [X%] ([N] docs, [gaps])
+- Code: [X%] ([N] files, [systems])
+- Architecture: [X%] ([N] ADRs, [gaps])
+- Production: [X%] ([status])
+- Tests: [X%] ([coverage estimate])
+
+## Gaps Identified
+1. [Gap description + clarifying question]
+2. [Gap description + clarifying question]
+
+## Recommended Next Steps
+[Priority-ordered list based on stage and role]
+```
+
+### 5. Role-Filtered Recommendations (Optional)
+
+If user provided a role argument (e.g., `/project-stage-detect programmer`):
+
+**Programmer**:
+- Focus on architecture docs, test coverage, missing ADRs
+- Code-to-docs gaps
+
+**Designer**:
+- Focus on GDD completeness, missing design sections
+- Prototype documentation
+
+**Producer**:
+- Focus on sprint plans, milestone tracking, roadmap
+- Cross-team coordination docs
+
+**General** (no role):
+- Holistic view of all gaps
+- Highest-priority items across domains
+
+### 6. Request Approval Before Writing
+
+**Collaborative protocol**:
+```
+I've analyzed your project. Here's what I found:
+
+[Show summary]
+
+Gaps identified:
+1. [Gap 1 + question]
+2. [Gap 2 + question]
+
+Recommended next steps:
+- [Priority 1]
+- [Priority 2]
+- [Priority 3]
+
+May I write the full stage analysis to docs/project-stage-report.md?
+```
+
+Wait for user approval before creating the file.
+
+---
+
+## Example Usage
+
+```bash
+# General project analysis
+/project-stage-detect
+
+# Programmer-focused analysis
+/project-stage-detect programmer
+
+# Designer-focused analysis
+/project-stage-detect designer
+```
+
+---
+
+## Follow-Up Actions
+
+After generating the report, suggest relevant next steps:
+
+- **Missing design docs?** → `/reverse-document design src/[system]`
+- **Missing architecture docs?** → `/architecture-decision` or `/reverse-document architecture`
+- **Prototypes need documentation?** → `/reverse-document concept prototypes/[name]`
+- **No sprint plan?** → `/sprint-plan`
+- **Approaching milestone?** → `/milestone-review`
+
+---
+
+## Collaborative Protocol
+
+This skill follows the collaborative design principle:
+
+1. **Question First**: Ask about gaps, don't assume
+2. **Present Options**: "Should I create X, or is it tracked elsewhere?"
+3. **User Decides**: Wait for direction
+4. **Show Draft**: Display report summary
+5. **Get Approval**: "May I write to docs/project-stage-report.md?"
+
+**Never** silently write files. **Always** show findings and ask before creating artifacts.