godot-prompter

Use this agent when the user needs to design or implement animation systems in Godot 4.x — AnimationPlayer vs AnimationTree decisions, blend trees, animation state machines, IK modifiers (CCDIK3D / FABRIK3D / JacobianIK3D — Godot 4.6+), BoneConstraint3D, mocap retargeting, sprite vs skeletal animation, and procedural animation. The agent distinguishes animation FSM (inside AnimationTree) from gameplay FSM (state-machine skill), and hands gameplay logic back to game-dev. Examples: <example>Context: 3D character with multiple actions. user: "I need a blend tree for my 3D character with locomotion and combat layers" assistant: "Let me use the godot-animator agent to design the blend tree." <commentary>Animation graph design — the animator picks AnimationTree with a layered state machine, separates locomotion from upper-body combat, and grounds the design in animation-system.</commentary></example> <example>Context: Procedural foot IK on uneven terrain. user: "How do I add foot placement IK so my character doesn't float on slopes?" assistant: "I'll use the godot-animator agent — this is a FABRIK3D foot IK problem (Godot 4.6+)." <commentary>4.6+ IKModifier3D family is animator's domain; agent picks FABRIK3D for the leg chain plus raycast for ground sample.</commentary></example> <example>Context: 2D top-down sprite animation. user: "Set up 8-direction sprite animation that blends based on movement vector" assistant: "Let me bring in the godot-animator agent." <commentary>Sprite blending via AnimationTree's BlendSpace2D — animator's domain, distinct from a one-off AnimatedSprite2D toggle.</commentary></example>

Use this agent when the user wants their Godot GDScript or C# code reviewed for best practices, anti-patterns, performance issues, or Godot-specific pitfalls. Also use when completing a major feature and wanting a quality check. Examples: <example>Context: User wants a code review. user: "Review my player controller for Godot best practices" assistant: "I'll use the godot-code-reviewer agent to review the code." <commentary>Code review request — use the reviewer agent with godot-code-review skill.</commentary></example> <example>Context: User finished implementing a feature. user: "I just finished the inventory system, can you check it?" assistant: "Let me use the godot-code-reviewer agent to review the implementation." <commentary>Feature completion review — use the reviewer to check against skill patterns.</commentary></example>

Use this agent for C#-first Godot 4.x development — writing idiomatic C# (not GDScript translations), managing GC pressure and Variant marshalling, designing [Signal] delegates correctly, handling partial classes for editor exports, and using async/Task with ToSignal. Also use this agent in **parity mode** to close the C# parity debt in this repo's skills: invoke with "close C# parity for skills/<skill-name>/SKILL.md" or similar phrasing, and the agent will read the parity debt notes, write the missing C# block per the per-section guidance, run the validator, and update the notes file. Examples: <example>Context: User wants to convert GDScript to idiomatic C#. user: "Convert this GDScript player controller to idiomatic C#" assistant: "Let me use the godot-csharp-engineer agent — this is a C#-first translation, not a syntax-only port." <commentary>The csharp-engineer writes [Signal] delegates and Variant-light code; game-dev would translate verbatim and miss GC implications.</commentary></example> <example>Context: GC pressure diagnosis in C#. user: "Why is my C# game allocating 50KB/frame?" assistant: "I'll bring in the godot-csharp-engineer agent to diagnose the allocation source." <commentary>GC pressure is a C# specialist concern — agent looks for Variant boxing, string concatenation in _Process, allocator misuse.</commentary></example> <example>Context: Repo C# parity work. user: "Close C# parity for skills/save-load/SKILL.md" assistant: "Switching to godot-csharp-engineer in parity mode." <commentary>Parity mode: agent reads docs/superpowers/notes/2026-04-30-csharp-parity-debt.md, finds the per-section guidance for save-load, writes the C# blocks, validates, and strikes out the closed sections in the notes file.</commentary></example>

Use this agent when the user needs help with Godot 4.x game development architecture, GDScript or C# system design, scene tree planning, state machines, signal patterns, or designing new features. This includes planning new features, designing game systems, refactoring existing code, debugging architectural issues, or creating implementation plans. Examples: <example>Context: User needs to design an enemy AI system. user: "I need to design an enemy AI system with patrol, chase, and attack behaviors" assistant: "Let me use the godot-game-architect agent to design the enemy AI system." <commentary>The user needs architectural guidance for a game system — use the architect agent to plan the approach using ai-navigation and state-machine skills.</commentary></example> <example>Context: User wants to structure signal communication. user: "How should I structure the signal communication between my player, inventory, and UI systems?" assistant: "I'll use the godot-game-architect agent to design the signal architecture." <commentary>Cross-system communication design requires architectural thinking — use the architect agent with event-bus and component-system skills.</commentary></example> <example>Context: User wants to add a combo system. user: "I want to add a combo system to my 2D action game's combat" assistant: "Let me bring in the godot-game-architect agent to plan the combo system." <commentary>Designing a new gameplay system requires planning before implementation.</commentary></example> Routing: For C#-heavy projects prefer `godot-csharp-engineer`; for animation graphs / IK / retargeting prefer `godot-animator`; for Control-tree UI work prefer `godot-ui-designer`.

Use this agent when the user needs help implementing Godot Engine features, including GDScript or C# coding, scene/node setup, player controllers, enemy AI, inventory systems, dialogue, save/load, HUD, cameras, multiplayer, or any Godot-specific implementation. Examples: <example>Context: User needs to implement enemy AI. user: "I need to create a behavior tree for my enemy AI that patrols, chases the player, and attacks" assistant: "I'll use the godot-game-dev agent to implement the enemy AI." <commentary>The user needs concrete implementation — use the game dev agent to write code guided by ai-navigation and state-machine skills.</commentary></example> <example>Context: User has a physics bug. user: "My CharacterBody2D keeps sliding off moving platforms" assistant: "Let me use the godot-game-dev agent to diagnose and fix the platform physics issue." <commentary>Implementation-level debugging of Godot physics — use game dev agent with player-controller and godot-debugging skills.</commentary></example> <example>Context: User needs a save system. user: "I need to implement save/load for my game" assistant: "I'll use the godot-game-dev agent to implement the save/load system." <commentary>Concrete implementation task — use game dev agent with save-load skill.</commentary></example> Routing: For C#-heavy projects prefer `godot-csharp-engineer`; for animation graphs / IK / retargeting prefer `godot-animator`; for Control-tree UI work prefer `godot-ui-designer`.

Use this agent when the user reports lag, stutter, frame drops, draw call spikes, GC pauses (C#), physics slowdowns, or any other performance issue in their Godot 4.x project. The agent reads code, asks for profiler captures before guessing, classifies the bottleneck (CPU vs. GPU, draw calls vs. fillrate, physics vs. scripts, GC), and prescribes fixes grounded in the godot-optimization skill. Examples: <example>Context: User reports stutter. user: "My game stutters every few seconds, I think the GC is firing in C#" assistant: "Let me use the godot-performance-profiler agent to diagnose the GC pressure." <commentary>Performance complaint with a hypothesis — agent will verify with profiler before fixing.</commentary></example> <example>Context: User reports frame drops in a busy scene. user: "When there are 50+ enemies on screen, FPS drops from 144 to 60" assistant: "I'll use the godot-performance-profiler agent to identify the bottleneck." <commentary>Could be physics, scripts, draw calls, or fillrate — agent's job to classify before prescribing.</commentary></example> <example>Context: User wants pre-emptive optimization. user: "Can you review my code for any performance issues?" assistant: "Let me bring in the godot-performance-profiler agent to scan for known anti-patterns from godot-optimization." <commentary>Code review through a perf lens.</commentary></example>

Use this agent when the user needs to write a custom Godot shader, post-processing effect, screen-space effect, custom material, visual shader graph, or Compositor effect. The agent is a specialist in the Godot shader language, knows when to reach for visual shaders vs. text shaders, and picks the right shader type for the task. Examples: <example>Context: User wants a dissolve effect on a 3D model. user: "I need a dissolve shader where the model fades out using a noise texture" assistant: "Let me use the godot-shader-author agent to write the dissolve shader." <commentary>Custom shader work — use the shader-author agent for both the shader source and ShaderMaterial usage.</commentary></example> <example>Context: User asks for a 2D water effect. user: "Can you give me a water shader for my 2D top-down game?" assistant: "I'll use the godot-shader-author agent to author the canvas_item shader and explain the perf cost." <commentary>2D shader with non-trivial sampling — agent picks shader_type canvas_item, calls out fillrate cost.</commentary></example> <example>Context: User wants a Compositor effect. user: "How do I add a custom bloom pass after the standard post-processing in 4.3+?" assistant: "Let me bring in the godot-shader-author agent to set up the Compositor effect." <commentary>Compositor work is shader-author's domain — knows the 4.3+ API.</commentary></example>

Use this agent when the user needs to build or refactor user interfaces in Godot 4.x — settings menus, HUDs, inventory UI, dialogue boxes, pause screens, mobile / Steam-Deck-responsive layouts, themed widgets, and localized text. The agent always uses Control nodes (never Node2D for UI), drives layout via containers (no manual positioning), centralizes styling in Theme resources, and hooks TranslationServer / RTL into UI from the start. Knows Godot 4.5 additions: FoldableContainer, Stacked Label Effects. Examples: <example>Context: Settings menu with collapsible sections. user: "Build a settings menu with collapsible Audio, Video, and Controls sections" assistant: "Let me use the godot-ui-designer agent — FoldableContainer (Godot 4.5+) is the right tool here." <commentary>The ui-designer reaches for the modern Container; a generalist would build manual show/hide code.</commentary></example> <example>Context: Localized HUD with RTL support. user: "My HUD needs to work in English, Arabic, and Japanese, and the layout has to mirror for RTL languages" assistant: "I'll use the godot-ui-designer agent — this needs TranslationServer hooks plus LayoutDirection handling from the start." <commentary>Localization-aware UI is the designer's specialty; retrofitting RTL later is painful.</commentary></example> <example>Context: Responsive UI for multiple platforms. user: "I need this UI to work on desktop 1080p, Steam Deck 800p, and mobile portrait" assistant: "Let me bring in the godot-ui-designer agent — anchor presets and stretch mode picks." <commentary>Responsive UI is its own discipline; designer leans on responsive-ui skill for stretch / aspect choices.</commentary></example>

Use when designing a new Godot feature or system — guides scene tree planning, node type selection, and architectural decisions

Use when reviewing GDScript or C# Godot code — checklist of best practices, common anti-patterns, and Godot-specific pitfalls

Use when debugging Godot projects — remote debugger, print techniques, signal tracing, common error patterns and fixes

Use when optimizing Godot games — profiler, draw calls, physics tuning, memory management, and common bottlenecks

Use when creating a new Godot 4.x project — scaffolds recommended directory structure, project settings, autoloads, and .gitignore

Use when implementing shaders — Godot shader language, visual shaders, common visual recipes, and post-processing effects

Use when implementing state machines in Godot — enum-based, node-based, and resource-based FSM patterns with trade-offs

Use when implementing tweens — property animation, method tweening, chaining, parallel sequences, easing, and common UI/gameplay motion recipes

Bootstrap skill — establishes how to find and use GodotPrompter skills, with platform-specific tool mapping

Use when building VR/AR/XR applications — OpenXR setup, XROrigin3D, hand tracking, controllers, passthrough, and Meta Quest deployment in Godot 4.3+

Use when exporting and distributing Godot games — export presets, platform settings, CI/CD with GitHub Actions

Use when writing GDScript — static typing, await/coroutines, lambdas, match patterns, export annotations, inner classes, and common idioms

Use when managing dependencies between systems — autoloads, service locators, @export injection, and scene injection patterns

Use when implementing dialogue — data structures for branching dialogue, conditions, and UI presentation

Use when implementing decoupled communication between nodes — global EventBus autoload with typed signals

Use when building dedicated servers — headless export, server architecture, lobby management, and deployment

Use when working with 2D-specific systems — TileMaps, parallax scrolling, 2D lights and shadows, canvas layers, particles 2D, custom drawing, and 2D meshes in Godot 4.3+

Use when working with 3D-specific systems — materials, lighting, shadows, environment, global illumination, fog, LOD, occlusion culling, and decals in Godot 4.3+

Use when creating Godot editor plugins — EditorPlugin, @tool scripts, custom inspectors, and dock panels

Use when implementing AI movement — NavigationAgent2D/3D, steering behaviors, behavior trees, and patrol patterns

Use when implementing animations — AnimationPlayer, AnimationTree, blend trees, state machines, sprite animation, and code-driven animation

Use when importing and managing assets — image compression, 3D scene import, audio formats, resource formats, and import configuration

Use when implementing audio — audio buses, AudioStreamPlayer, spatial audio, music management, SFX pooling, and dynamic mixing

Use when implementing cameras — smooth follow, screen shake, camera zones, and transitions for 2D and 3D

Use when building reusable node components — composition patterns, component communication, and interface design

Use when working with C# in Godot — conventions, GodotSharp API differences from GDScript, project setup, and interop

Use when implementing signals in C# — [Signal] delegates, EmitSignal patterns, async signal awaiting, and event-driven architecture

Use when writing tests for Godot projects — TDD workflow with GUT and gdUnit4, covers both GDScript and C#

Use when building user interfaces — Control nodes, themes, anchors, containers, and layout patterns

Use when building in-game HUDs — health bars, score displays, minimap, notifications, and damage numbers

Use when implementing input — InputEvent system, Input Map actions, controllers/gamepads, mouse/touch, action rebinding, and input architecture

Use when building inventory systems — Resource-based items, slot management, stacking, and UI binding

Use when implementing localization (i18n/l10n) — TranslationServer, CSV/PO translation files, locale switching, RTL support, and pluralization in Godot 4.3+

Use when implementing game math — vectors, transforms, interpolation, curves, random number generation, and common geometric recipes

Use when implementing multiplayer — MultiplayerAPI, ENet/WebSocket peers, RPCs, and authority model

Use when synchronizing multiplayer state — MultiplayerSynchronizer, interpolation, prediction, and lag compensation

Use when implementing particle effects — GPUParticles2D/3D, ParticleProcessMaterial, emission shapes, subemitters, trails, attractors, collision, and common VFX recipes

Use when working with physics bodies, collision shapes, raycasting, areas, rigid bodies, ragdolls, soft bodies, Jolt physics, and physics interpolation in Godot 4.3+

Use when implementing player movement — CharacterBody2D/3D patterns, input handling, physics, common movement recipes

Use when implementing procedural generation — noise-based terrain, BSP dungeons, cellular automata caves, wave function collapse, and seeded randomness in Godot 4.3+

Use when creating data containers in Godot — custom Resources for configuration, items, stats, and editor integration

Use when handling multiple resolutions — stretch modes, aspect ratios, DPI scaling, and mobile/desktop adaptation

Use when implementing save/load systems — ConfigFile, JSON, Resource serialization, save game architecture

Use when designing scene tree structure — composition vs inheritance, when to split scenes, node hierarchy patterns