Agentic Gamedev Skills

English | 日本語

This repository collects agent skills extracted from game-development work and related agentic-workflow research. Each skill lives under .agents/skills/, uses SKILL.md as its entry point, and may include references/, assets/, scripts/, tools/, or agents/ directories.

The main use case is building mini-games with one-button controls, strong visual feedback, procedural audio, telemetry-guided tuning, and optional pixel-art assets. A few adjacent skills support that workflow: skill extraction, workflow refinement from real execution artifacts, and gating or dispatching expensive agent work.

Games built with these skills live in agentic-gamedev-games.

How To Use

• Invoke a skill by name, or let the task trigger the skill through its description field.
• Treat each SKILL.md as the canonical workflow for that capability.
• Use AGENTS.md for repository-level maintenance rules.

Plugin Distributions

Six repository-hosted plugins package the skills for Codex and Claude Code. Their version 0.1.0 installable roots and catalogs are generated from the canonical skills and compositions in this repository. They become available from GitHub after the reviewed change is committed and pushed. GitHub distribution is separate from submission to an OpenAI or Anthropic curated directory. See the maintainer guide for regeneration, validation, versioning, and the publication boundary.

Plugin	Skills
One-Button Game Builder	7
Gameplay Verification & Debugging Toolkit	5
Retro Arcade Game Finisher	5
Godot Mini-Game Builder	4
Web Mini-Game Kit	4
Agent Workflow Engineering	9

The bundles cover 32 local skills with 34 memberships; externally referenced skills are excluded.

After GitHub publication, Claude Code users can add abagames/agentic-gamedev-skills as a marketplace and install <plugin>@agentic-gamedev-skills. Codex CLI users can add the same owner/repo marketplace, list available plugins, and install <plugin>@agentic-gamedev-skills; workspace administrators can import the GitHub repository through plugin management. The repository contains the standard Codex catalog, an API-key-login Codex catalog, and the Claude Code catalog. Maintainers regenerate them with python3 tools/plugin-bundles/published.py --repo . --write.

Skill Authoring Conventions

Local skills follow Anthropic's Skill authoring best practices where practical:

• Names use lowercase letters, numbers, and hyphens.
• New local skills should prefer gerund-style names, such as designing-mini-games.
• Descriptions should state what the skill does and when to use it, written in third person.
• SKILL.md should stay concise and point to references/, assets/, scripts/, tools/, or agents/ only as needed.
• Keep load-bearing decisions and the shortest complete workflow in SKILL.md; route variant setup, technique catalogs, long examples, and conditional edge cases to directly linked references/ with explicit read conditions.
• Do not preserve project validation history in the executable skill body. Retain only the generalized rule or failure mode that changes future agent behavior.

External imported skills may keep their upstream names and structure.

Bundled Skills

Game Design

Skill	Purpose
designing-mini-games	Designs original mini-games — rules, controls and physical bindings, scoring, hazards, and difficulty curves — for any input scheme, including one-button games. It helps prevent idle, hold-only, or button-mashing strategies from becoming optimal.
designing-minimal-game-rules	Turns an abstract game-design seed into a minimal discrete-state rule system by generating conflict candidates, stress-testing simple strategies, and reducing to the smallest surviving core.
generating-retro-arcade-concepts	Batch-generates, evaluates, and specs multiple fixed-screen arcade game concepts in the style of 1978–1985 cabinets, then selects and writes implementation specs for the top concepts.
verifying-turn-based-games	Defines a pure-function engine interface contract and quality measurement methodology (bot-ladder win-rates, tension/decision-density metrics) for two-player strict-alternating-turn games.

Game Implementation

Skill	Purpose
scaffolding-godot-mini-games	Scaffolds a minimal Godot 4.2+ mini-game project with Web export defaults, tests, telemetry helpers, and procedural audio primitives.
running-headless-godot	Defines reproducible headless Godot workflows for CLI usage, logs, scene editing through scripts, tests, and Web export.
developing-with-crisp-game-lib	Implements or repairs browser mini-games with crisp-game-lib, including input bindings, library-owned versus custom arcade cycles, drawing-order collision, scoring, audio setup, and validation.
arcadifying-mini-games	Converts a working mini-game into a complete arcade game by adding rounds, ceremony screens, score economy, visible initials entry and rankings, and replay- or autopilot-driven attract mode around a verified core loop.
implementing-gameplay-invariants	Translates game design promises into engine-neutral implementation invariants, player-visible readouts, and validation checks that prevent monotonous strategies or hidden rules from dominating play.

Game Presentation

Skill	Purpose
directing-game-visuals	Defines readable visual hierarchy, palette roles, screen composition, event feedback, and optionally runtime-probeable visual contracts without relying on explanatory HUD text.
maximizing-game-feel	Adds engine-independent tactile feedback such as squash/stretch, tilt, particles, trails, and impact polish to make gameplay feel more responsive.
creating-godot-procedural-audio	Designs and implements runtime procedural audio in Godot using built-in APIs, with distinct sounds for gameplay events and state changes.
building-era-authentic-game-audio	Designs, implements, and validates a complete game-specific procedural audio system with BGM, SE, jingles, event wiring, voice arbitration, and explicit era-inspired or hardware-faithful constraints.
styling-web-game-typography	Implements readable, licensed typography for distributed games (web export, downloadable, packaged), engine-agnostic at the core with Godot 4.2+ implementation patterns provided as a reference.
designing-retro-arcade-sound-kits	Designs and validates event-driven retro-arcade sound kits (SFX and jingles) where game code emits abstract event names and an adapter layer resolves and plays them. Engine-agnostic; prevents SEs from drifting into background music.
generating-dot-assets	Generates transparent pixel-art object assets by combining image generation, chroma-key removal, pixelization, exact canvas fitting, and validation.

Evaluation And Tuning

Skill	Purpose
evaluating-gameplay-balance	Evaluates balance through telemetry by comparing monotonous and exploratory policies with deterministic seeds or calibrated non-deterministic bands, including simulation, instrumentation, and structural repair guidance.
gating-intent-legibility	Measures whether an isolated grader who never saw the design or source can read a game's goal, options, and risk off sampled gameplay frames, with a withheld follow-up frame as oracle and a degraded control, returning intent, decision-variety, and entry-point verdicts.

Gameplay Verification And Debugging

Ordered from the cheapest gate to the most expensive instrument: runtime health, spec conformance, coverage of behavior families, defect localization, repair validation, and measurement of the instruments themselves.

Skill	Purpose
smoke-testing-web-games	Smoke-tests a browser game build headlessly with idle time and input bursts, failing on console errors, uncaught exceptions, or crashes. Catches code that passes mock or simulator tests but crashes in a real browser.
probing-web-game-mechanics	Verifies browser-game mechanics through maintained debug contracts, state injection, transition assertions, visual-contract checks, screenshots, and UI-binding probes. Sits between smoke testing and balance evaluation.
auditing-gameplay-implementation-coverage	Audits bounded gameplay surfaces across specification, implementation, presentation, and tests to find missing sibling cases and concrete probe gaps.
localizing-game-state-divergence	Replays a deterministic defect and finds the first event where a mechanically checked state invariant fails.
adversarially-validating-game-repairs	Stress-tests an existing game repair with patch-reachable adversarial and inverse cases, returning reproducible patch evidence.
generating-semantic-game-mutants	Plants controlled gameplay defects, clean controls, and equivalent mutants to measure a test suite's detection power or an agent workflow's repair behavior.

Agent Workflow

Skill	Purpose
extracting-agent-skills	Distills reusable agent procedures, validation loops, debugging methods, and decision rules from completed, paused, abandoned, or failed projects.
extracting-spec-design-ladders	Reverse-engineers source code into a concrete reproduction spec and an abstract design doc while preserving the qualitative contact, boundary, goal, and failure rules needed to restore the core loop.
gating-by-blind-restoration	Validates an abstraction layer through an isolated blind reconstruction followed by comparison with a withheld rule key, returning whole-artifact and per-load-bearing-rule transmission verdicts.
gating-expensive-batch-work	Splits a batch of expensive per-item agent work into a cheap reversible pass over every item and an expensive irreversible pass, separated by a method-freeze checkpoint, so a wrong rubric or transform is found before fresh seeds, held-out data, or one-shot quota are spent.
migrating-agents-md-to-control-flow	Audits large repo agent instruction files, then moves repeatable workflows into skills, mandatory checks into scripts/hooks/CI, and stable policy back into concise repo instructions.
refining-workflows-from-artifacts	Refines reusable agent workflows from real execution artifacts by classifying failure causes before proposing the smallest evidence-based workflow diff.
critiquing-own-response	Re-examines the agent's own immediately preceding response as an advisory pass over assumptions, logical gaps, alternatives, and unverified claims. Invoke explicitly; it shares blind spots with the answer it critiques, so it is not independent quality assurance.
dispatching-agent-work	Routes substantive work to suitable execution boundaries while requiring objective, artifact, authority, lifecycle, model-role, and reasoning-effort continuity before reusing a worker. Persistent dispatch mode remains opt-in.

Supporting Directories

• references/: detailed guides, checklists, design templates, and implementation patterns.
• assets/: reusable templates, Godot scripts, fonts, or other project assets.
• scripts/: automation for asset generation, validation, or related workflows.
• tools/: repository maintenance utilities, such as README/skill-list checks and external skill installation.
• agents/: optional model- or agent-specific configuration used by a skill.

External Skill References

The following individual skills are imported or referenced from other repositories because they complement a specific local workflow. They are listed in .gitignore so they can be evaluated or used locally without being committed here. tools/install-external-skills.sh fetches the supported entries; reference-only entries are reviewed and adapted individually rather than installed as a whole upstream collection.

• empirical-prompt-tuning: iterative methodology for evaluating and improving prompts, skills, slash commands, and AGENTS.md-style guidance.
• writing-for-agents: reference for making agent-facing skills, instructions, specifications, and prompts predictable by tightening completion criteria, controlling context load, and pruning no-op, duplicated, or stale guidance. Use alongside extracting-agent-skills and refining-workflows-from-artifacts; keep this repository's frontmatter convention when upstream invocation metadata differs.
• source-driven-development: version-aware implementation workflow grounded in official documentation. Use alongside developing-with-crisp-game-lib, running-headless-godot, or scaffolding-godot-mini-games when behavior depends on a current engine, browser, or library API; it complements those domain workflows without replacing their project-specific validation.
• browser-testing-with-devtools: live-browser diagnosis using console, network, DOM, and performance evidence. Use after smoke-testing-web-games or probing-web-game-mechanics localizes a browser-game problem that needs deeper runtime investigation; adapt the workflow when Chrome DevTools MCP is unavailable.
• performance-optimization: measure-first performance investigation and before/after verification. Use as a source for extending smoke-testing-web-games or maximizing-game-feel with performance gates, replacing general Web-app targets with game-relevant frame time, input latency, memory growth, load size, and representative-device budgets.
• systematic-debugging: root-cause-first debugging workflow for bugs, test failures, and unexpected behavior. Not installed by default: it claims every technical issue as its trigger, so it outranks localizing-game-state-divergence, adversarially-validating-game-repairs, smoke-testing-web-games, and probing-web-game-mechanics rather than complementing them, and its Phase 4 points at superpowers: sibling skills this repository does not carry. Pull it by name (install-external-skills.sh systematic-debugging) for non-game work, or for crashes, build failures, and multi-component boundary isolation, which the local debugging skills deliberately exclude.

Repository Tools

• tools/install-external-skills.sh — stage and validate supported external skills before replacing .agents/skills/<name>/; failed updates preserve the installed version. Reference-only entries above are not automatic targets.
• tools/check-readme-skills.sh — verify local skill directories and external .gitignore entries against this README. Exits non-zero on drift.
• tools/tests/test-repository-tools.sh — exercise installer success, failure recovery, path containment, and README consistency without network access or changes to installed skills.
• python3 tools/plugin-bundles/build.py plugin-bundles/<bundle>.json --target codex|claude — build a self-contained plugin with a v3 payload hash/mode inventory. --publishable gates clean inputs; it does not imply strict reproducibility or official approval. Rebuild ignored dist/ outputs instead of editing or committing them.
• tools/tests/test-plugin-bundles.sh — validate compositions, generated artifacts, deterministic skill hashes, and rejection of unsafe or malformed inputs.
• python3 tools/plugin-bundles/published.py --write|--check — regenerate or verify the six tracked plugin roots and the Codex, Codex API-key, and Claude catalogs from compositions and canonical skills. The check rejects stale payloads, missing or extra roots, path escape, and identity/version drift.
• python3 tools/plugin-bundles/package.py --output <new-dir> — build and round-trip all six bundles as ZIPs with checksums and a validation report. See the release guide for platform validator options.