vibe-game-developer

name	vibe-game-developer
description	Master orchestrator and workflow router for building 2D games in Go with Ebitengine. Coordinates the full game development lifecycle across concept design (GDD creation), engine architecture, asset pipelines (pure-code procedural vs. AI-generated media), animation controllers, and WebAssembly deployment. Activate when building a 2D game from scratch, planning game workflows, routing game asset requests, or managing end-to-end game projects.
license	Apache-2.0
metadata	{"category":"game-dev","tags":"game-dev, ebitengine, orchestrator, workflow, architecture, 2d","author":"Daniela Petruzalek ([e-mail])","version":"0.2.0","catalog":"https://skills.danicat.dev"}

Vibe Game Developer: Master Orchestrator & Request Router

This master skill teaches the agent how to analyze, classify, and route user game development requests to the specialized skill best suited for the task.

[!NOTE] Genre-Agnostic Design Principle: All skills and reference modules in this suite provide generic, highly adaptable building blocks suitable for any 2D game genre (puzzle, arcade, strategy, platformer, racing, rhythm, RPG, shmup, or simulation). Specific code examples (such as progress bars, jump gravity curves, or A* pathfinding) are illustrative patterns—apply and adapt only the components that fit the game's unique design and mechanics.

---

1. Skill Selection & Intent Routing Matrix

When responding to user requests, evaluate the underlying engineering need and activate the primary specialized skill according to this decision matrix:

User Intent / Request Type	Primary Specialized Skill	Key Technical Characteristics
Game Design & Concept Probing	game-design	Game Designer role: interactive /grill-me probing interview, mechanics, controls, art/audio strategy, and GDD.md creation.
Ebitengine 2D Game Architecture	ebitengineer	Ebitengine game loop, 16:9 canvas, FSM scene flow, WASM touch, Cloud Run deployment, plus 6 core engine modules: Physics/Collisions (AABB/Spatial Hash), Tilemaps/Autotiling, UI/HUD (9-slice/anchors), Action Mapping, Entity Pools/ECS, and A* Pathfinding/AI.
Pure-Code DSP Audio Synthesis	procedural-composer	Zero-asset runtime DSP sound engine (sound.go), YM2612 6-channel polyphony, FM synthesis, ADSR envelopes, JSON sound format, and CLI player (play.go).
Generative CD-Quality AI Music	lyria	High-fidelity 44.1 kHz stereo music (lyria-3-clip-preview & lyria-3-pro-preview), custom lyrics, section tags ([Verse], [Chorus]), multimodal image-to-music, and .mp3/.wav export.
Pure-Code Procedural 2D Graphics	procedural-art	Pure-code Go texture generation (art.go), 2D matrix transformation math (), 32-bit RGBA color ramps, non-linear easing, pre-allocated particle pools, and Kage shaders.

---

2. Decision Rules: Pure-Code Procedural vs. Generative AI Assets

A critical responsibility of this master skill is determining whether an asset request should be built procedurally in pure Go code or generated using Gemini AI models:

2.1 Audio & Music Routing Rules

• Choose procedural-composer when:

  • The user requests Game Sound Effects (SFX): button clicks, coin pick-ups, laser blasts, jumps, explosions, or UI audio cues.
  • The user requests retro chiptune audio, synthesized waveforms, or lightweight FM audio.
  • The game requires zero external .mp3/.wav dependencies or real-time dynamic pitch/filter manipulation during gameplay.
  • The user requests a JSON sound specification or code-driven audio engine implementation (sound.go).

• Choose lyria when:

  • The user requests Background Music (BGM): CD-quality 44.1 kHz stereo music tracks, full songs with custom lyrics, instrumental score beds, or BGM loops.
  • The user wants to compose background music matching a visual reference image or photo.
  • Output music must be exported as standalone .mp3 or .wav audio files.

---

2.2 Graphics & Visual Routing Rules

• Choose procedural-art when:

  • The user requests pure-code texture generation (art.go), vector geometry, dynamic particle systems (explosions, fire, magic), or custom Kage post-processing shaders.
  • The game requires zero disk I/O, infinite resolution scaling, or real-time palette swapping in Go memory.
  • The request involves matrix transformation ordering, sub-frame interpolation curves, or direct bitmap pixel crafting.

• Choose nano-banana when:

  • The user requests AI-generated concept art, character avatars, item icons, or AI pixel art sprites (16x16, 32x32, 64x64).
  • The request specifies character visual consistency for recurring characters, heroes, or NPCs across scenes.
  • The output is an image file (.png/.jpg).

---

3. Standard End-to-End Game Workflow

When guiding the user through building a complete 2D game from scratch:

1. Game Concept & GDD: Activate game-design (/grill-me) to probe player vision, define core mechanics, controls, art/audio strategy, and save GDD.md.
2. Architecture & Scope: Activate ebitengineer to set up package structure (internal/), 16:9 virtual pixel canvas, delta time ($dt$) 60 FPS timing, and FSM scene progression.
3. Visual Art & Sprites:
   • For UI/particle FX/vector geometry $\rightarrow$ Activate procedural-art.
   • For character concept art / AI pixel sprite sheets $\rightarrow$ Activate nano-banana + sprite-animation.
4. Sound Effects & Music:
   • For retro SFX & synthesized chiptunes $\rightarrow$ Activate procedural-composer.
   • For high-fidelity background music beds $\rightarrow$ Activate lyria.
5. Code Review & Quality Gate: Activate godoctor (smart_build, unit testing, Selene mutation testing) to ensure code correctness and test coverage.
6. Deployment: Activate ebitengineer to compile to WebAssembly and configure Google Cloud Run deployment with multi-stage Docker builds.