Donchitos/Claude-Code-Game-Studios

Adopt audits a brownfield project's existing artifacts against the template's required internal formats, classifies gaps by impact, and produces a numbered migration plan. Use it when joining an in-progress project or upgrading from an older template version.

Architecture Decision creates an Architecture Decision Record (ADR) documenting a significant technical decision, its context, alternatives considered, and consequences. Use it when every major technical choice should have a formal, validated ADR in a game development project.

Architecture Review validates that architectural decisions cover all game design requirements, are internally consistent, and target the correct engine version. It builds a traceability matrix, detects cross-ADR conflicts, and produces a PASS/CONCERNS/FAIL verdict.

Art Bible guides section-by-section authoring of a game's visual identity specification, which gates all asset production. Use it after the game concept is approved and before any game design document authoring.

Asset Audit scans game asset directories to check naming conventions, file size budgets, format standards, and pipeline requirements. Use it to identify orphaned assets, missing references, and standard violations before release.

Asset Spec generates per-asset visual specifications and AI generation prompts from game design documents, level docs, or character profiles. Use it after the art bible and GDD/level design are approved, before production begins.

Balance Check analyzes game balance data files, formulas, and configuration to identify outliers, broken progressions, degenerate strategies, and economy imbalances. Use it after modifying any balance-related data or design.

Brainstorm guides game developers from a blank slate to a structured concept document through collaborative questioning and professional studio ideation techniques. Use it when starting a new game project to define the creative direction and core loop.

Bug Report creates structured bug reports from descriptions or code analysis, with reproduction steps, severity assessment, and context. Use it when filing, verifying, or closing bugs in a game development workflow.

Bug Triage reads open bugs, classifies severity and priority, assigns them to sprints, detects systemic trends, and writes a triage report. Run at sprint start or when the bug backlog grows.

Changelog Generator auto-generates internal and player-facing changelogs from git commits, sprint data, and design documents. Use it to categorize changes, add metrics, and produce release notes ready for community posting.

Code Review performs architectural and quality code review on a specified file or set of files, checking coding standards, architecture patterns, SOLID principles, testability, and performance concerns in game development projects. Use it before merging code to catch violations and drift.

Consistency Check scans game design documents against an entity registry to detect cross-document inconsistencies such as entities with different stats, items with different values, or formulas with different variables. Use it after writing a GDD and before architecture reviews to catch conflicts early.

Content Audit compares specified content counts from game design documents against implemented content in the codebase, producing a gap report. Use it to see what is planned vs built and identify high-priority missing content.

Create Architecture produces docs/architecture/architecture.md, the master architecture document that translates all approved GDDs into a concrete technical blueprint. It reads engine references, validates decisions, and flags knowledge gaps before sprint planning.

Create Control Manifest produces a flat actionable rules sheet for programmers, extracting what to do and what to avoid from Accepted ADRs, technical preferences, and engine reference docs. Use it after architecture review to keep implementation consistent.

Create Epics translates approved game design documents and architecture into one epic per architectural module, defining scope, governing ADRs, engine risk, and untraced requirements. Use it after architecture review and before creating stories.

Create Stories breaks a single epic into implementable, traceable story files for game development. Run it after /create-epics to decompose each epic into stories with acceptance criteria, TR-IDs, ADR guidance, story types, and test evidence paths.

Day-One Patch scopes, prioritizes, implements, and QA-gates a focused patch for known issues discovered after gold master but before or immediately after public launch. Use it after a gold master build is locked and known bugs or cert feedback require a safe, minimal fix with a rollback plan.

Design Review analyzes a game design document for completeness, internal consistency, implementability, and adherence to project design standards. Use it before handing a design document to programmers to catch gaps and broken references.

Dev Story reads a story file, loads full context (story, GDD, ADR, control manifest), routes to the right programmer agent, implements code and test, and confirms each acceptance criterion. Use after /story-readiness and before /code-review.

Estimate analyzes task complexity, dependencies, historical velocity, and risk factors to produce a structured effort estimate with confidence levels. Use it before committing to a task to get optimistic, expected, and pessimistic day ranges plus a recommended budget and risk breakdown.

Game Design System guides section-by-section authoring of a single game system's GDD, gathering context from existing docs, cross-referencing dependencies, and writing incrementally to file. Use it to design game mechanics with consistency against a systems index and registry.

Game Design System guides Claude Code through an interactive, section-by-section process to author game design documents (GDDs), from Overview to Acceptance Criteria, with user approval at each step. Use it when you need a consistent, technically grounded per-system GDD ready for design review.

Gate Check validates readiness to advance between development phases. It produces a PASS/CONCERNS/FAIL verdict with specific blockers and required artifacts, used when someone asks whether the project is ready to move to the next stage.