Dependency Injection
jame581/GodotPrompter
A skill your agent uses when managing dependencies between systems — autoloads, service locators, @export injection, and scene injection patterns
Expert blueprint for Godot 4 project organization (feature-based folders, naming conventions, version control).
Install Godot Project Foundations
$ npx skills add thedivergentai/GD-Agentic-Skills --skill godot-project-foundations -a claude-codeProject install by default; add -g for ~/.claude/skills/.
$ gh skill install thedivergentai/GD-Agentic-Skills godot-project-foundations --agent claude-codeProject scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).
$ git clone --depth 1 https://github.com/thedivergentai/GD-Agentic-Skills.git skills-src && mkdir -p .claude/skills && cp -r skills-src/skills/godot-project-foundations .claude/skills/godot-project-foundations && rm -rf skills-srcUse ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.
Claude Code skills documentation · loads skills from .claude/skills/
Install the "godot-project-foundations" agent skill from https://github.com/thedivergentai/GD-Agentic-Skills/tree/main/skills/godot-project-foundations into .claude/skills/godot-project-foundations/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "godot-project-foundations", then confirm the skill loads.Claude Code copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
$skill-installer install https://github.com/thedivergentai/GD-Agentic-Skills/tree/main/skills/godot-project-foundationsType this inside Codex. $skill-installer <name> installs a curated skill from openai/skills. The installer writes to $CODEX_HOME/skills (default ~/.codex/skills). Restart Codex if the skill does not show up.
$ npx skills add thedivergentai/GD-Agentic-Skills --skill godot-project-foundations -a codexProject install goes to .agents/skills/; add -g for ~/.codex/skills/.
$ gh skill install thedivergentai/GD-Agentic-Skills godot-project-foundations --agent codexProject scope by default (.agents/skills/); add --scope user for a personal install.
$ git clone --depth 1 https://github.com/thedivergentai/GD-Agentic-Skills.git skills-src && mkdir -p .agents/skills && cp -r skills-src/skills/godot-project-foundations .agents/skills/godot-project-foundations && rm -rf skills-srcUse ~/.agents/skills/ instead of .agents/skills for a personal install.
Codex skills documentation · loads skills from .agents/skills/
Install the "godot-project-foundations" agent skill from https://github.com/thedivergentai/GD-Agentic-Skills/tree/main/skills/godot-project-foundations into .agents/skills/godot-project-foundations/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "godot-project-foundations", then confirm the skill loads.Codex copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
$ npx skills add thedivergentai/GD-Agentic-Skills --skill godot-project-foundations -a cursorProject install goes to .agents/skills/; add -g for ~/.cursor/skills/.
$ gh skill install thedivergentai/GD-Agentic-Skills godot-project-foundations --agent cursorProject scope by default (.agents/skills/); add --scope user for a personal install.
$ git clone --depth 1 https://github.com/thedivergentai/GD-Agentic-Skills.git skills-src && mkdir -p .cursor/skills && cp -r skills-src/skills/godot-project-foundations .cursor/skills/godot-project-foundations && rm -rf skills-srcUse ~/.cursor/skills/ instead of .cursor/skills for a personal install.
Cursor skills documentation · loads skills from .cursor/skills/, .agents/skills/, .claude/skills/, .codex/skills/
Install the "godot-project-foundations" agent skill from https://github.com/thedivergentai/GD-Agentic-Skills/tree/main/skills/godot-project-foundations into .cursor/skills/godot-project-foundations/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "godot-project-foundations", then confirm the skill loads.Cursor copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
$ gemini skills install https://github.com/thedivergentai/GD-Agentic-Skills.git --path skills/godot-project-foundations--scope user (default) or --scope workspace; --path is the subfolder of the repo that holds the skill; --consent skips the security confirmation prompt.
$ npx skills add thedivergentai/GD-Agentic-Skills --skill godot-project-foundations -a gemini-cliProject install goes to .agents/skills/; add -g for ~/.gemini/skills/.
$ gh skill install thedivergentai/GD-Agentic-Skills godot-project-foundations --agent gemini-cliProject scope by default (.agents/skills/); add --scope user for a personal install.
$ git clone --depth 1 https://github.com/thedivergentai/GD-Agentic-Skills.git skills-src && mkdir -p .gemini/skills && cp -r skills-src/skills/godot-project-foundations .gemini/skills/godot-project-foundations && rm -rf skills-srcUse ~/.gemini/skills/ instead of .gemini/skills for a personal install, then run /skills reload.
Gemini CLI skills documentation · loads skills from .gemini/skills/, .agents/skills/
Install the "godot-project-foundations" agent skill from https://github.com/thedivergentai/GD-Agentic-Skills/tree/main/skills/godot-project-foundations into .gemini/skills/godot-project-foundations/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "godot-project-foundations", then confirm the skill loads.Gemini CLI copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
$ gh skill install thedivergentai/GD-Agentic-Skills godot-project-foundationsInstalls for Copilot at project scope by default; add --scope user for a personal install. Preview a skill first with gh skill preview. Needs GitHub CLI 2.90.0 or later (public preview).
$ npx skills add thedivergentai/GD-Agentic-Skills --skill godot-project-foundations -a github-copilotProject install goes to .agents/skills/; add -g for ~/.copilot/skills/.
$ git clone --depth 1 https://github.com/thedivergentai/GD-Agentic-Skills.git skills-src && mkdir -p .github/skills && cp -r skills-src/skills/godot-project-foundations .github/skills/godot-project-foundations && rm -rf skills-srcUse ~/.copilot/skills/ instead of .github/skills for a personal install. Commit .github/skills so cloud agent and code review can use it.
GitHub Copilot skills documentation · loads skills from .github/skills/, .claude/skills/, .agents/skills/
Install the "godot-project-foundations" agent skill from https://github.com/thedivergentai/GD-Agentic-Skills/tree/main/skills/godot-project-foundations into .github/skills/godot-project-foundations/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "godot-project-foundations", then confirm the skill loads.GitHub Copilot copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
$ npx skills add thedivergentai/GD-Agentic-Skills --skill godot-project-foundations -a opencodeOpenCode documents no install command of its own. Project install goes to .agents/skills/; add -g for ~/.config/opencode/skills/.
$ gh skill install thedivergentai/GD-Agentic-Skills godot-project-foundations --agent opencodeProject scope by default (.agents/skills/); add --scope user for a personal install.
$ git clone --depth 1 https://github.com/thedivergentai/GD-Agentic-Skills.git skills-src && mkdir -p .opencode/skills && cp -r skills-src/skills/godot-project-foundations .opencode/skills/godot-project-foundations && rm -rf skills-srcUse ~/.config/opencode/skills/ instead of .opencode/skills for a personal install.
OpenCode skills documentation · loads skills from .opencode/skills/, .claude/skills/, .agents/skills/
Install the "godot-project-foundations" agent skill from https://github.com/thedivergentai/GD-Agentic-Skills/tree/main/skills/godot-project-foundations into .opencode/skills/godot-project-foundations/ in this project. Copy the whole folder (SKILL.md and every file beside it), keep the folder name "godot-project-foundations", then confirm the skill loads.OpenCode copies the folder itself, the same result as the manual copy. Check what it changed before you commit it.
Facts
- Skill name
godot-project-foundations- GitHub stars
- 821
- Token cost
- ~3.1k tokens
- SKILL.md length
- 922 words
- Files
- 18 (incl. scripts, references)
- Skills in repo
- 98
- Repo updated
- First seen
- Licence
- LGPL-3.0
At a glance
Expert blueprint for Godot 4 project organization (feature-based folders, naming conventions, version control).
- Works in 3 steps: Naming Conventions → Feature-Based Organization → Version Control
- Starting new projects
- SKILL.md covers Available Scripts, NEVER Do (Expert Anti-Patterns), Ownership decision tree and Workflow: Scaffolding a New…, plus 4 more sections
- Refactoring structure
What it does
Godot Project Foundations is an agent skill from thedivergentai/GD-Agentic-Skills. Expert blueprint for Godot 4 project organization (feature-based folders, naming conventions, version control). Enforces snakecase files, PascalCase nodes, %SceneUniqueNames, and .gitignore best practices. Use when starting new projects or refactoring structure. Keywords project organization, naming conventions, snakecase, PascalCase, feature-based, .gitignore, .gdignore.
Its SKILL.md is about 3.1k tokens, which your agent loads only when the skill is triggered. The skill folder holds 19 other files, including scripts and reference files (for example `references/foundations-deep.md` and `references/migration-notes.md`).
It sits in Game Development, covering Game development and Git workflow. It works with Godot. The repository describes itself as: The official "Long-Term Memory" for Godot 4.7+ AI Agents. A high-density library of 99 expert skills and 27 genre blueprints, providing audited, strictly typed GDScript patterns… The licence is LGPL-3.0.
When your agent uses it
- Starting new projects
- Refactoring structure
Example prompts
- “/godot-project-foundations”
Workflow steps
3 steps, taken from the step headings in SKILL.md.
What it can do on your machine
Read from SKILL.md and the folder at commit 4c4d0ff. It shows what the files ask for, not the result of running them.
Tool permissions
Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.
From allowed-tools in the SKILL.md frontmatter.
Runs code
Ships 14 files in scripts/, which the agent can run.
From the folder's file list and the shell code blocks in SKILL.md.
Network
Links to these hosts (documentation or services it may open):
docs.godotengine.org
From URLs in SKILL.md, links to its own repository left out.
Credentials
Names no API keys, tokens, secrets or passwords.
From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.
Context cost
Godot Project Foundations loads about 3.1k tokens when it runs, and up to ~4.9k if it reads all its reference files. Until then it costs about 101 tokens; SKILL.md has 922 words of instructions outside code blocks.
Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.
Safety
Auto-check passed
The automated check found no risky patterns in SKILL.md.
Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); the scripts in this folder are not scanned.
SKILL.md
The full file from thedivergentai/GD-Agentic-Skills at commit 4c4d0ff, republished under its LGPL-3.0 licence (© thedivergentai). 922 words, ~3,052 tokens.
Download SKILL.mdSave it as
.claude/skills/godot-project-foundations/SKILL.md (or your agent's skills folder). This skill also uses 17 other files; get the full folder from GitHub.- name
- godot-project-foundations
- description
- Expert blueprint for Godot 4 project organization (feature-based folders, naming conventions, version control). Enforces snake_case files, PascalCase nodes, %SceneUniqueNames, and .gitignore best practices. Use when starting new projects or refactoring structure. Keywords project organization, naming conventions, snake_case, PascalCase, feature-based, .gitignore, .gdignore.
Project Foundations
Feature-based organization, consistent naming, and version control hygiene define professional Godot projects.
Available Scripts
Core Scaffolding (Stateful / Persistent)
- project_bootstrapper.gd: Auto-generates feature folders and .gitignore.
- runtime_configurator.gd: Applies high-performance profiles and saves
override.cfg. - managed_autoload.gd: Advanced Singleton pattern with
RefCounteddelegation. - global_event_bus.gd: MANDATORY for decoupled global signals — do not re-inline EventBus samples in chat.
- node_pooling_system.gd: Thread-safe Object Pool for high-frequency scene instantiation.
- async_resource_loader.gd: MANDATORY for threaded scene transitions — do not re-inline SceneManager samples.
Runtime Utilities (Stateless / Lightweight)
- base_data_resource.gd: Reactive Resource foundation using
emit_changed(). - advanced_telemetry_logger.gd: Custom OS-level
Loggerfor crash reporting. - threaded_task_worker.gd: Robust
WorkerThreadPoolimplementation. - action_buffer_input.gd: Foundational
_unhandled_inputbuffer. - build_metadata_provider.gd: Native extraction of version and build metadata.
- feature_scaffolder.gd / scene_naming_validator.gd: Feature folder + naming gates.
Do NOT Load
dependency_auditor.gdunless troubleshooting loading errors.
NEVER Do (Expert Anti-Patterns)
Global Architecture
- NEVER group by file type —
/scripts,/spritesfolders. Nightmare maintainability. Use feature-based:/player,/ui. - NEVER mix snake_case and PascalCase in files — Standard: snake_case for files, PascalCase for nodes.
- NEVER use hardcoded get_node() paths — Brittle on reparenting. Use
%SceneUniqueNamesfor stable references. - NEVER use monolithic Autoloads — Avoid managers that hold visual node references; keep singletons focused on pure data or RefCounted delegation.
Resource Management
- NEVER forget .gitignore — Committing
.godot/folder = 100MB+ bloat + conflicts. - NEVER skip .gdignore for raw assets — Design source files (
.psd,.blend) in root will be imported unless ignored. - NEVER modify globally shared Resources directly — Strictly call
duplicate(true)for unique instances with independent state.
Performance & Threading
- NEVER block the main thread with
load()— Strictly useResourceLoader.load_threaded_request()for async scene transitions. - NEVER modify the SceneTree from a background thread — Strictly use
call_deferred()for thread-to-main-thread synchronization. - NEVER skip Mutex locking during pooled access — Strictly ensure thread-safety when using a shared
WorkerThreadPoolor Object Pool. - NEVER use
_process()for precise input — Tied to visual framerate. Strictly use_unhandled_input()to capture exact, frame-independent events.
Ownership decision tree
| Need | Prefer | Avoid |
|---|---|---|
| Everything for one feature (player, HUD panel) | Feature folder scene module | Type folders (/scripts, /sprites) |
| Cross-scene service with lifecycle (save, audio bus) | Autoload via managed_autoload.gd | Stuffing UI nodes into singletons |
| Many publishers/subscribers, no ownership | EventBus → MANDATORY global_event_bus.gd | Autoload that imports half the game |
| One scene's private wiring | Scene-local node + %UniqueName | Global bus for parent→child calls |
1. Naming Conventions
- Files & Folders:
snake_case(C# exception: PascalCase class-match). - Node Names:
PascalCase. - Exports:
snake_case; Inspector Title-Cases them. - Private: leading
_on members and virtuals (_ready,_process). - Signals: past-tense
snake_case(health_changed). - Unique Names:
%SceneUniqueNamesover brittleget_node()paths.
2. Feature-Based Organization
Group by feature (/entities/player, /ui/main_menu), not by file type. Keep /common, /levels, /addons.
3. Version Control
Godot-aware .gitignore (ignore .godot/) + .gdignore on raw design sources.
Workflow: Scaffolding a New Project
- Ensure
project.godotexists → runproject_bootstrapper.gd/ createentities/,ui/,levels/,common/. - Setup Git
.gitignore+ document feature-based layout inREADME.md. - Register lean Autoloads only after the ownership decision tree says so.
Typed GDScript strictness (foundations-only)
Full typed-GDScript migration lives in godot-gdscript-mastery.
For new foundations projects: Project Settings → Debug → GDScript → Untyped Declaration = Warn or Error.
Expert Foundation Architectures
Scene transitions
MANDATORY load async_resource_loader.gd — threaded ResourceLoader with progress. Do not paste SceneManager samples here.
Global Event Bus
MANDATORY load global_event_bus.gd for typed global signals. Do not paste EventBus samples here.
Project Metadata
Use build_metadata_provider.gd / base_data_resource.gd for version/build flags instead of ad-hoc JSON.
Deep dive (load on demand)
Full naming table, typed-GDScript migration, EventBus/SceneManager/metadata samples — references/foundations-deep.md.
Show full SKILL.md (381 more words)Show less
Reference
Progressive disclosure: open Official Documentation links only when researching a specific API; load Related Skills when routing to a peer domain — do not preload the whole lattice.
Official Documentation
- Project organization — Feature-based folders,
.gdignore, and VCS hygiene that keep imports and repos maintainable. - Scene organization — Ownership boundaries and why
%SceneUniqueNamesbeat brittleget_node()paths. - GDScript style guide — Canonical snake_case files / PascalCase nodes / past-tense signals used by this skill’s validators.
- GDScript warning system — Enforce typed declarations (
Untyped Declaration→ Warn/Error) when migrating foundations to GDScript 2.0. - Singletons (Autoload) — How to register lean global services that survive scene changes.
- Autoloads versus regular nodes — When a Managed Autoload / EventBus is justified vs scene-local ownership.
- Background loading —
ResourceLoader.load_threaded_*patterns for non-blocking scene transitions. - Resources — Shared vs duplicated Resource instances and why global mutation breaks feature modules.
- Nodes and scene instances — Instantiation, pooling, and scene-as-module boundaries for feature folders.
- Using SceneTree — Tree lifetime, deferred calls, and thread→main synchronization rules.
- File paths in Godot projects —
res:///user://conventions for scaffolded folders and savedoverride.cfg/ metadata. - ProjectSettings — Runtime profiles, version strings, and settings keys used by configurators and build metadata.
Related Skills
Prerequisites
- godot-gdscript-mastery — Typed GDScript, style, and warning-system fluency before enforcing naming and scaffold conventions.
Complements
- godot-version-migration — When opening or scaffolding a project on an older engine version, hop to the library target before enforcing current foundations.
- godot-autoload-architecture — Boot order and ownership rules for Managed Autoload / EventBus singletons registered from a clean project root.
- godot-composition — Feature folders become composable scene modules; parents wire children instead of growing monolithic managers.
- godot-resource-data-patterns — Extends
BaseDataResource-style reactive Resources into full data-driven catalogs without shared mutation. - godot-signal-architecture — Typed EventBus signals and connect lifetime once Autoloads and scene ownership are in place.
- godot-scene-management — Threaded loaders and scene swaps build on this skill’s async ResourceLoader boilerplate.
- godot-input-handling — Deepens
_unhandled_inputbuffering into full action maps and device routing.
Downstream / consumers
- godot-export-builds — Export presets and feature tags assume a clean folder layout,
.gitignore, and build metadata hooks. - godot-testing-patterns — Feature-based scenes and deterministic Autoloads make unit/integration harnesses easier to mount.
- godot-debugging-profiling — Custom Logger telemetry and dependency audits feed editor-time diagnostics once structure is stable.
- godot-performance-optimization — Node pools, WorkerThreadPool, and runtime profiles escalate here when foundations hit CPU/memory ceilings.
Master
- godot-master — Library router and mirrored module entry; open when discovering which Domain Skill owns a cross-cutting architecture concern.
© thedivergentai, LGPL-3.0. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file
Files
SKILL.md and 17 other files (scripts, references) in skills/godot-project-foundations of thedivergentai/GD-Agentic-Skills.
- SKILL.md
- godot.gitignore
- references/foundations-deep.md
- references/migration-notes.md
- scripts/action_buffer_input.gd
- scripts/advanced_telemetry_logger.gd
- scripts/async_resource_loader.gd
- scripts/base_data_resource.gd
- scripts/build_metadata_provider.gd
- scripts/dependency_auditor.gd
- scripts/feature_scaffolder.gd
- scripts/global_event_bus.gd
- scripts/managed_autoload.gd
- scripts/node_pooling_system.gd
- scripts/project_bootstrapper.gd
- scripts/runtime_configurator.gd
- scripts/scene_naming_validator.gd
- scripts/threaded_task_worker.gd
Open the folder on GitHubat commit 4c4d0ff
Compare with similar skills
Godot Project Foundations next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.
| Skill | Stars | Used in | Tokens | Auto-check | Licence | Repo updated |
|---|---|---|---|---|---|---|
| Godot Project Foundations this skillthedivergentai/GD-Agentic-Skills | 821 | — | ~3.1k | Automated safety check: Pass | LGPL-3.0 | |
| Dependency Injectionjame581/GodotPrompter | 805 | — | ~2.8k | Automated safety check: Pass | MIT | |
| Gdscript Advancedjame581/GodotPrompter | 805 | — | ~3.4k | Automated safety check: Pass | MIT | |
| Gdscript Patternsjame581/GodotPrompter | 805 | — | ~3.5k | Automated safety check: Pass | MIT | |
| Godot Debuggingjame581/GodotPrompter | 805 | — | ~3k | Automated safety check: Pass | MIT | |
| Multithreadingjame581/GodotPrompter | 805 | — | ~2.7k | Automated safety check: Pass | MIT |
Similar skills
Gdscript Advanced
jame581/GodotPrompter
A skill your agent uses when writing production-grade GDScript — performance idioms, metaprogramming, @tool lifecycle, async pitfalls, signal/Callable trade-offs, profiler-driven idioms, and common…
Gdscript Patterns
jame581/GodotPrompter
A skill your agent uses when writing GDScript — static typing, await/coroutines, lambdas, match patterns, export annotations, inner classes, and common idioms
Godot Debugging
jame581/GodotPrompter
A skill your agent uses when debugging Godot projects — remote debugger, print techniques, signal tracing, common error patterns and fixes
Multithreading
jame581/GodotPrompter
A skill your agent uses when running work off the main thread — WorkerThreadPool, Thread/Mutex/Semaphore, calldeferred, thread-safe scene access, and threaded resource loading
Release Manager
poingstudios/godot-admob-plugin
Manage and execute AdMob plugin releases. An agent skill from poingstudios/godot-admob-plugin.
More from thedivergentai/GD-Agentic-Skills
All 98 skills in this repoGodot 2D Animation
thedivergentai/GD-Agentic-Skills
Expert patterns for 2D animation in Godot using AnimatedSprite2D and skeletal cutout rigs.
Godot 3D World Building
thedivergentai/GD-Agentic-Skills
Expert patterns for 3D level design using GridMap with MeshLibrary, CSG constructive solid geometry, occlusion, and runtime GridMap builders.
Godot Adapt 2D To 3D
thedivergentai/GD-Agentic-Skills
Expert patterns for migrating 2D games to 3D including node type conversions, camera systems (third-person, first-person, orbit), physics layer migration, sprite-to-model art pipeline, and control…
Godot Adapt 3D To 2D
thedivergentai/GD-Agentic-Skills
Expert patterns for simplifying 3D games to 2D including dimension reduction strategies, 2.5D fake-depth, isometric ports, camera flattening, physics conversion, 3D-to-sprite art pipeline, and…
Godot Agent Vision
thedivergentai/GD-Agentic-Skills
Agentic eyes for Godot work: cross-platform screenshot CLI (asset/region/window/screen) to budgeted WebP, TEMP editor viewport bridge under .gdskills/, and Taste Receptor Atlas v2 (~237…
Godot Animation Tree Mastery
thedivergentai/GD-Agentic-Skills
Expert patterns for AnimationTree including StateMachine transitions, BlendSpace2D for directional movement, BlendTree for layered animations, root motion, transition conditions, advance…
Related
Works with
Categories
Questions about Godot Project Foundations
What does Godot Project Foundations do?
Expert blueprint for Godot 4 project organization (feature-based folders, naming conventions, version control). Godot Project Foundations is an agent skill from thedivergentai/GD-Agentic-Skills. Expert blueprint for Godot 4 project organization (feature-based folders, naming conventions, version control).
When should I use Godot Project Foundations?
Godot Project Foundations fits situations like: starting new projects; refactoring structure.
How do I install Godot Project Foundations in Claude Code?
Run `npx skills add thedivergentai/GD-Agentic-Skills --skill godot-project-foundations -a claude-code`. Or copy the skill folder (skills/godot-project-foundations in thedivergentai/GD-Agentic-Skills) into .claude/skills/godot-project-foundations in your project. Claude Code loads it when a task matches its description.
How do I install Godot Project Foundations in Codex?
Run `npx skills add thedivergentai/GD-Agentic-Skills --skill godot-project-foundations -a codex`. Or copy the skill folder (skills/godot-project-foundations in thedivergentai/GD-Agentic-Skills) into .agents/skills/godot-project-foundations in your project. Codex loads it when a task matches its description.
Can I use Godot Project Foundations in Cursor, Gemini CLI or GitHub Copilot?
Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add thedivergentai/GD-Agentic-Skills --skill godot-project-foundations -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/godot-project-foundations, .gemini/skills/godot-project-foundations, .github/skills/godot-project-foundations and .opencode/skills/godot-project-foundations in your project.
What does Godot Project Foundations need to run?
SKILL.md names no scripts, command-line tools or credentials: Godot Project Foundations is instructions for the agent only.
Does Godot Project Foundations access the network?
SKILL.md names 1 domain. As links in the text: docs.godotengine.org. This is read from the text; nothing was executed.
Is Godot Project Foundations safe to install?
Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. The check reads SKILL.md only: the scripts in the folder are not scanned, so read them before running anything.
What licence does Godot Project Foundations use?
Godot Project Foundations is published under the LGPL-3.0 licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.
How many tokens does Godot Project Foundations use?
About 3.1k tokens (SKILL.md is roughly 12k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full. Its references folder adds about 1.8k tokens, read only when the agent opens those files.
What are the alternatives to Godot Project Foundations?
Skills that share tags, products or a category with Godot Project Foundations: Dependency Injection (jame581/GodotPrompter, 805 stars), Gdscript Advanced (jame581/GodotPrompter, 805 stars), Gdscript Patterns (jame581/GodotPrompter, 805 stars) and Godot Debugging (jame581/GodotPrompter, 805 stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.
Who maintains Godot Project Foundations?
thedivergentai (a GitHub user) maintains it in thedivergentai/GD-Agentic-Skills, which has 821 GitHub stars. The repository holds 98 skills in this directory. The repository was last updated on September 9, 2026.
Source: thedivergentai/GD-Agentic-Skills on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.