Hire an AI Godot gameplay programmer

Everything it can hand back

Your task sets the actual outputs. The specialist picks the methods that cover them.

• A node and scene plan with each part as its own scene
• A signal list with names, typed values, who sends and who listens
• A review of your Autoloads and what to move out of them
• A typing plan for GDScript, and the GDScript and C# split if both are used
• Draft code for the parts you ask for, marked as not run
• A test checklist to run in the Godot editor

How it does the job well

• Prefer composition over inheritance. Behaviour such as health or movement is a component node, not a deeper base class.
• Every scene must run on its own. It assumes no parent type and no sibling.
• Signals are a public API. Give each a typed value list. GDScript signal names use snake_case. C# follows the Godot C# signal pattern with the EventHandler suffix. Do not use an untyped Variant in a signal unless a legacy script needs it.
• Parts talk upward by signal, not by reaching to a parent. Reach siblings through exported node paths or typed @onready variables, not fixed get_node strings inside logic.
• Autoloads hold true global state only: settings, save data, an event bus. No gameplay logic in an Autoload.
• Start from the user's task and the content, then the layout. Decoration comes last.
• Design every state: empty, loading, error, long text and mobile.

Mistakes it avoids

• Putting gameplay logic in an Autoload.
• Fixed node paths inside game logic.
• Untyped variables and arrays in new code.
• Deep inheritance where a component would do.
• Mixing GDScript and C# without a reason.
• Designing only the happy path at desktop width.

What a good result looks like

An example, not your task: You are adding a gameplay feature, such as health, an inventory or an enemy, and want the node and signal plan first.

• Scenes and components. Each part as its own scene, with its settings and a note on whether it runs alone.
• Signals. Every signal with typed values, the sender and the listeners.
• Autoload review. Which Autoloads to keep, change or remove, and why.
• Typing plan. Where to add types in GDScript and where C# is worth using.
• Draft code. Code for the parts you asked for, marked as not run.
• Test checklist. Tests to run in the editor, including each scene on its own.

How the work is checked

• Every screen has its states, breakpoints and interactions written down.
• Colour pairs and type sizes pass the stated contrast checks.
• The handoff names components, tokens and open questions.
• States which checks passed, failed or could not run, and names missing inputs.

These checks have not been run against a model yet. Your AI uses them to check its own work.

A second opinion

Before it hands back, your AI reviews the draft the way Linus Torvalds and William Shakespeare would. This is a way of reviewing the work. It does not mean they wrote or endorse it.

Capabilities

• Fix the scope. It states the feature, your Godot version and language, and what must not break. Missing facts are asked for once, then marked.
• Plan scenes and components. It splits behaviour into small component scenes. Each scene must run on its own with no parent assumed.
• Plan the signals. It lists every signal with a typed value, an owner and its listeners. GDScript uses snake_case names. C# follows the Godot C# pattern.
• Audit Autoloads and typing. It keeps Autoloads for true global state such as settings and an event bus. It plans typed variables, typed arrays and typed node references.
• Draft code and tests. It drafts the code you asked for and lists scene-by-scene tests, including running each scene alone.

How the role works

1. Checks your task, context and available tools.
2. Picks the methods needed and prepares a work plan.
3. Carries out supported tasks, with each method's limits and review gates.
4. Checks the real deliverables and corrects supported faults.
5. Hands back files, evidence and unresolved gaps.

Your specialist's working setup

Download the base specialist without a task form or account. README.md and SETUP.md explain how to use the folder. SOUL.md defines its scope. INTAKE.md asks missing questions inside your AI. PLAYBOOK.md, SKILLS.md, BEST_PRACTICES.md, CHECKS.md and HANDOFF.md guide the work and its checked deliverables.

Complete associated skills, supporting files and licences are included. Choose only the methods needed for the actual task. Keep context, working files and accepted feedback in your AI project.

Use this specialist through MCP or the API

Call prepare_specialist with role_id godot-gameplay-scripter only. No task is required to load it. Your AI asks what job you need done, what you want back and which relevant context it can use.

For task-led hiring, call find_specialist, explain the suggested specialists and let the user accept or change the team.

Complete ZIP: Download base specialist. API: GET /api/v1/specialists/godot-gameplay-scripter/pack. The host AI supplies its own model, tools and execution; a pack does not connect accounts or run a task.

Inputs and helpful context

The specialist starts from the task brief. Only active methods require their inputs.

For the primary method, when used

• The gameplay feature you want, and how it should behave
• Your Godot version and language, GDScript, C# or both
• The scene tree and the scripts it touches, pasted as text (optional)
• Your Autoload list and what each one does (optional)
• Anything the feature must not break

Helpful context (optional)

• A screenshot or text copy of your scene tree.
• The errors or warnings the editor shows today.

Tools and access

• Claude, ChatGPT or Gemini with file upload: It can read your scripts and scene files together and spot a node path or signal that will break.

Functions and deliverables

• Godot gameplay programmer: Plan a Godot 4 gameplay feature with a clean scene layout, typed signals and GDScript or C# code, plus a checklist to test it in the editor.
  • A node and scene plan with each part as its own scene
  • A signal list with names, typed values, who sends and who listens
  • A review of your Autoloads and what to move out of them
  • A typing plan for GDScript, and the GDScript and C# split if both are used
  • Draft code for the parts you ask for, marked as not run
  • A test checklist to run in the Godot editor
  Source: Michael Sitarzewski and Agency Agents contributors.
• Language model feature explorer: Use SAELens to break a model’s inner signals into sparse features. Get code to train, inspect and test them.
  • Training code for the feature network
  • Named features with example text
  • Charts of which features fire
  • Steering and removal tests
  • Notes on quality checks
  Source: Orchestra Research.
• Emotional scene editor: Rewrite a paragraph that names feelings so plain facts and actions carry them. Paste your text, get a feeling-to-action rewrite in short sentences.
  • A rewritten paragraph in short sentences
  • A list of feeling words cut and what replaced each
  • The one detail it used
• Character motivation scene editor: Rewrite a flat scene so each person wants something and uses words to get it. Paste your dialogue and get a scene rewrite with a read-aloud check.
  • A short table of what each speaker wants, who blocks them and their tactic
  • A rewritten scene
  • A note on what the audience knows that a character does not
  • A read-aloud check
• Brand profile builder: Share your website. Get a reusable profile covering your products, customers, voice and approved claims, with sources.
  • A folder of eight plain files, from a start file for your AI to a claims list and a change log
  • A tag on every fact, and every claim marked approved, pending or banned
  • A two-sentence diagnosis of your biggest gap, and a list of what's missing and who can answer it
  • A short slice for your next step, if you name one
• Linus Torvalds: Review a code change using Linus Torvalds’s recorded approach. Ask what works, what breaks for existing users and who owns the fix.
  • Your problem worked on the way Linus Torvalds would: their questions, their method, their push-back
  • The answer or the work, in Linus Torvalds's voice, using their ideas by name
  • Anything that goes beyond their public record, marked
  • One suggested next step
• William Shakespeare: Plan a scene, speech or poem using a reading of Shakespeare’s work. Give people conflicting aims, shape a turn and write for the ear.
  • Your problem worked on the way William Shakespeare would: their questions, their method, their push-back
  • The answer or the work, in William Shakespeare's voice, using their ideas by name
  • Anything that goes beyond their public record, marked
  • One suggested next step

Tasks you can use it for

• You are adding a gameplay feature, such as health, an inventory or an enemy, and want the node and signal plan first.
• Your player script has grown past what you can follow and you want it split into parts.
• Signals break at run time or scenes only work when placed under a certain parent.
• You want to move from untyped GDScript to typed code without breaking the game.

Limits to check before starting

• You need players to share a game over a network. Use the Godot multiplayer designer.
• You want visual effects, such as outlines, dissolve or water. Use the Godot Shader Developer agent.
• You want ideas for the loop, goals or balance of the game. Use the Gameplay designer.
• Your project is in Unity. Use the Unity software architect.

Best way to use this role

Give it one clear outcome, the actual files and a definition of done. Keep the work in one AI project so it can reuse checked context and earlier files.

• Download the pack and add it to your AI as a skill. If you cannot, paste SKILL.md and then references/source-agent.md into a new chat.
• Paste your feature description, your Godot version and the scene tree. Paste the scripts it touches if you have them.
• Type "Plan this feature as components with typed signals, then draft the code." Your AI asks once for anything missing.
• Read the signal list first. Each signal is a promise between parts, so fix names or types before any code.
• Copy the draft code into a test scene. Run that scene alone in Godot, then in the full game.
• Fix anything the editor warns about before you add the next feature. Your AI cannot run Godot for you.

Read it as data

Read the complete role setup as JSON. Connect your AI to the AI Blocks MCP library and read aiblocks://roles/godot-gameplay-scripter for its role instructions and pinned sources.

This is a prepared AI role. No task has run. Your AI carries out authorized work using its available tools and reports the actual deliverables and checks.