awesome-gamedev-agent-skills: 77 game dev skills for Claude Code, Codex and Cursor, tested
If you use an AI agent to write games, you know where it falls short: it mixes APIs from different Godot versions, invents Unity components that don't exist and hands you jumps that feel floaty. awesome-gamedev-agent-skills tries to fix that with 77 game development skills and a router that picks the right ones for your engine and your request.
We cloned it, read it and tested it in Claude Code on a Phaser project. This article covers what it includes, how to install it in Claude Code, Codex or Cursor, what the agent did with the skills loaded and what they don't solve.
What awesome-gamedev-agent-skills is
It is a collection of *Agent Skills*: folders with a SKILL.md (Markdown instructions) that the agent loads only when your request matches its description. If skills are new to you, start with what Claude Code skills are.
Repository facts at the time of testing (commit 19d93f9, October 28, 2026):
- 77 skills + 1 router, about 87,000 words of instructions in total.
- 12 engines: Godot 4.7, Unity 6.3 LTS, Unreal Engine 5.8, Ebitengine 2.10.5 (Go), Phaser 4.2, PixiJS 8.22, three.js r186, Bevy 0.20, pygame-ce 2.5.8, LÖVE 11.5, Defold 1.14.0 and Roblox.
- License: Apache-2.0, not MIT. You can use, modify and redistribute the skills, including commercially, but if you redistribute the repository or a modified version you must keep
LICENSEandNOTICEand state what you changed. Using them in your agent to write your game puts no obligation on your game. - Maintainer: Abhishek Barali and contributors. The
NOTICEstates every skill was written from the engines' official documentation.
Each skill pins the engine version it targets, and docs/VERSION-SUPPORT.md records the last review date (October 24, 2026). Each skill also tells the agent to read your project's version first and keep it: if your game is on Godot 4.3, it should not "upgrade" your code to 4.7 unless you ask.
Which skills are included
The catalog has four groups:
| Group | Count | Examples |
|---|---|---|
| Engines | 49 | `godot-2d-movement`, `godot-tilemap`, `unity-input-system`, `unreal-blueprints`, `phaser-arcade-physics`, `threejs-gltf-loading`, `bevy-ecs`, `roblox-datastores` |
| Disciplines | 15 | `game-feel`, `camera-systems`, `save-systems`, `procedural-gen`, `game-ai`, `shader-programming`, `performance-optimization`, `create-game-assets` |
| Genres | 9 | `platformer`, `roguelike`, `rpg`, `fps-shooter`, `tower-defense`, `card-game`, `visual-novel`, `survival-crafting`, `puzzle` |
| Workflows | 4 | `game-jam`, `prototype-fast`, `steam-publish`, `itch-publish` |
Godot has the best coverage (16 skills) and is the router's default when you start a new project without naming an engine. Unity has 8, Unreal 6, Roblox 8 and the rest 1 to 3. Ebitengine and Defold each get one large skill, and the router admits gaps: Defold has no dedicated UI, tilemap or physics skill.
Genre skills don't repeat APIs: they say which systems the game needs and in what order, and leave the code to the engine skill. platformer, for example, asks you to tune the jump by outcome (height in tiles and time to apex) and derive gravity and velocity from that, instead of guessing numbers.
How the router works
The router (router/SKILL.md) does three things on each request:
- Detects the engine from project files:
project.godotmeans Godot,*.uprojectmeans Unreal, apackage.jsonwithphasermeans Phaser, ago.modwithebiten/v2means Ebitengine, and so on. - Classifies the task: a concept (saving, AI, shaders), a genre (platformer, roguelike) or a shipping step (Steam, itch.io).
- Loads only the skills needed, in order: engine, discipline, genre and workflow.
So "add a double jump to my Godot player" should load godot-2d-movement and platformer, and nothing else. If your engine is in-house or not on the list, the router keeps it: it uses the discipline and genre skills and looks up the APIs in your code.
How to install the skills
There are three ways. All of them install the same SKILL.md files.
With the skills CLI (any agent)
npx skills add gamedev-skills/awesome-gamedev-agent-skillsIt detects your agent and copies the router and the 77 skills to the right place. Add --list to preview, -g to install for every project or -a <agent> to target one (-a claude-code, -a cursor, -a gemini-cli). It needs Node.js 22.20 or later. To search for other skills from inside your agent, see find-skills.
As a Claude Code plugin
The repository is also a plugin marketplace:
claude plugin marketplace add gamedev-skills/awesome-gamedev-agent-skills
claude plugin install gamedev@awesome-gamedev-agent-skillsIf you only work with one engine, install the router and that engine's bundle so you don't fill the context with 77 descriptions:
claude plugin install router@awesome-gamedev-agent-skills
claude plugin install godot@awesome-gamedev-agent-skillsThe bundles are godot, unity, unreal, ebitengine, web-engines (Phaser, PixiJS, three.js), other-engines (Bevy, pygame, LÖVE, Defold, Roblox), disciplines, genres and workflows.
Copying the folders by hand
Copy each skill's folder (the one containing SKILL.md) into your agent's directory:
| Agent | Folder |
|---|---|
| Claude Code | `.claude/skills/` |
| Codex, Gemini CLI, GitHub Copilot, Antigravity | `.agents/skills/` |
| Cursor | `.cursor/skills/` (also reads `.agents/skills/`) |
| Windsurf | `.devin/skills/` (also reads `.windsurf/skills/`) |
| Cline | `.cline/skills/` |
| Kiro | `.kiro/skills/` |
The test: a Phaser platformer with Claude Code
We created an empty project with phaser@4.2.1 in package.json, copied the router and the 77 skills into .claude/skills/ and gave Claude Code this prompt in non-interactive mode (originally in Spanish):
I want a minimal 2D platformer in Phaser that opens from index.html
(load node_modules/phaser/dist/phaser.js). Rectangle player, ground and
3 platforms, double jump with coyote time and jump buffer. No external
assets. When done, say which skills you loaded and why.It took 31 seconds and cost 0.18 USD. Its tool log shows it loaded three skills: phaser-core, phaser-arcade-physics and platformer. It never called the router: Claude Code already sees the descriptions of all 78 skills and went straight to the ones that matched. It skipped input-systems and physics-tuning as unnecessary for such a small project, and said so.
The result was two files (index.html and a 100-line game.js) that follow what the skills ask for: state is reset in init() rather than in the scene constructor, platforms live in a staticGroup, the collider is registered once in create() and the ground check uses body.blocked.down. The core of the jump looks like this:
const JUMP_VELOCITY = -460;
const COYOTE_TIME = 0.1; // s after leaving the ground when you can still jump
const JUMP_BUFFER = 0.12; // s a jump press is remembered before landing
const MAX_AIR_JUMPS = 1; // one extra jump in the air => double jump
const JUMP_CUT = 0.45; // releasing early cuts the rise
// ...inside update():
if (this.buffer > 0) {
if (this.coyote > 0) {
body.setVelocityY(JUMP_VELOCITY); // ground or coyote-time jump
this.coyote = 0;
this.buffer = 0;
} else if (this.airJumps > 0 && pressed) {
body.setVelocityY(JUMP_VELOCITY); // double jump, fresh press only
this.airJumps--;
this.buffer = 0;
}
}
if (released && body.velocity.y < 0) body.setVelocityY(body.velocity.y * JUMP_CUT);We opened it in Chromium with Playwright, simulated the keyboard and logged the player's position every frame. No console errors, and the double jump works:
What we found when playing it
The code is correct, but the level isn't built for that jump. With a velocity of -460 and gravity of 1100, a single jump rises about 96 px, and in our test it never passed 92. The first platform sits 130 px above the ground and the other two are 100 px above the previous one. Result: no step can be climbed with a single jump, every one needs the double jump. The player also spawns right under the first platform and bonks its head if it jumps there.
That's exactly what the platformer skill tries to prevent: it says to set jump height in tiles and place platforms from it. Claude loaded the skill but picked the numbers by eye and didn't measure the level. It also skipped the asymmetric gravity (faster fall than rise) the skill recommends against floaty jumps. The skills improve code structure, but they don't replace playing what the agent builds. Ask "check that every platform is reachable with a single jump" or "derive gravity and velocity for a 3-tile jump" and it fixes it.
What it doesn't do
- It doesn't run your game. These are instructions. To check the result you need the engine or a browser; some skills ship helper scripts (
check_godot_project.py,check_ebitengine.py, an Ebitengine project generator) the agent can run if you allow it. - It doesn't make art on its own.
create-game-assetsis an art-direction workflow (brief, asset manifest, one approved reference image before producing the full family) and only uses animagegenskill if your agent has one. - It isn't light if you install everything. The 78 skill descriptions add up to about 31,000 characters, close to 8,000 tokens the agent keeps in view every session. If you use one engine, install its bundle.
Common errors
The skills CLI fails to install. Check node -v: it needs Node.js 22.20 or later.
The agent doesn't load any skill. Skills trigger on their description. Name the engine or genre in your request ("in my Godot game", "a roguelike") or ask directly: "use the platformer skill".
The code uses an API from another engine version. The skills tell the agent to read your project's version (project.godot, ProjectVersion.txt, package.json and its lockfile, Cargo.lock). If those files don't exist yet, state the version in your request.
The router says there's no skill for your case. That's by design: instead of inventing a skill, it loads the closest one for the same engine and says so. UI in Defold is one example.
FAQ
Is it free? Yes. It's a public repository under Apache-2.0.
Does it work with Codex, Cursor or Gemini CLI? Yes. They use the same SKILL.md format; only the target folder changes.
Do I need the router in Claude Code? Not strictly: in our test Claude picked the skills without it. It helps most when you don't know which skill applies, when a project mixes engines, or in agents that read fewer descriptions.
Can I use it for a commercial game? Yes. Apache-2.0 allows commercial use. Its obligations (keeping LICENSE and NOTICE) apply when you redistribute the skills, not to your game's code.
Which engine should I start with? The one you already know. If you have no preference, Godot has the best coverage in the catalog and is the router's default.
Conclusion
awesome-gamedev-agent-skills is the most complete set of game dev skills we've seen: pinned versions, 12 engines and genre skills that compose with them without repeating code. In our Phaser test the agent picked the right skills and wrote clean code, but didn't apply the jump tuning the skill itself describes. Install only your engine's bundle, play what it builds and ask it to measure the level. If you want an agent that plans and tests before coding, pair it with Superpowers.
// source code
Help us grow
codigoagente is free, with no paywalls. If this article helped you, any of these keeps the blog going.
- Share it with someone who'll find it usefulWhatsAppLinkedInXFacebook
- Meet our sponsorSafe Build Labs
More on AI agents

guide · The complete ECC guide for Claude Code · #8
- Security and code review
- Claude Code

guide · The complete ECC guide for Claude Code · #7
- Claude Code
- Skills for your agents

guide · The complete ECC guide for Claude Code · #6
- Claude Code
- Skills for your agents