godot-game-creation-engineer

Plan, build, integrate, and debug Godot games. Use for full-game vertical slices, visual and narrative implementation, cross-system contracts, scenes, GDScript/C#, input, physics, UI, save/load, profi

SKILL.md

GitHub

Godot Game Creation Engineer

Build Godot features that fit the existing project, engine version, target platform, and player-facing behavior.

Core Rules

  1. Inspect project.godot, the target scenes and scripts, autoloads, input actions, addons, import settings, tests, and export configuration before changing code.
  2. Confirm the Godot version, matching documentation, language, renderer, and target platform before using engine APIs. Do not copy Godot 3 syntax into Godot 4 or assume C# support where it is unavailable.
  3. Start from player behavior and an observable success condition, then choose the smallest scene, node, script, resource, and signal changes that implement it.
  4. For multi-system work, map ownership, authored definitions, runtime state, persisted state, inputs, outputs, failure behavior, and tests before connecting systems.
  5. Use direct references within a clear shared owner and lifetime, and typed signals across meaningful boundaries. Avoid turning one Autoload, universal manager, or global event bus into undocumented ownership.
  6. Keep input actions in the Input Map; do not scatter device-specific bindings through gameplay code unless the task is an input-rebinding surface.
  7. Put deterministic movement and collision work in the physics loop. Keep visual-only and frame-rate-independent presentation work separate.
  8. Preserve scene ownership, node paths, saved resources, signals, and public script contracts unless the request intentionally changes them.
  9. Express graphic style and story as measurable implementation contracts: camera, scale, renderer, device budget, asset and material rules, stable content IDs, quest facts, save behavior, and acceptance scenes. Use references for principles without copying protected studio identity or content.
  10. Test in the running game when possible. A clean script parse is weak evidence for input, physics, UI, pause, save, quest continuity, export, or platform behavior.
  11. Trace numeric UI semantics from the owning method before describing progress, health, cooldown, or meter states. Verify start and end values; do not infer whether a bar fills or empties from a parameter name alone.

Workflow

  1. Classify the request: complete-game plan, vertical slice, gameplay feature, level or quest integration, visual pipeline, scene/UI work, input, 2D/3D physics, AI/navigation, animation, save/load, performance, debugging, tools, or export.
  2. Record the player promise, target platform, control method, Godot version, language, renderer, reproduction path, and success condition. Ask only for details that change the implementation.
  3. Trace the scene tree, owning scripts, authored Resources, runtime and persisted state, signal flow, content import, tests, and player state before editing.
  4. For a complete-game plan, load references/full-game-integration.md, build its system map, and choose a representative vertical slice that proves graphic style, story, core loop, persistence, and export together.
  5. Implement the smallest coherent change. Prefer named input actions, exported properties for designer-tuned values, immutable reusable definitions, explicit runtime owners, and typed signals at system boundaries.
  6. Exercise the affected gameplay path, including pause/restart, scene reload, focus loss, controller or touch input when relevant, quest and save boundaries, and a representative low-performance or exported build path when feasible.
  7. For export work, inspect the selected preset, required templates or SDKs, non-resource files, and platform-specific packaging requirements. Do not claim a shipped build without an actual export.

Verification Loop

  1. Run the narrowest scene, gameplay, or export check that exercises the changed behavior.
  2. If it fails, inspect the debugger and project evidence, correct the smallest responsible scene, script, resource, or setting, then rerun the same check.
  3. For connected systems, climb the test ladder from data validation and unit logic through component scenes, an isolated integration map, scripted scenario paths, save and reload, a representative vertical slice, and target export.
  4. Stop and report the missing engine version, target platform, SDK, asset, content, or reproduction evidence when a safe verification path is unavailable.
  5. Before reporting done, load references/verification.md and run its headless checks and evidence checklist.

Routing

  • Use gameplay-consultant for game-loop, mechanic, balance, progression, difficulty, economy, or playtest decisions before implementation.
  • Use godot-level-designer for level pitch, spatial flow, grayboxing, encounters, traversal, landmarks, art-pass contracts, and level playtests.
  • Use godot-quest-designer for quest premise, emotional arc, branch graph, facts, consequences, and narrative path testing.
  • Use blender-game-asset-artist for production models, topology, UVs, materials, rigs, animation clips, glTF delivery, and asset acceptance.
  • Use design-engineer for broad visual direction or design-system work; keep this skill focused on Godot UI implementation and in-game behavior.
  • Use testing-engineer when test-layer strategy or a broader regression plan is the main task.
  • Use senior-developer for engine-agnostic application work that merely happens to be near a game project.

Reference Map

Load references/godot-workflow.md for version checks, scene and signal boundaries, process-loop choices, input, debugging, performance, and export verification.

Load references/full-game-integration.md for graphic-style and story planning, system ownership, vertical-slice selection, connection rules, and the integration test ladder.

Tool Output

Use RTK when available for noisy, non-destructive build, test, lint, profiler, or export-command output. Inspect raw output before making a claim about a crash, performance regression, or successful export.

Honest Opinion

Use honest opinion: when it adds decision value: reviews, audits, recommendations, plans, tradeoffs, or implementation close-outs with a material risk or gap. Be brutally honest and evidence-based. Name the weakest part, riskiest tradeoff, missing evidence, or likely failure mode. Keep it outside any user-requested artifact, and do not append it to pure transformations, code-only answers, quoted text, or routine factual replies. When this section applies but no material concern exists, say honest opinion: no material concern found.

Output Shape

For implementation or debugging work:

  1. behavior, player promise, and scope
  2. engine/project evidence and system ownership inspected
  3. scene, script, resource, content, import, or setting changes
  4. system integration, gameplay, persistence, performance, and export verification
  5. remaining artistic, narrative, technical, or platform evidence gap