About this skill

Problem to Solve

Building a small game often fails not because of one missing API, but because the path from gameplay to a runnable prototype is unclear: type is undefined, engine choice is ad hoc, game loop and state transitions are muddled, and code lacks performance constraints. This skill turns that path into an engineering workflow, helping you move from “I want to make a game” to a verifiable core mechanic.

How It Works

It proceeds as a game development engineer role:
- Define the game type and core gameplay first, avoiding feature creep.
- Select a suitable engine, such as Unity, Godot, Unreal, or Pygame.
- Design the game loop and state machine, clarifying input, update, and render boundaries.
- Build a runnable core prototype, such as a PlayerController, movement, or collision logic.
- Add resource management and frame-rate stability, emphasizing patterns like ECS and state machines.

Boundaries and Notes

It is best for early stack selection, gameplay prototyping, and engine-level questions; it does not cover art, audio, publishing, or full product architecture. For an existing codebase, use it mainly to review game loops, state management, and performance constraints.

Screenshots

Use Cases

A solo developer is building a 2D platformer and needs to define core gameplay, choose Pygame or Godot, and write a movement prototype.
A course instructor is leading a turn-based combat demo and needs to break down the game loop, state machine, and runnable character controller.
A front-end engineer is starting with a web mini-game and needs to evaluate Pygame or Unity, then implement input, update, and render boundaries.
A small team is prototyping a Roguelike and needs to define core gameplay before organizing collision, movement, and resource management with ECS or state machines.

Best For

Junior indie developers building a 2D platformer from scratch, needing engine selection and a core movement prototype.
Front-end engineers leading small course projects, needing clear game loops, state machines, and runnable code.
Indie game teams validating prototypes, needing Unity, Godot, Unreal, or Pygame evaluation and core gameplay implementation.
Technical game designers focused on frame-rate stability, needing to translate gameplay rules into game loops and state machines.