Skip to content
Skills Library
Programming · Building & coding

game-dev

/game-dev

Use when the user wants to build, prototype, or architect a 2D browser game — e.g. "make a game", "build a platformer/shooter/word game/stickman game", "let's build a 2D game", or any request to start game systems from scratch for the web. Drives a strict discovery-interview → system-by-system build-and-test loop, using in-browser testing after every system.

Licence
MIT
Last repository change
23.08.2026

Assessment and security

100/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content35 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
6
Scripts
0
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 23.08.2026, without references to retired models or APIs.

Licence

MIT, open: use and modify while retaining author attribution.

What it does and when to use it

Use when the user wants to build, prototype, or architect a 2D browser game — e.g. "make a game", "build a platformer/shooter/word game/stickman game", "let's build a 2D game", or any request to start game systems from scratch for the web. Drives a strict discovery-interview → system-by-system build-and-test loop, using in-browser testing after every system.

Triggers from the description

make a gamebuild a platformer/shooter/word game/stickman gamelet
Original author description

Use when the user wants to build, prototype, or architect a 2D browser game — e.g. "make a game", "build a platformer/shooter/word game/stickman game", "let's build a 2D game", or any request to start game systems from scratch for the web. Drives a strict discovery-interview → system-by-system build-and-test loop, using in-browser testing after every system.

How it works

  1. Scope
  2. The discipline this skill enforces
  3. Phase 0 — Resume / Existing-Project Check (run this before anything else)
  4. Phase 1 — Discovery Interview (new projects only — see Phase 0)
  5. Phase 2 — Tech Stack Selection
  6. Phase 3 — Scaffold
  7. Phase 4 — Build Loop (strict — this is the core of the skill)
  8. Phase 5 — Testing Protocol (run after every single system)
  9. Phase 6 — Assembly & Playtest
  10. Ongoing discipline
Original SKILL.md headings · 194 lines, 1,481 words
SKILL.md preview
---
name: game-dev
description: >-
  Use when the user wants to build, prototype, or architect a 2D browser
  game — e.g. "make a game", "build a platformer/shooter/word game/stickman
  game", "let's build a 2D game", or any request to start game systems from
  scratch for the web. Drives a strict discovery-interview → system-by-system
  build-and-test loop, using in-browser testing after every system.
license: MIT
---

# 2D Game Dev — Build & Test Loop

## Scope

This skill is for **2D, browser-based games** (HTML5/Canvas/WebGL via JS or TS).
If the user wants 3D, a native (non-web) target, or a specific engine like
Unity/Unreal/Godot, say so explicitly and ask whether they still want you to
proceed with adapted guidance — don't silently force it into the web mold.

## The discipline this skill enforces

Solo game projects die from two things: never nailing down what the game
actually is, and building five systems in parallel none of which actually
work. This skill exists to prevent both. Follow the phases below **in
order**. Do not skip the interview. Do not build more than one system at a
time. Do not mark a system done without watching it work in a real browser.

---

## Phase 0 — Resume / Existing-Project Check (run this before anything else)

Before doing anything else, check the project root:

1. **`GAME_SPEC.md` already exists** → this is a resumed project, not a new
   one. Read `GAME_SPEC.md` and `SYSTEMS.md` in full. Do **not** re-run the
   Phase 1 interview. Jump straight to Phase 4 and continue at the first
   system in `SYSTEMS.md` that isn't `done`. Briefly confirm your read of
   where things stand with the user before writing any code, in case
   something changed since the last session.
2. **No `GAME_SPEC.md`, but a project already exists** (a `package.json`,
   an existing `src/`, etc.) → an established project the skill wasn't
   used to start. Don't scaffold over it. Read what's there (stack,
   structure, existing game logic), then run Phase 1 to establish
   `GAME_SPEC.md`, and do Phase 3 adapted to build `SYSTEMS.md` and a dev
   level *around* the existing code rather than a fresh scaffold.
3. **Neither exists** → genuinely new project. Proceed to Phase 1 normally.

---

## Phase 1 — Discovery Interview (new projects only — see Phase 0)

Never assume genre, platform, or scope on the user's behalf. Ask, using
`AskUserQuestion`.

### Round 1 — always ask these together

1. **Game type/genre.** Offer concrete options plus a free-type escape hatch:
   Platformer · Side-scroller / endless runner · Shooter (top-down / arcade /
   bullet-hell) · Stickman or ragdoll physics · Puzzle · Word game ·
   Simulation / idle · Top-down adventure or action · Other (let them
   describe it in their own words — never force a freeform idea into one of
   the listed buckets if it doesn't fit).
2. **Target platform.** Desktop (keyboard/mouse) · Mobile (touch) · Both.
   This decides input abstraction and layout from the start, not as an
   afterthought.
3. **Art approach.** Placeholder/programmer art (ship fast, swap later) ·
   Pixel art · Vector/flat shapes · "I already have assets."
4. **Scope.** Quick prototype (one core loop, a handful of systems) · Full
   small game (multiple levels/content, a polish pass).

### Round 2 — genre-specific follow-ups

Derive 2–4 follow-up questions from whatever genre came out of Round 1.
Don't ask a static checklist — pick what's actually decision-relevant. Examples:

- **Platformer:** jump feel (floaty vs snappy)? Single screen or multi-level? Enemies/hazards?
- **Side-scroller/runner:** auto-scroll or player-driven? Endless or level-based? Obstacle pattern style?
- **Shooter:** perspective (top-down/side-on)? Free movement or rail? How complex are bullet patterns?
- **Stickman/ragdoll:** physics-driven skeleton or animated? Combat, sandbox, or platformer-with-ragdoll?
- **Word game:** curated word list or full dictionary? Single-player or turn-based multiplayer? Grid-based or freeform?
- **Simulation/idle:** what's being simulated? Real-time or tick-based? How deep is the progression/economy?
- **Puzzle:** core mechanic (match / physics / logic)? Level-based or endless/procedural?
- **Other (freeform description):** ask them to state the core loop in one sentence, then confirm your read of it back to them before proceeding — don't guess silently.

### Write the spec

Once both rounds are answered, write `GAME_SPEC.md` in the project root
using `references/game-spec.template.md` as the structure: genre, platform
target(s), art approach, scope, every genre-specific answer, plus a
one-paragraph "core loop" summary in your own words. This file is the
**source of truth** for the rest of the build — every later phase reads it,
and scope creep beyond it requires asking the user first, not deciding
unilaterally.

---

## Phase 2 — Tech Stack Selection

Read `references/libraries.md` — it's a curated knowledge base of the 2D
web game libraries available (engines, physics, audio, tilemaps, word-list
sources, mobile input, bundler). Pick the smallest stack that actually
satisfies `GAME_SPEC.md`. Default bundler is Vite unless there's a reason
not to. State the chosen stack and a one-line reason to the user; only ask
for confirmation if two real options are genuinely close and the tradeoff
matters to them (e.g. Phaser vs. raw PixiJS when physics needs are unclear).

---

## Phase 3 — Scaffold

1. If Phase 0 found an existing project, skip fresh scaffolding entirely —
   map the existing code onto the system list in step 3 below, and add the
   dev level alongside the existing structure instead of replacing it.
   Otherwise, scaffold the project with the chosen bundler/library.
2. If the project isn't already a git repository, run `git init` now. The
   checkpoint commits in Phase 4 depend on it, and it's cheap to set up
   before any code exists.
3. Build the **dev level** — a persistent sandbox scene/route used to test
   systems in isolation, per `references/dev-level.md`. This is not
   throwaway scaffolding: it stays in the repo for the life of the project
   as the QA harness.
4. Write `SYSTEMS.md` using `references/systems.template.md` as the
   structure — the build checklist. Derive the initial system list from
   `GAME_SPEC.md` (genre + platform), e.g.: input/controls, core movement,
   collision, camera, the genre-defining mechanic, UI/HUD, audio, mobile
   touch input (if mobile was requested), save/progress (if the scope calls
   for it), level/content loading. Each row: system name, status
   (`pending` / `building` / `testing` / `done`), test notes. Show this
   list to the user before starting Phase 4 so the build order is visible
   and correctable.

---

## Phase 4 — Build Loop (strict — this is the core of the skill)

Non-negotiable rules:

1. Build **exactly one system at a time**, in `SYSTEMS.md` order top to
   bottom. Reorder only when a real dependency forces it, and note why in
   the file when you do.
2. Never write code for the next system before the current one is tested.
3. The instant a system is implemented, test it in the dev level (Phase 5)
   before touching anything else.
4. A failed test means fix-and-retest the **same** system. Do not move on
   carrying a known-broken system.
5. Only mark a system `done` in `SYSTEMS.md` after watching it pass in an
   actual browser per Phase 5 — "the code looks right" is not a pass.
6. Immediately after marking a system `done`, commit it (`git add` the
   changed files + `SYSTEMS.md`, commit with a message naming the system).
   This is the rollback point if a later system's changes break something
   already working — don't batch multiple systems into one commit.
7. Once every system in the list is individually verified, proceed to
   Phase 6.

---

## Phase 5 — Testing Protocol (run after every single system)

Read `references/testing-protocol.md` and follow it exactly. In short:
prefer `claude-in-chrome` when it's available and permitted for the local
dev server; otherwise fall back to Playwright. Every test cycle: serve the
project, load the dev level for the system under test, exercise it,
screenshot, read the console for errors, confirm the expected behavior
actually happened, then log the result (pass/fail + note) in `SYSTEMS.md`.

---

## Phase 6 — Assembly & Playtest

Once all systems pass individually, wire them together into real
levels/content per `GAME_SPEC.md`. Do a full playthrough using the same
browser-testing tool from Phase 5, exercising every platform target that
was declared (simulate touch input if mobile was in scope, keyboard/mouse
if desktop was). Log findings in `PLAYTEST.md`.

### When is it actually done

Check against the scope declared in `GAME_SPEC.md`:

- **Quick prototype** — done once the core loop is playable start-to-finish
  with no crashes and every declared system passes its test. Rough edges
  (placeholder art staying placeholder, no audio polish, minimal content)
  are expected and fine — don't gold-plate a prototype.
- **Full small game** — done once, in addition to the above: there's more
  than one level/content unit, the polish pass the user asked for in Phase
  1 has actually happened (not just planned), and the full playtest above
  has been run on every declared platform with no open issues in
  `PLAYTEST.md`.

If it's unclear which bar has been met, ask the user rather than declaring
the project finished unilaterally.

---

## Ongoing discipline

- `GAME_SPEC.md` and `SYSTEMS.md` are living documents — re-read them at the
  start of any later session before continuing work, instead of re-deriving
  context from scratch.
- Never expand scope beyond `GAME_SPEC.md` without asking the user first.
- If the user asks for something new mid-build, add it to `GAME_SPEC.md` and
  `SYSTEMS.md` explicitly rather than quietly folding it into the current system.
Files in this package (6)
  • SKILL.md 10 KB
  • references/dev-level.md 3 KB
  • references/game-spec.template.md 1 KB
  • references/libraries.md 9 KB
  • references/systems.template.md 1 KB
  • references/testing-protocol.md 4 KB

Versions

RepositoryScoreLicence
This page · sudhanshu5669/html5-gamedev-skill100MIT
dreamlab-ai/agentbox100AGPL-3.0
sandbaseai/sandbase-skills100Apache-2.0
bigy0shi/super-skills100MIT

Database snapshot: 13.11.2026 · package version 4cc75b171ba7 (SHA-256 digest of the entire package)

Downloads in the last 30 days: 1 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 90build-full-game
    End-to-end pipeline for building a complete, playtested browser game from a one-line idea with the studio's subagents. Use when the user asks to make, build or create a game ("make me a game where...", "oyun yarat", "oyun düzəlt") and no /new-game command is available in the host.
  • 100game-architecture
    Game architecture patterns and best practices for browser games. Use when designing game systems, planning architecture, structuring a game project, or making architectural decisions about game code.
  • 100harmony-make
    Make a whole web game from an idea - a thorough interview in rounds that settles every part of the game and pushes back on vague answers and oversized scope, a short design brief the developer approves, then the game built in playable stages and packaged for upload to Harmony.…
  • 100game-vibe-code
    Runs an AI-agent build loop from idea to a playable, verified, shippable game: one-page spec, playable in the first hour, one feature per iteration with a pass/fail check, Playwright screenshots, commits and a progress.md handoff. Use for "vibe code a game", "build a game with…
  • 100threejs-game
    Build 3D browser games with Three.js using event-driven modular architecture. Use when creating a new 3D game, adding 3D game features, setting up Three.js scenes, or working on any Three.js game project.
  • 90gds-agent-game-architect
    Game systems architect for technical architecture, engine design, and infrastructure. Use when the user asks to talk to Cloud Dragonborn or requests the Game Architect.

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.