Install the "create-epics" agent skill from https://github.com/Donchitos/Claude-Code-Game-Studios/tree/main/.claude/skills/create-epics into .claude/skills/create-epics/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "create-epics", then confirm the skill loads.
Claude Code copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
Type this inside Codex. $skill-installer <name> installs a curated skill from openai/skills. The installer writes to $CODEX_HOME/skills (default ~/.codex/skills). Restart Codex if the skill does not show up.
skills CLI
$ npx skills add Donchitos/Claude-Code-Game-Studios --skill create-epics -a codex
Project install goes to .agents/skills/; add -g for ~/.codex/skills/.
Install the "create-epics" agent skill from https://github.com/Donchitos/Claude-Code-Game-Studios/tree/main/.claude/skills/create-epics into .agents/skills/create-epics/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "create-epics", then confirm the skill loads.
Codex copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
skills CLI
$ npx skills add Donchitos/Claude-Code-Game-Studios --skill create-epics -a cursor
Project install goes to .agents/skills/; add -g for ~/.cursor/skills/.
Install the "create-epics" agent skill from https://github.com/Donchitos/Claude-Code-Game-Studios/tree/main/.claude/skills/create-epics into .cursor/skills/create-epics/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "create-epics", then confirm the skill loads.
Cursor copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
--scope user (default) or --scope workspace; --path is the subfolder of the repo that holds the skill; --consent skips the security confirmation prompt.
skills CLI
$ npx skills add Donchitos/Claude-Code-Game-Studios --skill create-epics -a gemini-cli
Project install goes to .agents/skills/; add -g for ~/.gemini/skills/.
Install the "create-epics" agent skill from https://github.com/Donchitos/Claude-Code-Game-Studios/tree/main/.claude/skills/create-epics into .gemini/skills/create-epics/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "create-epics", then confirm the skill loads.
Gemini CLI copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
Installs for Copilot at project scope by default; add --scope user for a personal install. Preview a skill first with gh skill preview. Needs GitHub CLI 2.90.0 or later (public preview).
skills CLI
$ npx skills add Donchitos/Claude-Code-Game-Studios --skill create-epics -a github-copilot
Project install goes to .agents/skills/; add -g for ~/.copilot/skills/.
Install the "create-epics" agent skill from https://github.com/Donchitos/Claude-Code-Game-Studios/tree/main/.claude/skills/create-epics into .github/skills/create-epics/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "create-epics", then confirm the skill loads.
GitHub Copilot copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
skills CLI
$ npx skills add Donchitos/Claude-Code-Game-Studios --skill create-epics -a opencode
OpenCode documents no install command of its own. Project install goes to .agents/skills/; add -g for ~/.config/opencode/skills/.
Install the "create-epics" agent skill from https://github.com/Donchitos/Claude-Code-Game-Studios/tree/main/.claude/skills/create-epics into .opencode/skills/create-epics/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "create-epics", then confirm the skill loads.
OpenCode copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
Facts
Skill name
create-epics
GitHub stars
26k
Token cost
~4.3k tokens
SKILL.md length
1,917 words
Files
2
Skills in repo
73
Repo updated
First seen
Licence
MIT
At a glance
Turns game design documents and architecture into epics, one per architectural module, ready for story creation in a Claude Code game-studio workflow.
Works in 6 steps: Parse Arguments → Load Inputs → Processing Order → …
Breaking a finished game design and architecture into per-module epics
SKILL.md covers 1. Parse Arguments, 2. Load Inputs, 3. Processing Order and 4. Define Each Epic, plus 4 more sections
Calls bash
What it does
An epic here is a named, bounded body of work tied to one architectural module. It states what must be built and who owns it architecturally, and leaves implementation steps to stories. The skill writes one `EPIC.md` per epic folder under `production/epics/` plus a `production/epics/index.md`, and the next step after each epic is `/create-stories`.
It runs once per layer as development reaches that layer, and Feature layer epics wait until Core is nearly complete because the design will have changed by then. It follows the project's automation and review settings, resolved through a helper script. The skill is expected after `/create-control-manifest` and `/architecture-review` pass at the full tier, works from critical ADRs at standard, and is optional at minimal, where `/create-stories` builds the epic from `design/game-brief.md`.
When your agent uses it
Breaking a finished game design and architecture into per-module epics
Starting a new layer of development and needing its epics defined
Preparing epics before running /create-stories
Example prompts
“Create epics for the Core layer from our GDDs and architecture docs.”
“Generate the epic for the inventory module and update the epics index.”
“We just passed the architecture review, so turn the design docs into epics.”
Requirements
A Claude Code Game Studios project with game design and architecture documents
The `hooks/yaml-helper.sh` helper for configuration
From the folder's file list and the shell code blocks in SKILL.md.
Network
No URLs in SKILL.md.
From URLs in SKILL.md, links to its own repository left out.
Credentials
Names no API keys, tokens, secrets or passwords.
From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.
Context cost
Create Epics from Game Design Docs loads about 4.3k tokens when it runs. Until then it costs about 36 tokens; SKILL.md has 1,917 words of instructions outside code blocks.
Always· name and description, kept in context so the agent knows when to use it
~36
When it runs· the whole SKILL.md, loaded when a task matches
~4.3k
Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.
Safety
Auto-check passed
The automated check found no risky patterns in SKILL.md.
Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.
Download SKILL.mdSave it as .claude/skills/create-epics/SKILL.md (or your agent's skills folder). This skill also uses 1 other file; get the full folder from GitHub.
name
create-epics
description
Turn GDDs plus architecture into epics — one per architectural module, with untraced requirements. Then /create-stories [epic-slug].
Resolved above — use as-is; --review overrides review_mode. No block →
defaults in .claude/docs/config-resolution.md.
Create Epics
An epic is a named, bounded body of work that maps to one architectural module.
It defines what needs to be built and who owns it architecturally. It
does not prescribe implementation steps — that is the job of stories.
Run this skill once per layer as you approach that layer in development.
Do not create Feature layer epics until Core is nearly complete — the design
will have changed.
Next step after each epic:/create-stories [epic-slug]
When to run: After /create-control-manifest and /architecture-review pass
(at full). At standard, critical ADRs suffice, and a control manifest is
read if present. At
minimal, this skill is optional and not part of the path — /create-stories
synthesizes the epic from design/game-brief.md itself (Option A). If run anyway,
it decomposes directly from the brief with no GDD/ADR/manifest prerequisite.
At minimal, this skill is optional — /create-stories synthesizes the epic
(Option A). At that tier /create-stories reads design/game-brief.md
directly, writes a lightweight implicit production/epics/<slug>/EPIC.md, and
generates stories from the MVP list — so the path is /brainstorm →
/create-stories → /dev-story, with no separate /create-epics or
/sprint-plan step. At standard/full an epic IS required:
/create-stories reads production/epics/[slug]/EPIC.md, and skipping this
skill there leaves /dev-story with no story to implement — a dead end, not a
shortcut.
1. Parse Arguments
See .claude/docs/director-gates.md for the full check pattern. Individual gate definitions live in .claude/docs/director-gates/[gate-id].md — the spawned agent reads its own gate file; do not read it in the parent session.
Every AskUserQuestion call follows .claude/docs/automation-modes.md
(collaborative asks always · guided major-only · autonomous logs and proceeds;
automation_always_ask categories always prompt).
workflow (per .claude/docs/workflow-modes.md):
create-epics runs project-wide: it uses the project-level tier for its
prerequisite expectations and consults
workflow_overrides.system_overrides.<system> per-system when reading each
in-scope GDD. See "Workflow tier adjustment" in Step 2.
story_granularity — it sizes the
epic's story breakdown: expect 3–5 child stories per epic at coarse (the default, via rigor: minimal), 5–10
at balanced (rigor: standard), 10–20 at fine.
docs.density — it controls the depth of each epic's written scope and
rationale, not the story count (that is story_granularity). modes.rigor sets
it alongside workflow; set docs.density explicitly to vary epic prose alone:
terse (the default, via rigor: minimal) = scope as bullets, one-line rationale; balanced = a scope paragraph
with light rationale (rigor: standard); thorough = full scope prose with governing-ADR
rationale and risk discussion. The EPIC.md tables (GDD requirements, governing
ADRs) are structural and stay whole at every density.
Modes:
/create-epics all — process all systems in layer order
/create-epics layer: foundation — Foundation layer only
/create-epics layer: core — Core layer only
/create-epics layer: feature — Feature layer only
/create-epics layer: presentation — Presentation layer only
/create-epics [system-name] — one specific system
No argument — ask: "Which layer or system would you like to create epics for?"
2. Load Inputs
Step 2a — Summary scan (fast, fail-open)
At minimal, skip Steps 2a and 2b — that tier decomposes from
design/game-brief.md and has no GDDs by design (see the tier note below). Read
the brief instead; if it is missing, report "No design/game-brief.md — run
/start or /brainstorm first" and stop.
At standard and full, establish the denominator first. Glob design/gdd/*.md, excluding the
non-system docs — game-concept.md, systems-index.md, game-pillars.md,
gameplay-tags.md, entity-registry.md, fixture-swap-ledger.md, any
gdd-cross-review-*.md, sound-bible.md — the set gdd-structure-check.sh
skips (the sound bible belongs in design/audio/; it is listed for projects
that still keep it at the earlier location). Call the
count N. If N is 0, there are no system GDDs — report "No system GDDs found
in design/gdd/ — run /design-system first" and stop.
Scan for Summary sections:
Grep pattern="^## Summary" glob="design/gdd/*.md" output_mode="content" -A 5
Interpret the M matches against N. These are three different outcomes, and
a zero-match scan is never the same as "nothing in scope":
Result
Meaning
Action
M = N
Every GDD has a Summary.
For layer:/[system-name] modes, use the Summary Quick-reference (Layer/Priority) to pick the in-scope set; skip full-reading the rest.
0 < M < N
Partial adoption — older GDDs predate ## Summary.
Scope the M by their Summaries; determine the scope of the N − M unmatched from systems-index.md (layer/priority) and full-read those.
0 matches, N > 0
Expected for GDDs authored before /design-system emitted ## Summary.
Determine scope for all N from systems-index.md and full-read the in-scope set. This is the pre-optimization behaviour — correct, only more expensive. Note once: "No ## Summary sections found across [N] GDDs — scoping from systems-index.md instead of Summary."
Never treat an absent ## Summary as an absent system. The scan narrows the
read set when it succeeds; it never shrinks the in-scope set. In all mode
every system is in scope regardless of Summary, so the scan is a convenience
only — never a filter.
Step 2b — Full document load (in-scope systems only)
Using the Step 2a grep results, identify which systems are in scope. Read full documents only for in-scope systems — do not read GDDs or ADRs for out-of-scope systems or layers.
Read for in-scope systems:
design/gdd/systems-index.md — authoritative system list, layers, priority
In-scope GDDs only (Approved or Designed status, filtered by Step 2a results)
docs/architecture/architecture.md — module ownership and API boundaries
Accepted ADRs whose domains cover in-scope systems only — skip ADRs for
unrelated domains entirely. For each in-scope ADR, load only the "GDD
Requirements Addressed", "Decision", and "Engine Compatibility" sections —
never an unbounded full read:
Workflow tier adjustment (resolved in Step 1; per-system via
system_overrides). The inputs above are the full baseline:
full — every in-scope GDD must be Approved with all 8 sections; TR
registry + control manifest are required inputs; untraced requirements
(Step 4) are flagged before proceeding.
standard — GDDs need the 5 required sections (+ conditional Formulas)
approved; only critical (Foundation-layer) ADRs are expected; the control
manifest is read if present, not required. A system pinned higher via
system_overrides must still meet its higher bar.
minimal — decompose against design/game-brief.md +
acceptance criteria. Do not require GDDs, ADRs, the TR registry, or the
manifest; skip the untraced-requirement gate. If run, the epic is still
produced — but note /create-stories also synthesizes one from the brief when
this skill is skipped (the default minimal path).
3. Processing Order
Process in dependency-safe layer order:
Foundation (no dependencies)
Core (depends on Foundation)
Feature (depends on Core)
Presentation (depends on Feature + Core)
Within each layer, use the order from systems-index.md.
At minimal there is no systems-index.md — /map-systems is not required
at that tier, so nothing has produced one. Derive the layer split and ordering
from design/game-brief.md instead: its Build order field names what must
exist first. Do not stop, and do not send the user to /map-systems to satisfy
an ordering hint — the tier deliberately skips it.
Show full SKILL.md (782 more words)Show less
4. Define Each Epic
For each system, map it to an architectural module from architecture.md.
Check ADR coverage against the TR registry per the resolved tier (Step 1):
full — trace every TR-ID; warn on each untraced requirement (below).
standard — only critical (Foundation-layer) ADRs are expected; trace
those. Treat untraced non-critical requirements as informational (list them, do
not block or emit the untraced-requirements warning).
minimal — skip this check entirely (no TR registry / ADR expected).
Traced requirements: TR-IDs that have an Accepted ADR covering them
Untraced requirements: TR-IDs with no ADR — warn before proceeding (full only)
Present to user before writing anything:
## Epic: [System Name]
**Layer**: [Foundation / Core / Feature / Presentation]
**GDD**: design/gdd/[filename].md
**Architecture Module**: [module name from architecture.md]
**Governing ADRs**: [ADR-NNNN, ADR-MMMM]
**Engine Risk**: [LOW / MEDIUM / HIGH — highest risk among governing ADRs]
**GDD Requirements Covered by ADRs**: [N / total]
**Untraced Requirements**: [list TR-IDs with no ADR, or "None"]
If there are untraced requirements:
"⚠️ [N] requirements in [system] have no ADR. The epic can be created, but
/create-stories will write their stories with no governing ADR (ADR: N/A)
and Status: Ready — nothing downstream blocks them, so they would be
implemented without architectural guidance. Run /architecture-decision first
if they need a decision, or proceed and accept the gap."
Use AskUserQuestion:
Prompt: "Shall I create Epic: [name]?"
Options:
[A] Yes, create it
[B] Skip this epic
[C] Pause — I need to write ADRs first
4b. Producer Epic Structure Gate
Review mode check — apply before spawning PR-EPIC:
solo → skip. Note: "PR-EPIC skipped — Solo mode." Proceed to Step 5 (write epic files).
lean → skip (not a PHASE-GATE). Note: "PR-EPIC skipped — Lean mode." Proceed to Step 5 (write epic files).
full → spawn as normal.
After all epics for the current layer are defined (Step 4 completed for all in-scope systems), and before writing any files, spawn producer via Agent using gate PR-EPIC (.claude/docs/director-gates/pr-epic.md).
Pass: the full epic structure summary (all epics, their scope summaries, governing ADR counts), the layer being processed, milestone timeline and team capacity.
Present the producer's assessment.
If UNREALISTIC: offer to revise epic boundaries (split overscoped or merge underscoped epics). Revise, present the revised epics again, and re-run the gate before writing.
If CONCERNS, use AskUserQuestion:
Prompt: "Producer raised concerns about the epic structure. How do you want to proceed?"
Options:
[A] Proceed as planned — I accept the producer's concerns
[B] Revise epic boundaries — split or merge as recommended
[C] Stop — I want to reconsider the scope
If [A]: proceed to Step 5.
If [B]: revise epic definitions from Step 4, present the revised epics to the user again, then re-run the producer gate.
If [C]: stop. Verdict: BLOCKED — user wants to reconsider epic scope.
If NOT ASSESSED [missing input] — e.g. no milestone timeline or team capacity — it
is not a REALISTIC (.claude/docs/director-gates.md): name what was missing, then
supply it and re-run the gate, or, if the user chooses to go on without it,
proceed to Step 5 and state PR-EPIC: NOT ASSESSED — [input] in the output and
the final Verdict line.
Do not write epic files until the producer gate resolves.
5. Write Epic Files
If production/epics/[epic-slug]/EPIC.md already exists, never overwrite it.
Ask instead: "An EPIC.md already exists for [name]. Update it in place, or skip
it?" — [A] Update in place — keep its Stories table, and update its index.md row / [B] Skip this epic. An
update rewrites only what this skill owns — the header fields other than
Stories, ## Overview, ## Governing ADRs, ## GDD Requirements and
## Definition of Done — and leaves the **Stories** header line and any
## Stories table exactly as they are: /create-stories wrote them, and
resetting them to "Not yet created" orphans every story already in the directory.
For a new epic, after approval, ask: "May I write production/epics/[epic-slug]/EPIC.md and add its row to production/epics/index.md (creating it if absent)?"
After user confirms, write:
production/epics/[epic-slug]/EPIC.md
markdown
# Epic: [System Name]
> **Layer**: [Foundation / Core / Feature / Presentation]
> **GDD**: design/gdd/[filename].md
> **Architecture Module**: [module name]
> **Status**: Ready
> **Stories**: Not yet created — run `/create-stories [epic-slug]`
## Overview
[1 paragraph describing what this epic implements, derived from the GDD Overview
and the architecture module's stated responsibilities]
## Governing ADRs
| ADR | Decision Summary | Engine Risk |
|-----|-----------------|-------------|
| ADR-NNNN: [title] | [1-line summary] | LOW/MEDIUM/HIGH |
## GDD Requirements
| TR-ID | Requirement | ADR Coverage |
|-------|-------------|--------------|
| TR-[system]-001 | [requirement text from registry] | ADR-NNNN ✅ |
| TR-[system]-002 | [requirement text] | ❌ No ADR |
## Definition of Done
This epic is complete when:
- All stories are implemented, reviewed, and closed via `/story-done`
- All acceptance criteria from `design/gdd/[filename].md` are verified
- All Logic and Integration stories have passing test files in [the test root — `tests/` on Godot, `Assets/Tests/` on Unity, `Source/<Module>/Private/Tests/` on Unreal]
- All Visual/Feel and UI stories have retained screenshots in `production/qa/evidence/` — each screen touched for UI, plus a lead sign-off for Visual/Feel
## Next Step
Run `/create-stories [epic-slug]` to break this epic into implementable stories.
Update production/epics/index.md
Create or update the master index. An epic that already has a row keeps it:
update that row in place and keep its Stories value — never append a second
row, and never reset Stories to Not yet created:
markdown
# Epics Index
Last Updated: [date]
Engine: [name + version]
| Epic | Layer | System | GDD | Stories | Status |
|------|-------|--------|-----|---------|--------|
| [name] | Foundation | [system] | [file] | Not yet created | Ready |
6. Gate-Check Reminder
After writing all epics for the requested scope:
Foundation + Core complete: These are required for the Pre-Production →
Production gate. Run /gate-check production to check readiness.
Reminder: Epics define scope. Stories define implementation steps. Run
/create-stories [epic-slug] for each epic before developers can pick up work.
Collaborative Protocol
Applies in collaborative mode (the default). For guided and
autonomous modes, see .claude/docs/automation-modes.md — the rules below
describe what collaborative mode requires, not universal behavior.
One epic at a time — present each epic definition before asking to create it
Warn on gaps — flag untraced requirements before proceeding
Ask before writing — per-epic approval before writing any file
No invention — all content comes from GDDs, ADRs, and architecture docs
Never create stories — this skill stops at the epic level
After all requested epics are processed:
Verdict: COMPLETE — [N] epic(s) written. Run /create-stories [epic-slug] per epic.
Verdict: BLOCKED — user declined all epics, or no eligible systems found.
Create Epics from Game Design Docs next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.
Create Epics from Game Design Docs compared with similar skills
Skill
Stars
Used in
Tokens
Auto-check
Licence
Repo updated
Create Epics from Game Design Docs this skillDonchitos/Claude-Code-Game-Studios
Splits a too-large epic into user stories using Richard Lawrence's nine Humanizing Work splitting patterns while keeping each story a vertical slice of user value.
Writes per-asset visual specs and AI image-generation prompts for a game's characters, enemies and screens, driven by the GDD, art bible and an entity inventory.
Checks game data and formulas for balance outliers, broken progression, degenerate strategies and economy problems, and answers 'could not run' when the data is missing.
Generates an internal or player-facing changelog from git commits and sprint data, filtering out framework maintenance commits so that only work on the game itself reaches release copy.
Questions about Create Epics from Game Design Docs
What does Create Epics from Game Design Docs do?
Turns game design documents and architecture into epics, one per architectural module, ready for story creation in a Claude Code game-studio workflow. An epic here is a named, bounded body of work tied to one architectural module. It states what must be built and who owns it architecturally, and leaves implementation steps to stories.
When should I use Create Epics from Game Design Docs?
Create Epics from Game Design Docs fits situations like: breaking a finished game design and architecture into per-module epics; starting a new layer of development and needing its epics defined; preparing epics before running /create-stories.
How do I install Create Epics from Game Design Docs in Claude Code?
Run `npx skills add Donchitos/Claude-Code-Game-Studios --skill create-epics -a claude-code`. Or copy the skill folder (.claude/skills/create-epics in Donchitos/Claude-Code-Game-Studios) into .claude/skills/create-epics in your project. Claude Code loads it when a task matches its description.
How do I install Create Epics from Game Design Docs in Codex?
Run `npx skills add Donchitos/Claude-Code-Game-Studios --skill create-epics -a codex`. Or copy the skill folder (.claude/skills/create-epics in Donchitos/Claude-Code-Game-Studios) into .agents/skills/create-epics in your project. Codex loads it when a task matches its description.
Can I use Create Epics from Game Design Docs in Cursor, Gemini CLI or GitHub Copilot?
Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add Donchitos/Claude-Code-Game-Studios --skill create-epics -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/create-epics, .gemini/skills/create-epics, .github/skills/create-epics and .opencode/skills/create-epics in your project.
What does Create Epics from Game Design Docs need to run?
Going by SKILL.md and its folder, Create Epics from Game Design Docs needs the command-line tools its instructions call (bash). Our summary lists: A Claude Code Game Studios project with game design and architecture documents; The `hooks/yaml-helper.sh` helper for configuration. Its frontmatter pre-approves these tools: Read, Glob, Grep, Write, Edit, Agent, AskUserQuestion, Bash(bash "*/.claude/skills/create-epics/../../hooks/yaml-helper.sh" resolve_config *).
Does Create Epics from Game Design Docs access the network?
SKILL.md contains no URLs. Any network use would come from the scripts or tools the agent runs. This is read from the text; nothing was executed.
Is Create Epics from Game Design Docs safe to install?
Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. Review the folder before installing.
What licence does Create Epics from Game Design Docs use?
Create Epics from Game Design Docs is published under the MIT licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.
How many tokens does Create Epics from Game Design Docs use?
About 4.3k tokens (SKILL.md is roughly 17k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full.
What are the alternatives to Create Epics from Game Design Docs?
Skills that share tags, products or a category with Create Epics from Game Design Docs: Project Planner (adrianpuiu/claude-skills-marketplace, 100 stars), Backlog Builder (open-mercato/skills, 227 stars), New Feature (PolymathWizard/BHIL-AI-First-Development-Toolkit, 132 stars) and Epic Breakdown Advisor (deanpeters/Product-Manager-Skills, 7.2k stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.
Who maintains Create Epics from Game Design Docs?
Donchitos (a GitHub user) maintains it in Donchitos/Claude-Code-Game-Studios, which has 25,871 GitHub stars. The repository holds 73 skills in this directory. The repository was last updated on September 29, 2026.
