Claude Code Game Studios: a simulated game studio with 49 subagents

Everything worth knowing about Donchitos/Claude-Code-Game-Studios: a public template that turns a Claude Code session into a game-development studio with a three-tier hierarchy.

What Claude Code Game Studios is

Claude Code Game Studios (CCGS) is a public GitHub template that turns a single Claude Code session into a coordinated game-development studio: 49 specialized subagents, 73 workflow skills (/ commands), 12 automated validation hooks, and 11 path-based code rules, all organized into a three-tier hierarchy that mimics a real studio.

The core product isn’t an engine, a game, or an installable package: it’s a set of instructions, scripts, and templates that impose structure, quality control, and documentation on an AI-assisted game development project. The repository is flagged as a “Public template” (is_template in the API), which lets it be used directly as a template for a new project.

Origin

Creator: the Donchitos account, a public profile created in November 2023, with a stated location of Melbourne, Australia and 264 followers per the GitHub users API. The repository is that account’s only public repository, so there are no sibling repos from the author to map.
Creation date: February 12, 2026 (created_at from the API). The first public release, v0.1.0 (“First Public Release”), shipped on February 14, 2026 with 48 agents.
Release timeline (releases API): v0.1.0 (February 14, 2026), v0.2.0 “Context Resilience & Systems Decomposition” (February 20), v0.3.0 “/design-system, /map-systems, Status Line, UPGRADING Guide” (March 9), v1.0.0-beta (April 7), and v1.0.0, the first stable release, on May 13, 2026.
Stated narrative in the README (the “Why This Exists” section): the author starts from the premise that solo-developing a game with AI is powerful, but a single chat session has no structure — nothing stops hardcoded magic numbers, nothing enforces the design document, there’s no QA pass or design review that asks whether what got built fits the game’s vision. The proposal is to give the session the structure of a real studio: directors who guard the vision, department leads who own their domains, and specialists who execute, each with defined responsibilities, escalation paths, and quality gates.

Dark-mode cyberpunk visualization of a public GitHub template's origin and release history: a glowing timeline arc with five milestone nodes ascending from a modest first release to a stable version, with Melbourne coordinates projected in the background and a central repository icon pulsing with template metadata.

No launch announcement with a verifiable date and text was found in this investigation across blogs, Twitter/X, Product Hunt, or podcasts. This is flagged as unverified: any claim about launch anecdotes or the author’s personal identity beyond what the API shows.

Philosophy and principles

The README and CONTRIBUTING.md state a philosophy with these verifiable points:

Collaborative, not autonomous. “CCGS is not an auto-pilot system.” Every agent follows a strict five-step protocol: ask before proposing → present 2 to 4 options with pros and cons → the user decides → show a draft → nothing gets written without explicit approval. CONTRIBUTING.md elevates this to a contribution rule: a PR where an agent makes decisions or writes files unilaterally does not get merged.
A real studio hierarchy, not a single generalist assistant. Three tiers: Tier 1 directors (Opus model): creative-director, technical-director, producer; Tier 2 department leads (Sonnet): game-designer, lead-programmer, art-director, audio-director, narrative-director, qa-lead, release-manager, localization-lead; Tier 3 specialists (Sonnet/Haiku): programmers by area, designers, writers, QA, etc. Delegation is vertical (directors → leads → specialists), horizontal consultation is non-binding, conflicts escalate to the shared parent, and cross-department changes are coordinated by producer.

Dark-mode cyberpunk illustration of a collaborative AI protocol rather than autonomous autopilot: a human silhouette at the center holds a glowing decision key, surrounded by a circular sequence of five neon gates — question, options, user choice, draft, explicit approval — with AI agent avatars waiting at each gate until the human approves.

The user keeps every decision. The system contributes structure and questions, not autonomy; the README repeats this explicitly (“You still make every decision”).
A template, not a closed framework. The README makes clear everything is meant to be customized: delete or add agents, edit their prompts, modify skills, add rules, adjust hooks, and choose (or not) the set of engine agents.
Game design grounded in established theory. The README cites as its basis: the MDA framework (Mechanics, Dynamics, Aesthetics), Self-Determination Theory (autonomy, competence, relatedness), flow-state design, Bartle’s player types, and verification-driven development (tests before implementation).
Automated security and transparency. Hooks that validate commits, pushes, assets, and skill changes; permission rules in settings.json that auto-allow safe operations and block dangerous ones (force push, rm -rf, reading .env); and an audit log of subagent invocations (log-agent.sh / log-agent-stop.sh).
Path-based code standards (11 rules): for instance, src/gameplay/** requires data-driven values and delta-time usage; src/core/** requires zero allocations in hot paths; src/networking/** requires server authority and versioned messages; design/gdd/** requires eight mandatory sections.

How it works

Structure verified in the repository tree (main branch):

CLAUDE.md — master configuration that imports by reference the coordination documents, coding standard, context management, and hierarchy.
.claude/agents/ — the 49 agents (Markdown files with YAML frontmatter). Verified in the API listing: includes all three engines with their specialists (godot-specialist + GDScript/C#/shaders/GDExtension; unity-specialist + DOTS/shaders/Addressables/UI; unreal-specialist + GAS/Blueprints/replication/UMG).
.claude/skills/ — 73 skills in subdirectory format (<name>/SKILL.md), one per command.
.claude/hooks/ — 12 bash scripts: validate-commit.sh, validate-push.sh, validate-assets.sh, validate-skill-change.sh, session-start.sh, session-stop.sh, detect-gaps.sh, pre-compact.sh, post-compact.sh, notify.sh, log-agent.sh, log-agent-stop.sh.

Dark-mode cyberpunk security and validation scene for an automated game development framework: twelve hook shields orbit a central terminal, each shaped like a commit, push, asset, skill-change, session-start, session-stop, gap-detection, compaction, notification, or audit-log gate, with neon green checkmarks, amber warnings, and red locks on translucent HUD panels.

.claude/rules/ — 11 path-based rules: ai-code.md, data-files.md, design-docs.md, engine-code.md, gameplay-code.md, narrative.md, network-code.md, prototype-code.md, shader-code.md, test-standards.md, ui-code.md.
.claude/settings.json — hooks, permissions, and security rules; .claude/statusline.sh — status line (context %, model, stage, epic breadcrumb); .claude/agent-memory/ — per-agent memory.
.claude/docs/ — reference documentation: quick-start.md, agent-roster.md, skills-reference.md, hooks-reference.md, rules-reference.md, coordination-rules.md, coding-standards.md, context-management.md, workflow-catalog.yaml (the 7-phase pipeline definition that /help reads), and 41 document templates (GDD, ADR, art bible, test plan, sprint plan, HUD, accessibility, etc.).
Game project folders: src/, assets/, design/, docs/, tests/, tools/, prototypes/ (isolated from src/), and production/ (sprints, milestones, releases).
CCGS Skill Testing Framework/ — optional, self-contained infrastructure to test the framework’s own skills and agents (not the games built with it): catalog.yaml (a master registry tracking coverage of the 73 skills and 49 agents), quality-rubric.md, per-skill and per-agent behavioral specs, and spec templates. The framework’s own README states it can be entirely removed with rm -rf "CCGS Skill Testing Framework" without anything in .claude/ depending on it.

UPGRADING.md — migration guide between versions (v0.3.0 → v0.4.0 → v0.4.1 → v1.0.0-beta → v1.0.0) with lists of which files are safe to overwrite and which must be merged by hand.
SECURITY.md — coordinated vulnerability disclosure policy.

The 7-phase pipeline (per workflow-catalog.yaml and the docs): conceptualization → preproduction (concept, systems, art, UX, architecture) → prototype/vertical slice → sprint production → QA → polish → launch, with verification gates (/gate-check returns PASS/CONCERNS/FAIL) and full | lean | solo review modes configurable during /start, in production/review-mode.txt, or per-run with the --review flag.

Official and semi-official status

No acceptance in any official marketplace. There’s no marketplace listing or endorsement from Anthropic, OpenAI, or any other vendor in the sources consulted. PR #123, which would propose distribution as a Claude Code plugin, was still open at the close of this investigation; if merged, its status would change, but that isn’t a verified fact.
GitHub official-template status: the repository is flagged is_template: true (“Public template”), meaning it’s a public GitHub template that can be instantiated with “Use this template.” That’s a platform feature, not an Anthropic endorsement.
De facto standard: no formal designation in the sources consulted. Its visible adoption (24,000+ stars, 3,500 forks, a Chinese translation with 312 stars, ports to Codex and OpenCode, YouTube coverage in at least five languages) suggests de facto influence as a reference for the “multi-agent game studio” pattern within the Claude Code community, but that’s an inference drawn from the data above, not a documented claim.

The ecosystem

Donchitos has no other public repositories, so the ecosystem is entirely community-driven. A GitHub search by repository name returned 140 results; the relevant and verified ones in this run:

Translations and localizations

pixel-cellar/Claude-Code-Game-Studios — a Chinese-localized version (“48 协同代理管理独立游戏开发的 Claude Code 架构”, a 48-agent version): 312 stars, 69 forks; created and last pushed March 30, 2026. The most visible non-English port found.
moper99/opencode-unity — “Open Code 游戏工作室。翻译自Claude-Code-Game-Studios”: 4 stars.
GodSealS/Claude-Code-Game-Studios — a clone with content from a specific directory of the original: 10 stars.

Ports to other agent tools

merlinhu1/codex-game-studio — a native port to OpenAI Codex, “CLI for AI-assisted game development, scaffolding local projects with studio roles, bounded prompts…”: 50 stars; created May 24, 2026 with activity through August 9, 2026. Announced on r/gamedev (see the community reception section).
RiddleBox/game-studios-opencode — “OpenCode port of Claude Code Game Studios — 48 AI agents for Godot/Unity”: 5 stars.
laok775/hermes-game-dev-studio — “Turn Hermes Agent into a full game development studio - Based on Claude Code Game Studios”: 3 stars.

Variants and derivatives

IdoCohen560/claude-unity-game-studio — “AI-powered Unity game development studio for Claude Code - 49 agents”: 15 stars.
CoralGame/Claude-Code-Game-Studios — a copy with 48 agents and 36 workflows: 19 stars.
AlterLab-IEU/AlterLab_GameForge — “34 production-grade Claude Code skills for indie game development” inspired by the pattern: 31 stars.
zennicalles/lainbridge — “a claude code addon for roblox studio game development” (a Roblox Studio derivative): 1 star.
gwtt/Open-Code-Godot-Studio — “参考 Claude-Code-Game-Studios” (references the original): 18 stars.

Open extensions in the repository itself (public PRs and issues)

PR #123 “feat: plugin distribution, five new hook events, currency pass” (open since August 18, 2026) — plugin distribution for Claude Code, still unmerged.
PR #117 “Full web engine implementation: PixiJS and ThreeJS agents and skills” (open) — adds agents and skills for web engines.
Issue #105 “[Feature] Add libGDX engine specialist support” (open).
Issue #103 “[Feature] how to use this in Codex?” (open) and PR #108 “Codex migration” (open).
PR #110 “docs: add Chinese and Japanese README translations” (open).
PR #121 “Unreal Engine 5.8 Upgrade” (open).

Comparable-pattern projects (verified in the search, not direct derivatives)

htdt/godogen — “Autonomous game development for Godot, Bevy, and Babylon.js with Claude Code and Codex”: 5,543 stars. Generates a complete game repository from a description; instead of running a studio, it automates generation.
contains-studio/agents — “sharing current agents in use” (an AI agency): 12,407 stars.
msitarzewski/agency-agents — “A complete AI agency at your fingertips”: 147,287 stars.

Note: the curated list hesreallyhim/awesome-claude-code (52,806 stars) does not include Claude-Code-Game-Studios in its current README (verified by searching the content).

Repo numbers

Measured: August 22, 2026, GitHub API.

Metric	Value
Stars	24,411
Forks	3,489
Real subscribers	179
Open issues per the API	58
Issues + open PRs (repo page)	34 + 24
Primary language	Shell
License	MIT
Created	February 12, 2026
Last push to `main`	May 21, 2026
Latest release	`v1.0.0`, May 13, 2026
Total releases	5 (`v0.1.0`, `v0.2.0`, `v0.3.0`, `v1.0.0-beta`, `v1.0.0`)

Caveats: the API’s open_issues_count mixes issues and pull requests; the repository page separates them (34 issues, 24 open PRs), which matches the total of 58. watchers_count mirrors the star count, so subscribers_count (179) is reported as real subscribers. The API’s top contributors list shows Donchitos with 38 contributions and lists no other contributors with commit contributions (a solo-maintained project, as CONTRIBUTING.md confirms: “solo-maintained project”).

How to contribute

CONTRIBUTING.md documents the full process:

What’s accepted: bug fixes, new skills that fill a genuine workflow gap, improvements to existing agents/skills/hooks, documentation fixes. “PRs that don’t fit the framework’s direction will be closed without lengthy explanation.”
What’s not accepted: feature requests submitted as a PR (“Open an issue instead”). And, explicitly, the repo is not a place to store the games built with it: GDDs, ADRs, PRDs, game concepts, level designs, or narrative generated by CCGS for one’s own project don’t get merged; “keep those in your own repo.”
Non-negotiable technical rules: skills must use the mandatory subdirectory format with YAML frontmatter (name, description, argument-hint, allowed-tools, model); hooks must use grep -E and never grep -P, with fallbacks for missing jq/python; agents require a mandatory “Collaboration Protocol” section; any reference documentation must be updated alongside the change.
Collaborative principle: every contribution must follow the five-step “Question → Options → Decision → Draft → Approval → Write” protocol; an agent that decides or writes unilaterally doesn’t get merged.
Compatibility: must work on Windows (Git Bash), macOS, and Linux; any platform-specific dependency will be rejected; “When in doubt, test on Windows.”
The framework’s own testing harness: the CCGS Skill Testing Framework/ folder, with /skill-test (static / spec / category / audit) and /skill-improve, lets you test the framework’s own skills and agents against specs and rubrics.

Quick-start guide

Installation and first run

Prerequisites documented in the README: Git, Claude Code installed (npm install -g @anthropic-ai/claude-code), and, recommended, jq (hook validation) and Python 3 (JSON validation). Every hook fails gracefully if an optional tool is missing: “nothing breaks, you just lose validation.”

Exact steps from the README:

git clone https://github.com/Donchitos/Claude-Code-Game-Studios.git my-game
cd my-game
claude

In the Claude Code session, run /start. The system asks where you’re starting from (no idea, vague concept, clear design, existing work) and routes you to the right flow “without assumptions.” Direct alternatives: /brainstorm (explore ideas from scratch), /setup-engine godot 4.6 (configure the engine if you already know it), /project-stage-detect (analyze an existing project).

Common workflows

Documented in .claude/docs/quick-start.md (four paths depending on your starting point):

“No idea what to build”: /start generates 3 concepts; /setup-engine sets up CLAUDE.md; /design-review validates the concept; /map-systems decomposes it into systems; /design-system <system> drafts GDDs; /prototype <core-mechanic> validates the idea before the GDDs (1–3 days); /sprint-plan new and start building.
“I know what I want to build”: /setup-engine <engine> <version> → delegate game pillars to creative-director → /map-systems → /design-system <system> → /architecture-decision → first milestone in production/milestones/ → /sprint-plan new.
“I know the game but not the engine”: /setup-engine with no arguments asks about needs (2D/3D, platforms, team size, language) and recommends an engine.
“I have an existing project”: /start or /project-stage-detect analyzes what exists and what’s missing; /adopt audits existing GDDs/ADRs/stories and builds a numbered migration plan without overwriting; /gate-check shows the current position.

Dark-mode cyberpunk visualization of a seven-phase game development pipeline: a glowing track moves from conceptualization through preproduction, prototype, vertical slice, production sprints, QA, polish and launch, with each phase represented by a distinct neon station, and between phases, gate checkpoints display tri-color status lights in green, amber and red.

Per-story execution flows: /story-readiness validates a story before it’s picked up → /dev-story implements it, routing to the right programmer → /story-done verifies acceptance criteria when closing it.

Essential configuration

CLAUDE.md — master configuration (~60 lines): chosen engine, language, stack, and references to the coordination documents. Largely filled in via /setup-engine.
.claude/settings.json — hooks, permissions (auto-allow for safe operations, blocking force push / rm -rf / reading .env), and security rules.
production/review-mode.txt — review intensity: full (all director gates), lean (phase gates only), or solo (none). Can be overridden per-run with --review solo on any skill.
.claude/docs/technical-preferences.md — project-specific standards (naming conventions, performance budgets, engine defaults); filled in by /setup-engine.
.claude/docs/workflow-catalog.yaml — the 7-phase pipeline definition; read by /help to answer “what do I do now?”

Common pitfalls and fixes

Skills not showing up: skills must live in subdirectory format (.claude/skills/<name>/SKILL.md); “Flat .md files are silently ignored by Claude Code.” This is the documented cause of the “I cant find the skills” discussion (resolved by the asker themselves) and of issues about counting 72 vs. 73 skills.
Windows / Git Bash: hooks must use grep -E and never grep -P (Perl regex breaks on Windows Git Bash); fallbacks are required for systems missing jq or python, and a fast exit (exit 0) is required when a hook doesn’t apply. Primary development and testing happens on Windows 10; macOS/Linux “should run” but desktop notifications (notify.sh, PowerShell) are a no-op outside Windows.
Stale agent/skill counts: the repository’s README has drifted from the actual tree (issues ask for agent counts to be updated 48→49, skills 68→72). The main tree ships 49 agents, 73 skills, 12 hooks, and 11 rules; the repo description still says “72 workflow skills.”
Cross-version migrations: UPGRADING.md distinguishes files “safe to overwrite” from “merge carefully”; for older versions there’s a git-remote-merge strategy (recommended), cherry-pick, or manual copy.
Maintenance: an issue (July 28, 2026) asks “Is this project still maintained?”; the last push to main was May 21, 2026 (three months before this measurement).
Token cost: discussions about “tips on saving token useage” and credit-error reports reflect that heavy use of Opus-tier agents at director gates burns through context and credits quickly.

Dark-mode cyberpunk diagram of path-based code standards governing a game project: a luminous file tree branches into eleven rule plaques, each hovering beside a folder — gameplay, core, networking, design, narrative, shaders, UI, tests, prototypes, AI code, and data files — with neon cyan and violet circuit patterns running along the branches.

Integrations and migration

With Claude Code: this is the native integration; everything (skills, subagents, hooks, rules, permissions, statusline) uses first-class Claude Code mechanisms. There are no external network dependencies at runtime.
Game engines: dedicated agent sets for Godot 4 (GDScript, C#, shaders, GDExtension), Unity (DOTS/ECS, shaders/VFX, Addressables, UI Toolkit), and Unreal Engine 5 (GAS, Blueprints, replication, UMG/CommonUI). /setup-engine can search for current engine docs on the web if the version exceeds the LLM’s knowledge. An open PR covers web engines (PixiJS/ThreeJS) and a feature request covers libGDX.
With CI: /test-setup generates the test framework scaffold and the project engine’s CI pipeline; /test-flakiness detects flaky tests from CI history.
Migration to other agent tools: the community has ported the system to OpenAI Codex (merlinhu1/codex-game-studio, 50 stars), OpenCode (RiddleBox/game-studios-opencode), and Hermes Agent (laok775/hermes-game-dev-studio); the repo itself has PR #108 “Codex migration” and issue #103. Migrating from an existing game project uses /adopt (brownfield audit + a numbered plan without overwriting).
CCGS version migration: see UPGRADING.md (three strategies, per-version file lists).

How the community received it

Concrete anchors gathered in this investigation. The general tone across forums is high curiosity and moderate skepticism, with debates about maintenance, cost, and whether the result is a “studio” or “a long prompt.”

Hacker News

No dedicated main thread about the repository was found. A mention in an unrelated thread: in “Adventure Game Studio: OSS software for creating adventure games” (404 points, 92 comments), user mijustin comments: “Lots of kids still making games with engines like GameMaker Studio! I think lots of kids will start playing around with Claude Code in this way as well.” — without naming the repo. HN reception is minimal to nonexistent as of this measurement; adoption of the project happens outside HN (YouTube, Reddit, GitHub).

Reddit (via the arctic-shift archive API; Reddit’s direct JSON is blocked to bots)

r/gamedev, “Just ported Claude Code Game Studio to Codex”: the author presents their port, merlinhu1/codex-game-studio. PhilippTheProgrammer asks “How many games were made with this so far?”; the author replies “a little hard to describe. Like a template to replace most of human employees using AI to make video games” (−2 points); Ok_Hippo_1882 (+4): “I feel like at that point, it’s less trouble to just do everything manually lol.”
r/gamedev, “OpenCode Clone of Claude Code Game Studios”: Ralph_Natas (+3) “I avoid all those problems by having a functional brain and writing code myself”; the author replies “It’s a tool, nothing more, nothing less.”
r/ClaudeAI, “I rebuilt my game studio website with Claude Code and I think web dev is cooked”: a typical subreddit debate; l_lllas (+18) “i can probably build ur game using claude does that mean your profession is cooked too?”, pastafreakingmania (+12) criticizes that the generated site is invisible to bots.
r/ClaudeAI, two parallel scaffolds with smaller scope than CCGS (42 and 37 agents), a sign the pattern is being replicated.

GitHub Discussions

“v1.0.0 is out — thanks, what’s next, and a roadmap poll” and “Roadmap poll — what should v1.x prioritise?”
“Any real game output?” — a direct community question about whether the framework has produced real games (no cited answer).
“Great concept, but the implementation doesn’t match the pitch…yet!” — the most visible constructive criticism.
“I cant find the skills” (resolved by the asker) and “Should we create godot-csharp-specialist?” (already exists in the current tree).

YouTube

“AIエージェント49体に”ゲーム会社”を経営させる【Claude Code Game Studios】” — channel クロノITチャンネル: 27,925 views, 15:40. The highest-viewed video found.
“게임 개발자에게 깊은 조의를 표합니다 - 클로드 코드 게임 스튜디오” — channel 얌얌코딩: 6,242 views.
“Crea juegos usando Claude Game Studio (sin necesidad de programar)” — channel YanAITalk: 883 views, 35:30. The longest tutorial found, in Spanish.
Coverage in at least five languages (English, Japanese, Chinese, Korean, Spanish), with Japanese as the dominant video market.

Product Hunt / Twitter / podcasts / newsletters: no Product Hunt page, X launch thread, or podcast/newsletter appearance with a verifiable source was found in this investigation.

Claude Code Game Studios vs. other approaches

Project	What it is	Stars	Key difference from CCGS
`htdt/godogen`	Autonomous game development for Godot/Bevy/Babylon.js with Claude Code and Codex	5,543	Generates a complete game repository autonomously (describe a game → the agent builds it). CCGS is collaborative and human-in-control; godogen aims for autonomy.
`contains-studio/agents`	An AI “agency” agent catalog	12,407	An agency agent library (frontend, copywriting, etc.), not game-specific or hierarchical as a studio.
`msitarzewski/agency-agents`	“A complete AI agency at your fingertips”	147,287	A generic multi-agent agency framework (design, marketing, etc.); CCGS is focused exclusively on the game-development pipeline.
`merlinhu1/codex-game-studio`	A port of CCGS to OpenAI Codex	50	Same studio pattern, native to Codex instead of Claude Code.
`pixel-cellar/Claude-Code-Game-Studios`	A Chinese localization of CCGS (48 agents)	312	Translation/expansion into Chinese; same system.
`hesreallyhim/awesome-claude-code`	A curated list of Claude Code resources	52,806	Not a competitor: it’s a resource list that does not include CCGS (verified in the README).

Caveat: none of these figures measure the quality, maintenance, or compatibility of each derivative; they’re just GitHub API data as of the measurement date.

Use cases

A solo indie developer using Claude Code: the central case. The 49-agent hierarchy and 73 skills mimic the team a single developer can’t afford, with /start assuming nothing. The key constraint is that it’s a collaborative system: the developer still makes every decision.
Small game teams (2–3 people): explicit interest is documented in discussions; --review lean mode reduces the weight of director gates for teams that don’t want the full panel.
Brownfield projects (games already in progress): /adopt audits existing GDDs/ADRs/stories and generates a numbered migration plan without overwriting, and /reverse-document generates design/architecture documentation from existing code.
Those working with Godot 4, Unity, or Unreal Engine 5: specialized agent sets per engine with sub-specialists. /setup-engine searches for current engine documentation if the version exceeds the LLM’s knowledge.
Game designers who don’t want to depend solely on the programmer: design agents (game-designer, systems-designer, economy-designer, level-designer, ux-designer) and skills like /design-system, /art-bible, /balance-check cover the design and content side.
QA and quality control: qa-lead/qa-tester agents and skills like /qa-plan, /smoke-check, /soak-test, /regression-suite form a complete QA cycle.
Non-English communities: the Chinese translation (312 stars) and YouTube coverage in Japanese, Korean, Chinese, and Spanish extend reach to Spanish-speaking and Asian developers.

Honest limitations: no finished, verified game built with the framework was found published in the sources consulted; the last push was May 2026 and there’s an open issue asking about maintenance; and heavy use of Opus agents at director gates carries a real context and credit cost.

Resources

Repository: https://github.com/Donchitos/Claude-Code-Game-Studios
Quick start: https://github.com/Donchitos/Claude-Code-Game-Studios/blob/main/.claude/docs/quick-start.md
Upgrade guide: https://github.com/Donchitos/Claude-Code-Game-Studios/blob/main/UPGRADING.md
Contributing: https://github.com/Donchitos/Claude-Code-Game-Studios/blob/main/CONTRIBUTING.md
Skill Testing Framework: https://github.com/Donchitos/Claude-Code-Game-Studios/tree/main/CCGS%20Skill%20Testing%20Framework
Video (Japanese, 27,925 views): https://youtu.be/dAYlMrcaO64
Video (Spanish, 883 views): https://youtu.be/kpQUoRLT3qw
GitHub Discussions: https://github.com/Donchitos/Claude-Code-Game-Studios/discussions
Sponsor: https://github.com/sponsors/Donchitos

Note: This article combines official documentation, the GitHub API, Reddit (via the arctic-shift archive), Hacker News, and YouTube, gathered on August 22, 2026. Figures change over time.