Donchitos/Claude-Code-Game-StudiosPublic

Turn Claude Code into a full game dev studio — 49 AI agents, 75 workflow skills, and a complete coordination system mirroring real studio hierarchy.

AI summary: A coordinated multi-agent framework that transforms Claude Code into a complete virtual game development studio.

Stars
40.4K
+599 today
Forks
5.3K
Watchers
273
Open issues
49
Open PRs
46
Contributors
~1
Commits
44
Branches
1
Views (30d)
7

ShellMITCreated Feb 12, 2026Last push 11d agoLatest release v1.3.0+1.5K stars this week+13.4K this month

Quick answers

What is Claude-Code-Game-Studios?
A coordinated multi-agent framework that transforms Claude Code into a complete virtual game development studio.
What does Claude-Code-Game-Studios do?
Claude Code Game Studios structures a single AI coding session into a simulated game development studio featuring 49 distinct agent roles and 73 workflow skills. It implements a hierarchical coordination system that mirrors real-world studio departments, from narrative design to engine programming. The framework enforces strict operational rules and utilizes hooks to maintain context and direct communication between these simulated roles. By providing specific prompts and workflow definitions, it prevents the AI from losing focus during complex game development tasks. This structured approach allows developers to tackle ambitious game projects by effectively managing the AI's cognitive load.
Who is Claude-Code-Game-Studios for?
Solo game developers, technical designers, and programmers utilizing Claude Code who want to structure large-scale game development tasks. Familiarity with standard game engine architectures is expected.
How do I get started with Claude-Code-Game-Studios?
Follow the setup instructions in the .claude directory to initialize the studio environment.
How popular is Claude-Code-Game-Studios on GitHub?
Donchitos/Claude-Code-Game-Studios has 40,403 stars and 5,288 forks on GitHub, and gained 1,539 stars in the last 7 days.
What license does Claude-Code-Game-Studios use?
Donchitos/Claude-Code-Game-Studios is released under the MIT license.

Star history

since Jul 28, 2026
020K40KJul 2026Sep 2026Oct 2026Nov 2026
40.4K stars as of Nov 21, 2026. Measured daily since Jul 28, 2026; GitHub no longer exposes earlier star timestamps.

Update history

4 recorded
  • Nov 21, 2026Description changed from "Turn Claude Code into a full game dev studio — 49 AI agents, 72 workflow skills, and a complete coordination system mirr" to "Turn Claude Code into a full game dev studio — 49 AI agents, 75 workflow skills, and a complete coordination system mirr".
  • Nov 17, 2026New release v1.3.0 (previously v1.2.0).
  • Oct 27, 2026New release v1.2.0 (previously v1.1.3).
  • Oct 16, 2026New release v1.1.3 (previously v1.1.2).

Contribution activity

commits per day, last 52 weeks
NovDecJanFebMarAprMayJunJulAugSepOctNovMonWedFri2025-11-23: 0 commits2025-11-24: 0 commits2025-11-25: 0 commits2025-11-26: 0 commits2025-11-27: 0 commits2025-11-28: 0 commits2025-11-29: 0 commits2025-11-30: 0 commits2025-12-01: 0 commits2025-12-02: 0 commits2025-12-03: 0 commits2025-12-04: 0 commits2025-12-05: 0 commits2025-12-06: 0 commits2025-12-07: 0 commits2025-12-08: 0 commits2025-12-09: 0 commits2025-12-10: 0 commits2025-12-11: 0 commits2025-12-12: 0 commits2025-12-13: 0 commits2025-12-14: 0 commits2025-12-15: 0 commits2025-12-16: 0 commits2025-12-17: 0 commits2025-12-18: 0 commits2025-12-19: 0 commits2025-12-20: 0 commits2025-12-21: 0 commits2025-12-22: 0 commits2025-12-23: 0 commits2025-12-24: 0 commits2025-12-25: 0 commits2025-12-26: 0 commits2025-12-27: 0 commits2025-12-28: 0 commits2025-12-29: 0 commits2025-12-30: 0 commits2025-12-31: 0 commits2026-01-01: 0 commits2026-01-02: 0 commits2026-01-03: 0 commits2026-01-04: 0 commits2026-01-05: 0 commits2026-01-06: 0 commits2026-01-07: 0 commits2026-01-08: 0 commits2026-01-09: 0 commits2026-01-10: 0 commits2026-01-11: 0 commits2026-01-12: 0 commits2026-01-13: 0 commits2026-01-14: 0 commits2026-01-15: 0 commits2026-01-16: 0 commits2026-01-17: 0 commits2026-01-18: 0 commits2026-01-19: 0 commits2026-01-20: 0 commits2026-01-21: 0 commits2026-01-22: 0 commits2026-01-23: 0 commits2026-01-24: 0 commits2026-01-25: 0 commits2026-01-26: 0 commits2026-01-27: 0 commits2026-01-28: 0 commits2026-01-29: 0 commits2026-01-30: 0 commits2026-01-31: 0 commits2026-02-01: 0 commits2026-02-02: 0 commits2026-02-03: 0 commits2026-02-04: 0 commits2026-02-05: 0 commits2026-02-06: 0 commits2026-02-07: 0 commits2026-02-08: 0 commits2026-02-09: 0 commits2026-02-10: 0 commits2026-02-11: 0 commits2026-02-12: 0 commits2026-02-13: 1 commit2026-02-14: 2 commits2026-02-15: 0 commits2026-02-16: 0 commits2026-02-17: 0 commits2026-02-18: 0 commits2026-02-19: 0 commits2026-02-20: 1 commit2026-02-21: 0 commits2026-02-22: 0 commits2026-02-23: 0 commits2026-02-24: 0 commits2026-02-25: 0 commits2026-02-26: 0 commits2026-02-27: 0 commits2026-02-28: 0 commits2026-03-01: 0 commits2026-03-02: 0 commits2026-03-03: 0 commits2026-03-04: 0 commits2026-03-05: 0 commits2026-03-06: 0 commits2026-03-07: 0 commits2026-03-08: 0 commits2026-03-09: 2 commits2026-03-10: 1 commit2026-03-11: 1 commit2026-03-12: 3 commits2026-03-13: 3 commits2026-03-14: 0 commits2026-03-15: 1 commit2026-03-16: 6 commits2026-03-17: 0 commits2026-03-18: 0 commits2026-03-19: 0 commits2026-03-20: 0 commits2026-03-21: 0 commits2026-03-22: 0 commits2026-03-23: 0 commits2026-03-24: 0 commits2026-03-25: 1 commit2026-03-26: 0 commits2026-03-27: 2 commits2026-03-28: 1 commit2026-03-29: 2 commits2026-03-30: 0 commits2026-03-31: 0 commits2026-04-01: 0 commits2026-04-02: 0 commits2026-04-03: 0 commits2026-04-04: 0 commits2026-04-05: 0 commits2026-04-06: 1 commit2026-04-07: 3 commits2026-04-08: 0 commits2026-04-09: 0 commits2026-04-10: 1 commit2026-04-11: 0 commits2026-04-12: 0 commits2026-04-13: 0 commits2026-04-14: 0 commits2026-04-15: 0 commits2026-04-16: 0 commits2026-04-17: 0 commits2026-04-18: 0 commits2026-04-19: 0 commits2026-04-20: 0 commits2026-04-21: 0 commits2026-04-22: 0 commits2026-04-23: 0 commits2026-04-24: 1 commit2026-04-25: 0 commits2026-04-26: 0 commits2026-04-27: 0 commits2026-04-28: 0 commits2026-04-29: 0 commits2026-04-30: 0 commits2026-05-01: 0 commits2026-05-02: 2 commits2026-05-03: 1 commit2026-05-04: 0 commits2026-05-05: 0 commits2026-05-06: 0 commits2026-05-07: 0 commits2026-05-08: 0 commits2026-05-09: 0 commits2026-05-10: 0 commits2026-05-11: 0 commits2026-05-12: 0 commits2026-05-13: 1 commit2026-05-14: 0 commits2026-05-15: 0 commits2026-05-16: 0 commits2026-05-17: 0 commits2026-05-18: 0 commits2026-05-19: 0 commits2026-05-20: 0 commits2026-05-21: 0 commits2026-05-22: 0 commits2026-05-23: 0 commits2026-05-24: 0 commits2026-05-25: 0 commits2026-05-26: 0 commits2026-05-27: 0 commits2026-05-28: 0 commits2026-05-29: 0 commits2026-05-30: 0 commits2026-05-31: 0 commits2026-06-01: 0 commits2026-06-02: 0 commits2026-06-03: 0 commits2026-06-04: 0 commits2026-06-05: 0 commits2026-06-06: 0 commits2026-06-07: 0 commits2026-06-08: 0 commits2026-06-09: 0 commits2026-06-10: 0 commits2026-06-11: 0 commits2026-06-12: 0 commits2026-06-13: 0 commits2026-06-14: 0 commits2026-06-15: 0 commits2026-06-16: 0 commits2026-06-17: 0 commits2026-06-18: 0 commits2026-06-19: 0 commits2026-06-20: 0 commits2026-06-21: 0 commits2026-06-22: 0 commits2026-06-23: 0 commits2026-06-24: 0 commits2026-06-25: 0 commits2026-06-26: 0 commits2026-06-27: 0 commits2026-06-28: 0 commits2026-06-29: 0 commits2026-06-30: 0 commits2026-07-01: 0 commits2026-07-02: 0 commits2026-07-03: 0 commits2026-07-04: 0 commits2026-07-05: 0 commits2026-07-06: 0 commits2026-07-07: 0 commits2026-07-08: 0 commits2026-07-09: 0 commits2026-07-10: 0 commits2026-07-11: 0 commits2026-07-12: 0 commits2026-07-13: 0 commits2026-07-14: 0 commits2026-07-15: 0 commits2026-07-16: 0 commits2026-07-17: 0 commits2026-07-18: 0 commits2026-07-19: 0 commits2026-07-20: 0 commits2026-07-21: 0 commits2026-07-22: 0 commits2026-07-23: 0 commits2026-07-24: 0 commits2026-07-25: 0 commits2026-07-26: 0 commits2026-07-27: 0 commits2026-07-28: 0 commits2026-07-29: 0 commits2026-07-30: 0 commits2026-07-31: 0 commits2026-08-01: 0 commits2026-08-02: 0 commits2026-08-03: 0 commits2026-08-04: 0 commits2026-08-05: 0 commits2026-08-06: 0 commits2026-08-07: 0 commits2026-08-08: 0 commits2026-08-09: 0 commits2026-08-10: 0 commits2026-08-11: 0 commits2026-08-12: 0 commits2026-08-13: 0 commits2026-08-14: 0 commits2026-08-15: 0 commits2026-08-16: 0 commits2026-08-17: 0 commits2026-08-18: 0 commits2026-08-19: 0 commits2026-08-20: 0 commits2026-08-21: 0 commits2026-08-22: 0 commits2026-08-23: 0 commits2026-08-24: 0 commits2026-08-25: 0 commits2026-08-26: 0 commits2026-08-27: 0 commits2026-08-28: 0 commits2026-08-29: 0 commits2026-08-30: 0 commits2026-08-31: 0 commits2026-09-01: 0 commits2026-09-02: 0 commits2026-09-03: 0 commits2026-09-04: 0 commits2026-09-05: 0 commits2026-09-06: 0 commits2026-09-07: 0 commits2026-09-08: 0 commits2026-09-09: 0 commits2026-09-10: 0 commits2026-09-11: 0 commits2026-09-12: 0 commits2026-09-13: 0 commits2026-09-14: 0 commits2026-09-15: 0 commits2026-09-16: 0 commits2026-09-17: 0 commits2026-09-18: 0 commits2026-09-19: 0 commits2026-09-20: 0 commits2026-09-21: 0 commits2026-09-22: 0 commits2026-09-23: 1 commit2026-09-24: 1 commit2026-09-25: 0 commits2026-09-26: 0 commits2026-09-27: 0 commits2026-09-28: 0 commits2026-09-29: 1 commit2026-09-30: 0 commits2026-10-01: 0 commits2026-10-02: 0 commits2026-10-03: 0 commits2026-10-04: 0 commits2026-10-05: 0 commits2026-10-06: 0 commits2026-10-07: 0 commits2026-10-08: 1 commit2026-10-09: 0 commits2026-10-10: 0 commits2026-10-11: 0 commits2026-10-12: 0 commits2026-10-13: 0 commits2026-10-14: 0 commits2026-10-15: 0 commits2026-10-16: 0 commits2026-10-17: 0 commits2026-10-18: 0 commits2026-10-19: 1 commit2026-10-20: 0 commits2026-10-21: 0 commits2026-10-22: 0 commits2026-10-23: 0 commits2026-10-24: 0 commits2026-10-25: 0 commits2026-10-26: 0 commits2026-10-27: 0 commits2026-10-28: 0 commits2026-10-29: 0 commits2026-10-30: 0 commits2026-10-31: 0 commits2026-11-01: 0 commits2026-11-02: 0 commits2026-11-03: 0 commits2026-11-04: 0 commits2026-11-05: 0 commits2026-11-06: 0 commits2026-11-07: 0 commits2026-11-08: 0 commits2026-11-09: 1 commit2026-11-10: 0 commits2026-11-11: 0 commits2026-11-12: 0 commits2026-11-13: 0 commits2026-11-14: 0 commits2026-11-15: 0 commits2026-11-16: 0 commits2026-11-17: 0 commits2026-11-18: 0 commits2026-11-19: 0 commits2026-11-20: 0 commits2026-11-21: 0 commits
43 commits in the last yearLessMore

Signals and awards

derived from tracked data
  • Widely adopted

    40,403 stars

  • High momentum

    +599 stars today

  • Well documented

    High community health score

  • Permissive license

    MIT

  • Continuous integration

    Automated checks passing

  • Repeat trending

    9 trending appearances

What Claude-Code-Game-Studios does

Claude Code Game Studios structures a single AI coding session into a simulated game development studio featuring 49 distinct agent roles and 73 workflow skills. It implements a hierarchical coordination system that mirrors real-world studio departments, from narrative design to engine programming. The framework enforces strict operational rules and utilizes hooks to maintain context and direct communication between these simulated roles. By providing specific prompts and workflow definitions, it prevents the AI from losing focus during complex game development tasks. This structured approach allows developers to tackle ambitious game projects by effectively managing the AI's cognitive load.

Solo game developers, technical designers, and programmers utilizing Claude Code who want to structure large-scale game development tasks. Familiarity with standard game engine architectures is expected.

  • Role-Based Agents: Defines 49 specialized agent personas covering every aspect of game development from art direction to QA.
  • Workflow Coordination: Implements 73 specific skills to route tasks between the appropriate simulated departments.
  • Context Preservation Rules: Enforces 11 strict operational rules to ensure the AI maintains architectural consistency across long sessions.
  • Lifecycle Hooks: Utilizes 12 lifecycle hooks to trigger specific agent behaviors during different phases of the development process.
  • Engine Agnosticism: Provides structured workflows applicable to major engines including Unity, Godot, and Unreal Engine.

Where teams use it

Indie Game Prototyping

Solo developers utilize the framework to rapidly generate gameplay mechanics and architectural foundations across different game engines.

Narrative Systems Design

Game designers engage specific narrative agents to structure branching dialogue trees and complex quest logic.

Asset Pipeline Automation

Technical artists automate the conversion and optimization of game assets by coordinating the appropriate technical agents.

Complex Refactoring

Programmers offload the restructuring of intricate game state managers to specialized engine programming agents.

Getting started: Follow the setup instructions in the .claude directory to initialize the studio environment.

README

main branch

Claude Code Game Studios

Describe a game. Claude Code asks a few questions, writes a one-page brief, and builds a playable browser game from it.
Then you change it, grow it and finish it, one step at a time.

MIT License Built for Claude Code Buy Me a Coffee GitHub Sponsors


Make me a game

Open Claude Code in a copy of this repository and say what you want:

/prototype a fishing game where the rare fish only bite at dusk
  1. A few questions. One round, picked from the genre: the choices that shape the game, how it should feel, how it looks, how hard it is, the goal. Each has a usual answer, so "you pick" works. A vague idea ("a racing game") gets two or three one-line pitches to choose from first.
  2. A one-page brief. design/game-brief.md: your words kept as you typed them, the look, the first minute, the challenge, the features and what is left for later. You read it and say Build it, or change something first.
  3. A first build. A browser game in prototypes/<name>/ that opens with a double-click: every figure drawn, no emoji art, no copy of another game, and not trivially easy. Your session builds it at its own effort ("build it at medium" is cheaper and thinner).
  4. Checked before you get it. A few scripted key presses in a headless browser show it opens with no errors and responds; text that is too small, overlapping or off screen and screens that freeze are fixed in one round; and every line of the brief is marked built, missing or broken from the screenshots and the code, or not assessed when it could not be checked. Your play is the real test: the handover card says what passed, what is still broken and what was guessed, and ends "Not yet played by a person".

Then it is yours to play. After that:

  • Change it by asking. Each change is checked against what you said to keep and to avoid, and each one you accept is a checkpoint you can go back to. Ask to tune it and it gains a tweak panel with a slider for every value.
  • Share it. A clean copy without the panel and the working files, ready for itch.io or a link.
  • Grow it. When you like it, it becomes a real web project (Vite and TypeScript, its values in data files, tests and a build), and you add to it one feature a sitting: say the next feature, and it is built, checked and committed. After every feature the same seeded run is played again and any change is shown to you. Stories (/create-stories, /dev-story, /story-done) only when you ask for them.
  • Finish it. /cut proposes what to cut and a polish list, and a date when the game is to sell.

Already have a browser game? /prototype --from <path> brings a copy in as it is, so it can be changed and grown the same way.

What it has been shown to do

  • The first build. In a blind comparison on three game ideas, the brief made from its questions was picked over a hand-written brief all three times. All six games built from the two kinds of brief were ones the tester said they would build on, so on the games themselves the two kinds of brief tied.
  • Growing. One game was grown from its first build through six stories into a game the tester would keep building. That is one game, not yet a pattern.
  • Not yet shown: the engine route (Godot, Unity, Unreal) and deepening one system with a design document. Both are built and pass the framework's own checks, but neither has had a test like the two above.

The games themselves are deliberately not shipped here: this is a template you clone to start your own project, and somebody else's game in your repo is clutter, not evidence.


Table of Contents


Getting Started

Prerequisites

  • Git
  • Claude Code — the native installer is recommended (npm install -g @anthropic-ai/claude-code also works, on Node.js 22+)
  • Python 3 — reads project.yaml for every skill and hook; without it every setting silently falls back to its default
  • Bash — runs every hook; built into macOS and Linux, and on Windows it comes with Git for Windows. Without it on Windows the hooks skip themselves, and session start says their checks are off
  • Chrome, Edge or Chromium — /prototype plays and screenshots each game in it; without one, those checks say they were not assessed
  • Recommended: Node.js (to grow a game into a web project, for a 3D game's three.js, and for the web engine's build and tests) and jq (for hook validation)

Hooks fail gracefully if optional tools are missing — you just lose validation — with one deliberate exception: a commit that stages data JSON is blocked when there is no Python to validate it.

Setup

  1. Clone or use as template:

    git clone https://github.com/Donchitos/Claude-Code-Game-Studios.git my-game
    cd my-game
  2. Open Claude Code in the project's root folder (the one holding CLAUDE.md and project.yaml) and start a session:

    claude

    Starting it in a subfolder such as src/ skips the project's hooks, deny rules and ask-first permission mode.

  3. Type /prototype and your idea, or run /start, which asks where you are (make me a game, an idea or none yet, clear design, existing work) and guides you to the right workflow. No assumptions.

    Other ways in:

    • /next-step — names the one next step wherever you are
    • /brainstorm — explore game ideas from scratch
    • /setup-engine godot 4.7 — configure an engine if you already know you want one
    • /project-stage-detect — analyze an existing project

Engines

Engine engine.name Code root Notes
Web Web src/ The default for a new project. A one-shot needs no engine at all; a grown game is a web project. /setup-engine web offers a starter: nothing extra, three.js, Phaser or PixiJS
Godot 4 Godot src/ GDScript, C# or GDExtension
Unity Unity Assets/ Unity compiles only Assets/ and Packages/
Unreal Engine 5 Unreal Source/<Module>/ C++ and Blueprints

/setup-engine pins the engine version and writes its reference docs (docs/engine-reference/<engine>/). With no engine set, /prototype builds in the browser first; you pick an engine after you have played the game. Each engine's folders and default commands come from one table, .claude/engines/engines.tsv. If your code or tests live somewhere else, set engine.code_root or engine.test_root in project.yaml.

Configuration

project.yaml at the repo root is the single source of truth for how the studio behaves on your project — engine, naming conventions, and a modes block that controls how much process every skill enforces. /start writes it for you; you rarely need to hand-edit it.

The one question that matters most is modes.rigor — minimal, standard, or full. It's a single front door over six separate knobs (workflow — which GDD sections are required, docs.density, qa.level, story_granularity, review_mode — how many director agents review your work, and team.size), so /start asks it once instead of six times:

  • minimal (default) — the light path. No GDDs required, terse docs, minimal QA evidence, solo review. /prototype (questions, a brief, a first build) → play and change it → grow it on PROCEED → one feature a sitting: name it, and it is built, checked and committed. Stories (/create-stories → /dev-story ↔ /story-done) only when you ask.
  • standard — 5 required GDD sections, balanced doc depth, standard QA evidence, lean review.
  • full — all 8 GDD sections, thorough docs, full QA evidence on every story type, full director review.

minimal is the default because the heavier tier costs more to reach working code without producing a better result, and gives nothing back when someone new picks the project up. Raise it in one /project-settings call when your project grows — /next-step and /gate-check will suggest it when they see the signs.

Two escape hatches keep one setting from being a blunt instrument. system_overrides holds a single system to a higher standard than the rest of the project — your combat system gets the full treatment while everything else stays light. testing.strict sets, per test type (logic, integration, visual, UI, config), whether missing evidence blocks a story or merely warns.

Any of the six underlying knobs can still be set individually if you want a mix (e.g. workflow: full with docs.density: terse — comprehensive but compact). Two of them — review_mode (full / lean / solo) and team.size — are also personal: rigor sets the team-wide default, but you can override them per-developer in a gitignored project.local.yaml without touching the shared config. modes.automation (how often the AI pauses to ask before it acts) sits outside rigor and is likewise personally overridable. project.goal (a jam game, a hobby, a game to sell, and so on) is what you want from the game; /start guesses it, and /cut reads it.

View or change any setting with the /project-settings skill:

/project-settings                              # view effective config
/project-settings modes.review_mode            # view one setting
/project-settings modes.rigor=full             # write to project.yaml (team-wide)
/project-settings --local modes.review_mode=solo   # write to project.local.yaml (just you)

Full schema and per-setting behavior: .claude/docs/effects-map.md.

Upgrading

Already using an older version of this template? See UPGRADING.md for step-by-step migration instructions, a breakdown of what changed between versions, and which files are safe to overwrite vs. which need a manual merge.

Project Structure

CLAUDE.md                           # Master configuration
project.yaml                        # Project settings: engine, modes, goal
.claude/
  settings.json                     # Hooks, permissions, safety rules
  agents/                           # 49 agent definitions (markdown + YAML frontmatter)
  skills/                           # 75 skills, plus three old names (a subdirectory each)
  hooks/                            # 18 scripts (bash) — 15 event hooks, two helpers they
                                    #   source (yaml-helper.sh, update-check.sh), and one
                                    #   opt-in diagnostic you wire yourself
  scripts/                          # Helper scripts the skills and hooks run; each .sh has --help
  rules/                            # 14 path-scoped coding standards
  genres/                           # Genre sheets and look guidance /prototype asks and
                                    #   builds from
  engines/                          # The engine table (engines.tsv) and the web starter
  statusline.sh                     # Status line script (context%, model, stage, epic breadcrumb)
  docs/
    workflow-catalog.yaml           # 7-phase pipeline definition (read by /next-step)
    templates/                      # 62 document templates (+ per-section guidance)
prototypes/                         # One-shots, one folder each (isolated from src/)
references/                         # Optional: images and sounds you like, for /prototype
src/                                # Game source code (Godot, Web). The code root is
                                    #   ENGINE-SPECIFIC: Unity compiles only
                                    #   Assets/, Unreal builds from Source/<Module>/
assets/                             # Art, audio, VFX, shaders, data files
design/                             # The game brief, GDDs, narrative docs, level designs
docs/                               # Technical documentation, ADRs, engine references
tests/                              # Test suites (unit, integration, performance, playtest)
tools/                              # Build and pipeline tools
production/                         # Sprint plans, milestones, release tracking
studio-tests/                       # QA for the skills and agents themselves — see below

Testing your customizations

Claude Code Game Studios is a template you are meant to edit. studio-tests/ is how you check that an edited or newly written skill still holds up — a catalog of all 75 skills and 49 agents, per-category quality rubrics, behavioral specs, and templates for writing specs of your own.

/skill-test static [name]     # structural linter — 7 compliance checks
/skill-test category [name]   # category-specific quality rubric
/skill-test spec [name]       # behavioral spec assertions
/skill-test audit             # coverage report across skills and agents
/skill-improve [name]         # test-fix-retest loop; keeps or reverts on score change

It tests the framework, never your game — game tests live in tests/.

Hooks, Permissions and Rules

Hooks run automatically on every session:

Hook Trigger What It Does
validate-commit.sh PreToolUse (Bash, PowerShell) Checks for hardcoded values, TODO format, JSON validity, design doc sections — exits early if the command is not git commit
validate-push.sh PreToolUse (Bash, PowerShell) Warns on pushes to protected branches, and on git tag, git merge, gh release, butler push and steamcmd +run_app_build — exits early for any other command
validate-read.sh PreToolUse (Read) Refuses a whole-file read of a design doc over 40 KB and answers with its headings, so the retry reads one section (features.read_guard)
validate-write.sh PreToolUse (Write/Edit) Warns, never blocks, when a write would break a rule the skills state: a file they never overwrite, the config guard, the prototype boundary, a localization freeze
validate-registry.sh PreToolUse (Write/Edit) Warns when a write to the entity or TR-ID registry would delete or renumber an entry, or set a status its header does not list
validate-assets.sh PostToolUse (Write/Edit) Checks data-file JSON under assets/, Assets/ or Content/, and asset naming in Godot's assets/ only — exits early if the file is under none of them
session-start.sh Session open Shows current branch and recent commits for orientation
detect-gaps.sh Session open Detects fresh projects (suggests /start) and missing design docs when code or prototypes exist
pre-compact.sh Before compaction Logs the compaction (its output does not reach Claude — session-start.sh restores context afterwards)
notify.sh Permission prompt, or idle about a minute Shows Windows toast notification via PowerShell
session-stop.sh Every response end, in the background Archives active.md to session log and records git activity
log-agent.sh Agent spawned Audit trail start — logs subagent invocation
log-agent-stop.sh Agent stops Audit trail stop — completes subagent record
validate-agent-artifact.sh Agent stops Warns when a subagent stops without writing the file its brief named
validate-skill-change.sh PostToolUse (Write/Edit) Advises running /skill-test after any .claude/skills/ change

Note: validate-commit.sh, validate-push.sh, validate-read.sh, validate-write.sh, validate-registry.sh, validate-assets.sh and validate-skill-change.sh fire on every Bash, PowerShell, Read, Write or Edit tool call and exit immediately (exit 0) when the command or file path is not relevant. This is normal hook behavior — not a performance concern.

Permission rules in settings.json auto-allow test runs and the framework's read-only helper scripts, and block dangerous operations (force push, rm -rf, reading .env files) in both the Bash and PowerShell tools. Read-only commands such as git status, git log and ls need no rule: Claude Code runs them without asking. The git rules match anywhere after git, so a git command whose text only mentions push followed later by + or -f, clean followed by -f, or reset followed by --hard — a commit message such as git commit -m "push + pull" included — is denied too: reword the message.

Path-Scoped Rules

Coding standards are automatically enforced based on file location. The paths below are Godot's. Each rule also matches the Unity and Unreal layouts: the code rules match C# under Assets/**/Gameplay/ and C++ under Source/**/Gameplay/ (and Core, AI, Networking, UI), data matches JSON under Assets/**/Data/ and Content/**/Data/, shaders match by file type, and tests match C# under Assets/Tests/ and C++ under Source/**/Tests/.

Path Enforces
src/gameplay/** Data-driven values, delta time usage, no UI references
src/core/** Zero allocations in hot paths, thread safety, API stability
src/ai/** Performance budgets, debuggability, data-driven parameters
src/networking/** Server-authoritative, versioned messages, security
src/ui/** No game state ownership, localization-ready, accessibility
design/gdd/** Required sections per modes.workflow, formula format, edge cases
design/narrative/** Lore consistency, character voice, canon levels
assets/data/**/*.json JSON validity, naming conventions, schema rules
assets/shaders/** Naming conventions, performance targets, cross-platform rules
**/*.tscn, **/*.tres Scene and resource files changed in the editor where possible; safe hand-edit rules
tests/** Test naming, coverage requirements, fixture patterns
prototypes/** A one-shot's tuning values in config.js and seeded randomness; relaxed standards for engine and paper prototypes

Studio Mode

Everything above is the light path: one brief, a game you play, one feature a sitting as it grows. For a team, a long project, or a person who wants the paperwork, the same project also has studio mode: 49 specialized agents in a studio hierarchy, a design document per system, architecture decisions, epics and sprints, phase gates, and team-* pipelines that coordinate several agents on one feature. /next-step suggests it once when a grown game gets big (about nine stories or features).

What's Included

Category Count Description
Agents 49 Specialized subagents across design, programming, art, audio, narrative, QA, and production
Skills 75 Slash commands for every workflow phase (/prototype, /start, /design-system, /create-epics, /create-stories, /dev-story, /story-done, etc.)
Hooks 15 Automated validation on commits, pushes, asset changes, design-doc reads, writes and registries, session lifecycle, agent audit trail, and gap detection
Rules 14 Path-scoped coding standards enforced when editing gameplay, engine, AI, UI, network code, scene and asset files, and more
Templates 62 Document templates for GDDs, UX specs, ADRs, sprint plans, HUD design, accessibility, and more

Studio Hierarchy

Agents are organized into three tiers, matching how real studios operate:

Tier 1 — Directors
  creative-director    technical-director    producer

Tier 2 — Department Leads
  game-designer        lead-programmer       art-director
  audio-director       narrative-director    qa-lead
  release-manager      localization-lead

Tier 3 — Specialists
  gameplay-programmer  engine-programmer     ai-programmer
  network-programmer   tools-programmer      ui-programmer
  systems-designer     level-designer        economy-designer
  technical-artist     sound-designer        writer
  world-builder        ux-designer           prototyper
  performance-analyst  devops-engineer       analytics-engineer
  security-engineer    qa-tester             accessibility-specialist
  live-ops-designer    community-manager

Each agent declares a model in its frontmatter: the three directors ask for Opus, lead-programmer and fifteen specialists name Sonnet, and the remaining thirty inherit your session's model. Treat the tiers as seniority of role, not as a billing plan — most of the studio runs on whatever model you are already using.

Engine Specialists

The template includes agent sets for the three major engines. Use the set that matches your project (a web project uses the general programmers):

Engine Lead Agent Sub-Specialists
Godot 4 godot-specialist GDScript, Shaders, GDExtension
Unity unity-specialist DOTS/ECS, Shaders/VFX, Addressables, UI Toolkit
Unreal Engine 5 unreal-specialist GAS, Blueprints, Replication, UMG/CommonUI

Slash Commands

Type / in Claude Code to access all 75 skills (plus three old names that point to their new ones):

Make a Game /prototype /cut

Onboarding & Navigation /start /next-step /project-stage-detect /setup-engine /adopt /project-settings

Game Design /brainstorm /map-systems /design-system /quick-design /review-all-gdds /propagate-design-change

Art & Assets /art-bible /asset-spec /asset-audit

UX & Interface Design /ux-design /ux-review

Architecture /create-architecture /architecture-decision /architecture-review /create-control-manifest

Stories & Sprints /create-epics /create-stories /dev-story /sprint-plan /sprint-status /story-readiness /story-done /estimate

Reviews & Analysis /design-review /code-review /balance-check /content-audit /scope-check /perf-profile /tech-debt /gate-check /consistency-check /security-audit

QA & Testing /qa-plan /smoke-check /soak-test /regression-suite /test-setup /test-helpers /test-evidence-review /test-flakiness /skill-test /skill-improve

Production /milestone-review /retrospective /bug-report /bug-triage /reverse-document /playtest-report

Release /release-checklist /launch-checklist /write-changelog /patch-notes /hotfix /day-one-patch

Creative & Content /vertical-slice /onboard /localize

Team Orchestration (coordinate multiple agents on a single feature) /team-combat /team-narrative /team-ui /team-release /team-polish /team-audio /team-level /team-live-ops /team-qa

Does studio mode produce games, or documents?

A fair question, and the answer is a measurement. Games were built from one brief at different modes.rigor levels, and the documents each wrote before its first line of game code were counted. The lightest and the heaviest:

modes.rigor Docs before first line of game code Time
minimal 1 (the one-page brief) 0 min
standard 30 58 min

All of them produced a running, tested game. Two blind reviewers and a human playtest then ranked the standard build last — the extra 29 documents bought traceability, not a better game. That is why the light path is the default.

It runs the game and looks at it

A passing test says nothing about a menu drawn off-screen, so a story that changes anything the player sees is not closed until the game has been launched, observed, and a screenshot retained in production/qa/evidence/. A parse check is not a run. This holds at every rigor level, including minimal, where automated tests are waived but the look is not.

Agent Coordination

Agents follow a structured delegation model:

  1. Vertical delegation — directors delegate to leads, leads delegate to specialists
  2. Horizontal consultation — same-tier agents can consult each other but can't make binding cross-domain decisions
  3. Conflict resolution — disagreements escalate up to the shared parent (creative-director for design, technical-director for technical)
  4. Change propagation — cross-department changes are coordinated by producer
  5. Domain boundaries — agents don't modify files outside their domain without explicit delegation

Collaborative, Not Autonomous

This is not an auto-pilot system. Every agent follows a strict collaboration protocol:

  1. Ask — agents ask questions before proposing solutions
  2. Present options — agents show 2-4 options with pros/cons
  3. You decide — the user always makes the call
  4. Draft — agents show work before finalizing
  5. Approve — nothing gets written without your sign-off

You stay in control. The agents provide structure and expertise, not autonomy.

That is how a terminal session started at the project root behaves out of the box. The guided and autonomous automation settings, and Claude Code's own auto mode, trade some of these prompts for speed; see setup-requirements.md for the routes into auto mode.

Design Philosophy

This template is grounded in professional game development practices:

  • Playable first — a game you can play before documents about it
  • MDA Framework — Mechanics, Dynamics, Aesthetics analysis for game design
  • Self-Determination Theory — Autonomy, Competence, Relatedness for player motivation
  • Flow State Design — Challenge-skill balance for player engagement
  • Bartle Player Types — Audience targeting and validation
  • Verification-Driven Development — Tests first, then implementation

Customization

This is a template, not a locked framework. Everything is meant to be customized:

  • Add/remove agents — delete agent files you don't need, add new ones for your domains
  • Edit agent prompts — tune agent behavior, add project-specific knowledge
  • Modify skills — adjust workflows to match your team's process
  • Add rules — create new path-scoped rules for your project's directory structure
  • Tune hooks — adjust validation strictness, add new checks
  • Pick your engine — web, Godot, Unity or Unreal (see Engines); use the matching agent set, or none
  • Tune process weight — modes.rigor and its underlying knobs in project.yaml (see Configuration). Override per-run with --review solo on any skill that runs a review gate.

Platform Support

Primary development on Windows 10 with Git Bash. The hooks and scripts are also tested on macOS — its stock bash 3.2 and BSD tools, with and without jq — and on Linux. All hooks use POSIX-compatible patterns (grep -E, not grep -P) and include fallbacks for missing tools. The notify.sh hook uses PowerShell for Windows toast notifications and is a no-op elsewhere — desktop notifications on macOS/Linux are not yet wired. Please file issues for any platform-specific breakage.

Community


Supporting This Project

Claude Code Game Studios is free and open source. If it saves you time or helps you ship your game, consider supporting continued development:

Buy Me a Coffee   GitHub Sponsors

Sponsorships help fund time spent maintaining skills, adding new agents, keeping up with Claude Code and engine API changes, and responding to community issues.


Built for Claude Code. Maintained and extended — contributions welcome via GitHub Discussions.

License

MIT License. See LICENSE for details.

View on GitHub

Recent activity

commits and pull requests

Recent open issues

view all

Discussions

all 24

Releases and announcements

11 total
  1. v1.3.0 — make me a gamev1.3.0Nov 9, 2026

    **"Make me a game" is the main road: `/prototype` asks a few questions, writes a one-page brief, builds a browser game from it, checks it against the brief, and fixes what the check finds before you get it.** After you play it, you change it by asking, and when you like it you grow it into a real web project and build on it one feature at a time. A minor release after 1.2.0. ### Highlights - **Make me a game.** One round of at most about eight questions drawn from the genre, with the usual answer shown so "you pick" works. A vague idea gets two or three one-line pitches first. The answers become `design/game-brief.md`: your words kept exactly, how it looks, its first minute, its challenge, your systems, and Keep, Avoid and Out of scope lines. - **The build and its check.** The game is built in your session as a browser game in `prototypes/<name>/` that opens with a double-click: no emoji art, no copy of another game, and not trivially easy. A short scripted check runs before you get it: a headless browser presses a few keys, a screenshot is compared with the brief, and every line of the brief is marked pass, missing, broken or not assessed. The handover card shows what is still b

  2. **The story skills are rebuilt around shared helper scripts, a read guard stops whole-file reads of large design docs, the engine references move to Godot 4.7 and Unreal Engine 5.8, and no skill pre-approves every shell command any more.** A minor release after 1.1.3. ### Highlights - **The main path is rebuilt.** `/start`, `/create-stories`, `/story-readiness`, `/create-epics`, `/dev-story` and `/story-done` follow Anthropic's skill-authoring guidance: shorter, with rarely used branches in `references/` and fixed steps handed to helper scripts, so the same question gets the same answer each time. `/start` works out the rigor from what you describe and shows it on one card. `/create-stories` proposes an `S`, `M` or `L` estimate for each story. - **Stories list their files, and evidence knows when its code changed.** The new story template has a `## Files` section: `/create-stories` plans it, `/dev-story` fills it and `/story-done` checks scope against it. `/dev-story` stamps a story's screenshots with the files they prove, and `/story-done` names any that changed since (#135, proposed by @jiangshoujie). - **A read guard for large design docs.** A whole-file read of a doc over 40

  3. **Long skills keep their later steps through a long session, a question nobody answered is never taken as an answer, and the shipped permissions approve less.** A fix release for 1.1.2. ### Highlights - **The 14 longest skills keep their later phases after a compaction.** Claude Code re-attaches only the first part of a skill after a compaction, so the later phases of a long skill could drop out mid-session. `/adopt`, `/architecture-decision`, `/architecture-review`, `/create-architecture`, `/design-system`, `/dev-story`, `/gate-check`, `/prototype`, `/review-all-gdds`, `/setup-engine`, `/smoke-check`, `/story-done`, `/test-setup` and `/ux-design` now keep each phase in its own file under `references/`. The steps themselves are unchanged, and `/skill-test` and `/skill-improve` read those files too. - **A skipped, dismissed or empty question is not an answer**, in any mode: nothing is written, set or picked on it, and it is asked again. Agents return their options as a list for the skill to ask, and `CLAUDE.md` names the three writes that need no "May I write?". - **Settings read the same from a subfolder.** Started in `src/`, the settings reader missed per-system overrides, the n

  4. **The default path works end to end, Unity and Unreal get the same care as Godot, and the checks tell you what they found.** A fix release for bugs in 1.1.1, each reproduced before it was fixed. ### Highlights - **The minimal path works start to finish.** `/help`, `/story-done`, `/sprint-status` and the status line follow it. Skills that expect a concept doc read `design/game-brief.md` instead, and there are no more dead ends into sprints. - **Engine commands that actually run.** Godot tests run, Unity tests compile, and Unreal tests compile and are found. `/smoke-check` runs your tests first. - **Unity and Unreal get what Godot gets.** Rules, hooks, checklists and agents know `Assets/`, `Source/` and `Content/`, and check their own engine reference. - **Warnings you can see.** Hook warnings now reach you. The commit and push checks find `git` however it's written, ignore here-doc text, and run in PowerShell too. The push warning names the branches it protects: `main`, `master` and `release/*`. - **Gates you can pass, and verdicts that don't overclaim.** `/gate-check` passes a project that is ready. Every verdict has a word for "could not check" (NOT ASSESSED). A release waits fo

  5. **Skills and agents work again outside auto mode.** A fix release for #128. ### Fixed - **Skills no longer abort before they start.** In 1.1.0, every skill that reads your config began with a shell command Claude Code refuses to run unless it is explicitly approved. In the permission mode CCGS ships with (`default`), 66 of the 74 skills stopped before doing anything — from any subdirectory of your project, and whenever Claude invoked a skill on its own, in auto mode too. Each skill now runs the config lookup as one plain command and pre-approves exactly that command in its own frontmatter. Nothing else is approved. - **`game-designer` and `creative-director` launch again.** Both preload skills, so the aborting command stopped them at startup with `Shell command permission check failed … Contains expansion`. They keep their preloaded skills and still have no shell access. - **Config is found from any folder.** Starting Claude Code inside `src/` or `design/` now reads the project's `project.yaml`. - **`/changelog` works in a repository with no commits yet.** Checked on Claude Code 2.1.277 and 2.1.281, in every permission mode, from the project root and from subdirectories. ### Up

Code frequency

additions and deletions
+45.3K-45.3KWeek of 2026-02-08: +33,180 linesWeek of 2026-02-08: -1,280 linesWeek of 2026-02-15: +1,455 linesWeek of 2026-02-15: -171 linesWeek of 2026-02-22: +0 linesWeek of 2026-02-22: -0 linesWeek of 2026-03-01: +0 linesWeek of 2026-03-01: -0 linesWeek of 2026-03-08: +15,943 linesWeek of 2026-03-08: -1,920 linesWeek of 2026-03-15: +4,998 linesWeek of 2026-03-15: -661 linesWeek of 2026-03-22: +3,941 linesWeek of 2026-03-22: -1,265 linesWeek of 2026-03-29: +1,160 linesWeek of 2026-03-29: -126 linesWeek of 2026-04-05: +23,536 linesWeek of 2026-04-05: -2,076 linesWeek of 2026-04-12: +0 linesWeek of 2026-04-12: -0 linesWeek of 2026-04-19: +2 linesWeek of 2026-04-19: -2 linesWeek of 2026-04-26: +58 linesWeek of 2026-04-26: -2 linesWeek of 2026-05-03: +17 linesWeek of 2026-05-03: -17 linesWeek of 2026-05-10: +2,894 linesWeek of 2026-05-10: -721 linesWeek of 2026-05-17: +0 linesWeek of 2026-05-17: -0 linesWeek of 2026-05-24: +0 linesWeek of 2026-05-24: -0 linesWeek of 2026-05-31: +0 linesWeek of 2026-05-31: -0 linesWeek of 2026-06-07: +0 linesWeek of 2026-06-07: -0 linesWeek of 2026-06-14: +0 linesWeek of 2026-06-14: -0 linesWeek of 2026-06-21: +0 linesWeek of 2026-06-21: -0 linesWeek of 2026-06-28: +0 linesWeek of 2026-06-28: -0 linesWeek of 2026-07-05: +0 linesWeek of 2026-07-05: -0 linesWeek of 2026-07-12: +0 linesWeek of 2026-07-12: -0 linesWeek of 2026-07-19: +0 linesWeek of 2026-07-19: -0 linesWeek of 2026-07-26: +0 linesWeek of 2026-07-26: -0 linesWeek of 2026-08-02: +0 linesWeek of 2026-08-02: -0 linesWeek of 2026-08-09: +0 linesWeek of 2026-08-09: -0 linesWeek of 2026-08-16: +0 linesWeek of 2026-08-16: -0 linesWeek of 2026-08-23: +0 linesWeek of 2026-08-23: -0 linesWeek of 2026-08-30: +0 linesWeek of 2026-08-30: -0 linesWeek of 2026-09-06: +0 linesWeek of 2026-09-06: -0 linesWeek of 2026-09-13: +0 linesWeek of 2026-09-13: -0 linesWeek of 2026-09-20: +25,083 linesWeek of 2026-09-20: -8,282 linesWeek of 2026-09-27: +22,838 linesWeek of 2026-09-27: -10,568 linesWeek of 2026-10-04: +12,018 linesWeek of 2026-10-04: -10,545 linesWeek of 2026-10-11: +0 linesWeek of 2026-10-11: -0 linesWeek of 2026-10-18: +45,327 linesWeek of 2026-10-18: -31,445 linesWeek of 2026-10-25: +0 linesWeek of 2026-10-25: -0 linesWeek of 2026-11-01: +0 linesWeek of 2026-11-01: -0 linesWeek of 2026-11-08: +28,600 linesWeek of 2026-11-08: -3,751 linesWeek of 2026-11-15: +0 linesWeek of 2026-11-15: -0 linesFeb 8, 2026Nov 15, 2026
+221.1K lines added, -72.8K removed over the last year.

Commits per week

last 52 weeks
100Week of 2025-11-23: 0 commitsWeek of 2025-11-30: 0 commitsWeek of 2025-12-07: 0 commitsWeek of 2025-12-14: 0 commitsWeek of 2025-12-21: 0 commitsWeek of 2025-12-28: 0 commitsWeek of 2026-01-04: 0 commitsWeek of 2026-01-11: 0 commitsWeek of 2026-01-18: 0 commitsWeek of 2026-01-25: 0 commitsWeek of 2026-02-01: 0 commitsWeek of 2026-02-08: 3 commitsWeek of 2026-02-15: 1 commitsWeek of 2026-02-22: 0 commitsWeek of 2026-03-01: 0 commitsWeek of 2026-03-08: 10 commitsWeek of 2026-03-15: 7 commitsWeek of 2026-03-22: 4 commitsWeek of 2026-03-29: 2 commitsWeek of 2026-04-05: 5 commitsWeek of 2026-04-12: 0 commitsWeek of 2026-04-19: 1 commitsWeek of 2026-04-26: 2 commitsWeek of 2026-05-03: 1 commitsWeek of 2026-05-10: 1 commitsWeek of 2026-05-17: 0 commitsWeek of 2026-05-24: 0 commitsWeek of 2026-05-31: 0 commitsWeek of 2026-06-07: 0 commitsWeek of 2026-06-14: 0 commitsWeek of 2026-06-21: 0 commitsWeek of 2026-06-28: 0 commitsWeek of 2026-07-05: 0 commitsWeek of 2026-07-12: 0 commitsWeek of 2026-07-19: 0 commitsWeek of 2026-07-26: 0 commitsWeek of 2026-08-02: 0 commitsWeek of 2026-08-09: 0 commitsWeek of 2026-08-16: 0 commitsWeek of 2026-08-23: 0 commitsWeek of 2026-08-30: 0 commitsWeek of 2026-09-06: 0 commitsWeek of 2026-09-13: 0 commitsWeek of 2026-09-20: 2 commitsWeek of 2026-09-27: 1 commitsWeek of 2026-10-04: 1 commitsWeek of 2026-10-11: 0 commitsWeek of 2026-10-18: 1 commitsWeek of 2026-10-25: 0 commitsWeek of 2026-11-01: 0 commitsWeek of 2026-11-08: 1 commitsWeek of 2026-11-15: 0 commitsNov 23, 2025Nov 15, 2026
43 commits in the last 52 weeks.

When work happens

weekday and hour
SunMonTueWedThuFriSat036912151821Sun 0:00 — 0 commitsSun 1:00 — 0 commitsSun 2:00 — 0 commitsSun 3:00 — 0 commitsSun 4:00 — 0 commitsSun 5:00 — 0 commitsSun 6:00 — 0 commitsSun 7:00 — 0 commitsSun 8:00 — 0 commitsSun 9:00 — 0 commitsSun 10:00 — 0 commitsSun 11:00 — 0 commitsSun 12:00 — 0 commitsSun 13:00 — 0 commitsSun 14:00 — 0 commitsSun 15:00 — 0 commitsSun 16:00 — 0 commitsSun 17:00 — 2 commitsSun 18:00 — 0 commitsSun 19:00 — 1 commitsSun 20:00 — 0 commitsSun 21:00 — 1 commitsSun 22:00 — 0 commitsSun 23:00 — 0 commitsMon 0:00 — 0 commitsMon 1:00 — 0 commitsMon 2:00 — 0 commitsMon 3:00 — 0 commitsMon 4:00 — 0 commitsMon 5:00 — 0 commitsMon 6:00 — 0 commitsMon 7:00 — 0 commitsMon 8:00 — 0 commitsMon 9:00 — 0 commitsMon 10:00 — 0 commitsMon 11:00 — 0 commitsMon 12:00 — 1 commitsMon 13:00 — 3 commitsMon 14:00 — 2 commitsMon 15:00 — 2 commitsMon 16:00 — 0 commitsMon 17:00 — 1 commitsMon 18:00 — 0 commitsMon 19:00 — 0 commitsMon 20:00 — 1 commitsMon 21:00 — 0 commitsMon 22:00 — 0 commitsMon 23:00 — 1 commitsTue 0:00 — 0 commitsTue 1:00 — 0 commitsTue 2:00 — 0 commitsTue 3:00 — 0 commitsTue 4:00 — 0 commitsTue 5:00 — 0 commitsTue 6:00 — 0 commitsTue 7:00 — 0 commitsTue 8:00 — 0 commitsTue 9:00 — 0 commitsTue 10:00 — 0 commitsTue 11:00 — 0 commitsTue 12:00 — 0 commitsTue 13:00 — 0 commitsTue 14:00 — 0 commitsTue 15:00 — 0 commitsTue 16:00 — 1 commitsTue 17:00 — 2 commitsTue 18:00 — 1 commitsTue 19:00 — 0 commitsTue 20:00 — 0 commitsTue 21:00 — 1 commitsTue 22:00 — 0 commitsTue 23:00 — 0 commitsWed 0:00 — 0 commitsWed 1:00 — 0 commitsWed 2:00 — 0 commitsWed 3:00 — 0 commitsWed 4:00 — 0 commitsWed 5:00 — 0 commitsWed 6:00 — 0 commitsWed 7:00 — 0 commitsWed 8:00 — 0 commitsWed 9:00 — 0 commitsWed 10:00 — 0 commitsWed 11:00 — 0 commitsWed 12:00 — 1 commitsWed 13:00 — 0 commitsWed 14:00 — 0 commitsWed 15:00 — 0 commitsWed 16:00 — 0 commitsWed 17:00 — 0 commitsWed 18:00 — 1 commitsWed 19:00 — 0 commitsWed 20:00 — 2 commitsWed 21:00 — 0 commitsWed 22:00 — 0 commitsWed 23:00 — 0 commitsThu 0:00 — 0 commitsThu 1:00 — 0 commitsThu 2:00 — 0 commitsThu 3:00 — 0 commitsThu 4:00 — 0 commitsThu 5:00 — 0 commitsThu 6:00 — 0 commitsThu 7:00 — 0 commitsThu 8:00 — 0 commitsThu 9:00 — 0 commitsThu 10:00 — 0 commitsThu 11:00 — 1 commitsThu 12:00 — 2 commitsThu 13:00 — 0 commitsThu 14:00 — 0 commitsThu 15:00 — 0 commitsThu 16:00 — 0 commitsThu 17:00 — 1 commitsThu 18:00 — 0 commitsThu 19:00 — 0 commitsThu 20:00 — 0 commitsThu 21:00 — 1 commitsThu 22:00 — 0 commitsThu 23:00 — 0 commitsFri 0:00 — 0 commitsFri 1:00 — 0 commitsFri 2:00 — 0 commitsFri 3:00 — 0 commitsFri 4:00 — 0 commitsFri 5:00 — 0 commitsFri 6:00 — 0 commitsFri 7:00 — 0 commitsFri 8:00 — 0 commitsFri 9:00 — 0 commitsFri 10:00 — 0 commitsFri 11:00 — 0 commitsFri 12:00 — 1 commitsFri 13:00 — 0 commitsFri 14:00 — 1 commitsFri 15:00 — 1 commitsFri 16:00 — 0 commitsFri 17:00 — 1 commitsFri 18:00 — 0 commitsFri 19:00 — 0 commitsFri 20:00 — 4 commitsFri 21:00 — 1 commitsFri 22:00 — 0 commitsFri 23:00 — 0 commitsSat 0:00 — 0 commitsSat 1:00 — 0 commitsSat 2:00 — 0 commitsSat 3:00 — 0 commitsSat 4:00 — 0 commitsSat 5:00 — 0 commitsSat 6:00 — 0 commitsSat 7:00 — 0 commitsSat 8:00 — 1 commitsSat 9:00 — 0 commitsSat 10:00 — 0 commitsSat 11:00 — 0 commitsSat 12:00 — 0 commitsSat 13:00 — 1 commitsSat 14:00 — 0 commitsSat 15:00 — 0 commitsSat 16:00 — 1 commitsSat 17:00 — 0 commitsSat 18:00 — 0 commitsSat 19:00 — 0 commitsSat 20:00 — 2 commitsSat 21:00 — 0 commitsSat 22:00 — 0 commitsSat 23:00 — 0 commits
Commit volume by weekday and hour (UTC). Larger dots mean more commits.

Who is committing

last 52 weeks
Maintainer commits44 (100%)
Community commits0 (0%)

44 commits in total over the last year.

DateListRankStars gained
Apr 20, 2026daily#11+173
Apr 19, 2026daily#19+184
Apr 18, 2026daily#23+190
Apr 16, 2026daily#16+119
Mar 26, 2026daily#10+124
Mar 25, 2026daily#18+108
Mar 23, 2026daily#17+140
Mar 22, 2026daily#18+240
Mar 21, 2026daily#19+201
  • morluto/rea

    Reverse engineer anything with agents, from app behavior down to native binaries.

    471.6K stars · TypeScript

  • mattpocock/skills

    Skills for Real Engineers. Straight from my .agents directory.

    329K stars · Shell

  • obra/superpowers

    An agentic skills framework & software development methodology that works.

    322.9K stars · Shell

  • affaan-m/ECC

    The agent harness performance optimization system. Skills, instincts, memory, security, and research-first development for Claude Code, Codex, Opencode, Cursor and beyond.

    307.9K stars · JavaScript

  • NousResearch/hermes-agent

    The agent that grows with you

    265K stars · Python

  • firecrawl/firecrawl

    Knowledge infrastructure to make your agents smarter. Search, scrape and access 550+ data providers through one API.

    205.3K stars · TypeScript