# GodotPrompter: domain skills for AI agents working on Godot > GodotPrompter is a plugin that gives coding agents 56 Godot specific skills, so a request to add a state machine or set up multiplayer loads version checked Godot guidance rather than generic advice. It installs into Claude Code, Copilot, Cursor, Codex, Grok, Antigravity and OpenCode, and it is careful about what it writes into your repository. **jame581/GodotPrompter** — Agentic skills framework for Godot 4.x. Domain-specific skills for AI coding agents (Claude Code, Copilot, Antigravity, Cursor) - Repository: https://github.com/jame581/GodotPrompter - Stars: 866 · Forks: 56 - Language: JavaScript - License: MIT - Published: 2026-10-20 · Updated: 2026-10-20 · Language: en - Canonical page: https://hysenlabs.com/projects/jame581-godotprompter ## Skills instead of generic advice GodotPrompter is described as an agentic skills framework for Godot 4.x game development, giving AI coding agents domain-specific expertise for GDScript and C# projects. The mechanism is on demand loading. When you ask the agent to add a state machine or to set up multiplayer, the agent loads the relevant skill and follows Godot specific practice rather than working from its general knowledge. The README is blunt about the difference, saying the agent provides a complete directory structure, autoload setup and .gitignore, not generic advice. That framing matters because the failure mode of coding agents on a specific engine is well known. The model has seen a decade of Godot 3 tutorials, it confuses node types, it writes signals that never fire, and it usually cannot tell you which of its suggestions belong to a version you do not run. A skill file fixes all three problems at once if the file is version accurate. The project is inspired by and built on top of the Superpowers plugin for Claude Code, which provides the underlying skill loading, brainstorming and workflow infrastructure. GodotPrompter extends that with Godot domain knowledge rather than reinventing the plugin mechanism. The breadth is the other headline. There are 56 skills covering project setup, architecture, gameplay systems, input handling, physics, 2D and 3D systems, animation, shaders, audio, UI, multiplayer, localization, procedural generation, XR and VR, native extensions, multithreading, mobile shipping, optimisation, GDScript and C# patterns, a teaching mode, and third party addons including LimboAI, Beehave, Popochiu, Dialogue Manager and Phantom Camera. Everything targets Godot 4.3 and later, with both GDScript and C# examples, and features from Godot 4.5, 4.6 and 4.7 are included as annotated additive sections rather than silently assumed. ## Installing into seven agent platforms The plugin is installed differently depending on the agent, and the README documents each route. For Claude Code, which the README marks as the recommended path, you add a marketplace and then install the plugin from it. ```bash # Add the marketplace claude plugins marketplace add jame581/skillsmith # Install the plugin claude plugins install godot-prompter@skillsmith ``` A local clone works too, with the marketplace added from the directory and the plugin installed under a different marketplace name. ```bash git clone https://github.com/jame581/GodotPrompter.git claude plugins marketplace add ./GodotPrompter claude plugins install godot-prompter@godot-prompter ``` Grok Build uses a plugin command with a trust flag, and the README shows how to pin a specific release. ```bash grok plugin install jame581/GodotPrompter@v1.15.1 --trust grok plugin enable godot-prompter ``` The Antigravity CLI takes a URL, and the GitHub Copilot CLI mirrors the Claude marketplace flow. ```bash agy plugin install https://github.com/jame581/GodotPrompter ``` Cursor is different again, because Cursor reads a plugin manifest from the project: you either run the add-plugin command, or clone the repository into place and let Cursor read .cursor-plugin/plugin.json. Codex has no plugin command either, so the installation is a clone into the Codex directory plus a symbolic link from the shared agent skills directory. ```bash git clone https://github.com/jame581/GodotPrompter.git ~/.codex/godot-prompter mkdir -p ~/.agents/skills ln -s ~/.codex/godot-prompter/skills ~/.agents/skills/godot-prompter ``` OpenCode takes a plugin entry in its configuration file instead. ```json { "plugin": ["godot-prompter@git+https://github.com/jame581/GodotPrompter.git"] } ``` That is the shape of the project in one paragraph: it is not a tool with its own runtime, it is a bundle of knowledge that has to be attached to whatever agent you happen to use. ## The SessionStart hook and how it detects a Godot project The most interesting engineering in the project is the hook, because it decides when the skills are even offered. GodotPrompter registers a SessionStart hook that injects a skill routing card when it detects a Godot project. Detection looks for project.godot up to four directories above the working directory and up to three below it, which covers the common monorepo layout where documentation and tooling sit at the repository root and the engine project lives in source, game or godot. Vendored addons directories and dot-directories are skipped, so a plugin bundled demo project is never mistaken for your own. In any other repository the hook does nothing. The privacy properties are stated in the same paragraph. The hook reads only your project file and its own state file under your home directory, makes no network requests, and writes nothing. If bash is unavailable on Windows it exits silently, and the plugin behaves exactly as it did before version 1.13.0. The support matrix is honest about what has been checked. It is verified end to end on Claude Code and GitHub Copilot CLI. Cursor registration ships but is not yet confirmed. Codex and Antigravity have no hook mechanism at all and continue to load the bootstrap through AGENTS.md or GEMINI.md. That last point leads to the subagent gap. The hook covers your session, but subagents do not receive it, because SessionStart does not fire on subagent dispatch. The workaround is a section in your agent instruction file, and the plugin offers to add one rather than doing it silently. The README is careful that the offer names the file your repository already keeps, listing CLAUDE.md, AGENTS.md, GEMINI.md, the GitHub Copilot instructions file and the rules directories used by Claude and Cursor, so an agent agnostic project is never pushed into a file it does not want. A refusal is remembered in the plugin state directory, so you are asked once rather than at every session start. ## Mentor mode and the two phase workflow The plugin also changes how the agent answers, not only what it knows. Mentor mode is switched on by asking the agent to teach you as we go in a Godot project. The delivery changes to the Godot concept and why that node, the editor setup, annotated GDScript and C#, what to verify when you run it, and one suggested next step. The README stresses that this wraps the domain skills rather than replacing them, so the guidance stays version checked. The preference is remembered per project in the plugin state directory, and the README points out that nothing is written into your game repository. Saying just give me the code turns it off. The design phase is a two skill sequence. When design decisions are open, the plugin loads a grilling skill first, which asks the questions in numbered rounds, offers a recommended answer for each, and records your choices. Then a brainstorming skill walks through architectural approaches with their trade-offs, scene tree design, signal maps and data flow, and finally produces an implementation plan with ordered tasks. The implementation phase then loads the relevant domain skill per task, for example the player control skill when the task is building a player. This is the structure that makes the plugin more than a documentation dump. The grilling step exists because the expensive failures in agent assisted game development are not syntax errors but decisions taken early and never revisited, and the recorded choices are what the later tasks are built on. ## The 16 KB budget and the validator around it Since version 1.7.0 the skill files are subject to a 16 KB token budget, enforced by a validator, and the same release added the gdscript-advanced skill for production grade GDScript depth with performance idioms, metaprogramming, @tool lifecycle and profiler driven idioms. A budget on skill files is a design decision with real consequences. Skills are loaded into a context window, so an unbounded skill is an unbounded tax on every session that touches it. Capping them forces the author to split a topic across several files, which is why the collection is numbered at 56 rather than being a handful of very large documents. The enforcement is visible in the package scripts. The validate command runs a script that checks the skills, and the test scripts are split into three groups: a hooks test, a validator test that covers parity exemptions, nonexistent API checks and scanner patterns, and a metadata test that covers frontmatter, agent mirror sync, the skill index, platform metadata and mentor editor references. ```json "scripts": { "test:hooks": "node --test tests/hooks/session-start.test.mjs", "test": "npm run test:hooks && npm run test:validator && npm run test:metadata", "validate": "node scripts/validate-skills.mjs", }, ``` The validator tests also tell you what the project is trying to prevent: skills that reference APIs which do not exist, and content that duplicates what another agent mirror already says. The latter is what the agent mirror sync scripts handle, with a check mode and a write mode, and the skill index has the same pattern, generated by a script and checked in continuous integration. ## Repository layout, privacy posture and maintenance The top level of the repository shows how multi-platform a plugin like this has to be. There are separate directories for each agent: .claude-plugin, .claude, .codex, .cursor-plugin and .opencode. Alongside them sit agents, commands, skills, hooks, scripts, tests, docs and an evals directory, plus the instruction files CLAUDE.md, AGENTS.md and GEMINI.md at the root, and the usual governance files including CONTRIBUTING.md, CODE_OF_CONDUCT.md, SECURITY.md and PRIVACY.md. The presence of PRIVACY.md and SECURITY.md in a plugin whose hook reads your project file and inspects directories is a good sign, and the README backs it up with the concrete claims about no network requests and no writes. The project also carries AGENTS.md, which is the same file convention used by other agent tooling and which several of the agent platforms read automatically. On maintenance, the release tags are v1.15.1 on 2026-10-12, v1.15.0 on 2026-10-06 and v1.14.1 on 2026-10-05, with the last push on 2026-10-14. So three releases in ten days, with a change log maintained in the repository, which is the cadence you would expect from a project whose content is version-checked against Godot releases rather than against its own codebase. The licence is MIT. The plugin is JavaScript with an ES module type and an OpenCode entry point under .opencode/plugins, and the package metadata lists the supported agent names as keywords, which is a compact way to see the compatibility claim in one place. ## Conclusion GodotPrompter is worth installing for a team that uses an AI coding agent on a Godot project and keeps hitting the same generic advice about nodes and signals, because the skills are version checked against Godot 4.3 and later and cover areas agents routinely get wrong, from multiplayer to native extensions. It is the wrong choice if you work on a single small prototype, if your project targets a Godot version older than 4.3, or if your policy forbids plugins that inspect your working directory. Verify first that the hooks are supported on the agent platform you use, since the README states Cursor registration ships but is not yet confirmed and Codex and Antigravity have no hook mechanism, and read the skill budget rule of 16 KB before you author a skill of your own. ## FAQ ### What is GodotPrompter? It is an agentic skills framework for Godot 4.x that gives AI coding agents structured Godot specific knowledge, with 56 skills for GDScript and C# projects, built on top of the Superpowers plugin for Claude Code. ### How do I install GodotPrompter? Each agent has its own route: a marketplace and install command for Claude Code and the Copilot CLI, a plugin command for Grok Build and the Antigravity CLI, an add-plugin command or a project clone for Cursor, a clone plus a symbolic link for Codex, and a plugin entry in opencode.json for OpenCode. ### Does GodotPrompter modify my Godot project? The README states that the hook reads only your project.godot and its own state file under your home directory, makes no network requests, and writes nothing. If a section is added to your agent instruction file, it is offered first rather than added silently, and a refusal is remembered. ### What does mentor mode do in GodotPrompter? Asking the agent to teach you as we go switches it to teaching delivery covering the Godot concept, the editor setup, annotated GDScript and C#, what to verify when you run it and one suggested next step, while still wrapping the version checked domain skills. ## Sources - [Issues](https://github.com/jame581/GodotPrompter/issues) - [jame581/GodotPrompter on GitHub](https://github.com/jame581/GodotPrompter) - [License: MIT](https://github.com/jame581/GodotPrompter/blob/master/LICENSE) - [README](https://github.com/jame581/GodotPrompter/blob/master/README.md) - [Releases](https://github.com/jame581/GodotPrompter/releases) --- Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/jame581-godotprompter