March 19, 2026
Hey everyone, Divergent AI here! I'm super happy that I'm seeing the project getting some love. It's motivated me to come back at it with a really strong update for you all. I've spent many hours working on updating all Domain Skills to be completely packed with top expert-level knowledge as learned directly from the robot's mouth—the Godot documentation.
Read the full message...
The reason I did this was two-fold:
- I wanted all resources to be as true to the current documentation as possible and filled with top-level expert information.
- I think it's important to make AI useful and that includes avoiding slop. A big part of that is ensuring the code we write follows the best practices set out by the Godot documentation and team itself.
My hope is that this agentic skillset will allow anyone to make a game if they wish and have it be good and natively, and proactively follow best practices. Not everyone is gifted with the detailed vocabulary specific to Godot they may need to make their dream game come true. I hope GDSkills acts as an assistant and expert in making them quickly come to reality.
I have many things I want to add to this project and a lot of testing and things I would like to do to ensure it continues to improve in quality over time.
Please enjoy and remember to use AI for good. Most importantly, have fun and dream big!
- The Reference Lattice: Every Domain Skill now ends with a curated Official Documentation lattice (
docs.godotengine.org/en/stable/…) plus detailed Related Skills (Prerequisites / Complements / Downstream / Master), so agents can research deeper without leaving the skill graph. - Script & reference footers: Research-link comment blocks on Domain Skill scripts and phase docs (marker
GDSkills research links (agents)) — non-executing, file-specific, progressive disclosure. - SPECIAL MENTION —
@DedInc: First external Domain Skill — godot-monte-carlo-balancer — source-driven Monte Carlo balance lab (Rust + rayon), Resource-first extract, playstyle CI bands, economy careers, and headless Godot calibration. Thank you!
📜 Update Archive
- Godot 4.7 Director's Cut: Full library upgrade to Godot 4.7+ — AreaLight3D, HDR output, Asset Store, built-in virtual joystick, and migration digest for 4.6→4.7 projects.
- Domain Skills: Renamed "Micro-Skills" to Domain Skills — 92 modular topic skills, each with 4.7 baseline and targeted migration deltas.
- Persona Squad: Anara, Aurelius, and Builder updated for 4.7 scoring, never-lists, and
GODOT_PATHCLI overrides.
- Three Persona-Based Skills: We introduced specialized agent skills for
@godot-analyst(Anara),@godot-auditor(Aurelius), and@godot-builderto streamline and unify our persona development and code optimization workflows. - MCP Clean-up & Direct Building: Defunct
MCP SetupandMCP Builderskills have been removed; we now use Auditor and Builder to construct and compile projects directly via the Godot CLI, maximizing native efficiency. - Full Skills Audit: Completed a comprehensive and rigorous audit of all microskills to elevate the knowledge depth and execution quality to the highest agentic standard.
- Lead Architect Sync: Synchronized all audited advancements with the central
godot-masterhub, making the orchestrator smarter, faster, and more robust.
- Microskill Overhaul: We spent many hours updating all microskills to contain top expert-level knowledge, directly extracted from the Godot documentation. This massive update ensures all resources are true to the current engine state, empowering developers with best practices and reducing AI slop.
- Godot Master Takes Control: We updated the
godot-masterskill to fully orchestrate and integrate this major skill update. It is now a true, all-in-one Godot Master skill! - Feedback Requested: We'd love your feedback on the new updates! The easiest way to share your thoughts is to open an issue or start a discussion on our GitHub.
- Resource Harvesting: Introduced
godot-game-loop-harvestfor interactive gathering, node depletion, and rarity-based drop tables. - Time Trials & Ghosts: Added
godot-game-loop-time-trialwith precise millisecond timing and ghost transform recording/playback. - Wave-Based Survival: Implemented
godot-game-loop-wavesfor round-based difficulty scaling and dynamic enemy pool management.
- Seasonal Theming Identity: Introduced
godot-theme-easterfor safe, runtime aesthetic injection (StyleBox duplication & material swapping). - Core Loop Expansion: Added
godot-game-loop-collectionfor volumetric procedural spawning andgodot-mechanic-revivalfor "Souls-like" mortality. - Interaction Secrets: Implemented
godot-mechanic-secretsfor input sequence buffering (Konami code) and hidden discovery persistence.
- New Genre Mastery: Introduced the comprehensive Romance & Dating Sim skill set.
- Master Integration: Unified the Romance skill into the godot-master orchestration layer.
- Production Scripts: Added battle-tested GDScript patterns for affection tracking, relationship routing, and date events.
- Unified Architecture: Upgraded
godot-masterto an all-in-one orchestration layer for all 87 specialized skills. - Decision Matrix: Integrated expert-level Godot 4 architectural decision trees and anti-pattern guides.
- Workflow Scaffolding: Added programmatic scene building and project initialization patterns.
- The Foundation: Released the initial library of 80+ Godot 4.x Agentic Skills.
- Agent-First Design: Established the DIA (Discovery-Ingestion-Application) loop for AI Coding Agents.
- Core Systems: Atomic implementations for 2D, 3D, UI, and Gameplay fundamentals.
| 🚀 Get Started | 🏆 Godot Master | 🧩 Domain Skills | 🤖 Agent Protocol | ⭐ Star History |
|---|---|---|---|---|
| Install | All-in-One System | Bite-Size Modules | DIA Loop | Growth Chart |
Godot Agentic Skills is a high-density, Agent-First knowledge library for Godot 4.7+—designed as an external "Long-Term Memory" (LTM) for AI Coding Agents. It provides structured, deterministic patterns for professional game and application engineering.
Unlike generic AI responses, every skill in this repository follows strictly defined Godot 4 best practices, architectural patterns, and performance optimization techniques refined by shipping real products.
If this project helps your development or empowers your agents, please give it a star! 🌟
Choose your path to avoid a "Context Storm" (overloading your agent with too many instructions at once).
If you are starting a new project OR you have an existing project that needs to be "checked" and brought up to date with modern Godot 4 standards, install the Godot Master hub.
npx skills add thedivergentai/gd-agentic-skills/skills/godot-masterIf you need a specific feature (e.g., 2D movement, inventory), install only that Domain Skill.
npx skills add thedivergentai/gd-agentic-skills/skills/godot-characterbody-2d[!DANGER] NEVER use the
--allflag when installing this repository (e.g.,npx skills add ... --all). This is an "Instant No-No" that will cause an unrecoverable Context Storm by forcing your agent to read every single metadata entry in the library.
Use this when installing via the skills CLI, or when an agent is reading this README after a repo clone (DIA path) instead of a normal plugin install.
| Agent | -a flag |
Project path | Global path |
|---|---|---|---|
| Cursor | cursor |
.agents/skills/ |
~/.cursor/skills/ |
| Claude Code | claude-code |
.claude/skills/ |
~/.claude/skills/ |
| Codex | codex |
.agents/skills/ |
~/.codex/skills/ |
| Windsurf | windsurf |
.windsurf/skills/ |
~/.codeium/windsurf/skills/ |
| Gemini CLI | gemini-cli |
.agents/skills/ |
~/.gemini/skills/ |
| GitHub Copilot | github-copilot |
.agents/skills/ |
~/.copilot/skills/ |
| OpenCode | opencode |
.agents/skills/ |
~/.config/opencode/skills/ |
Rules
- Preferred install:
npx skills add thedivergentai/gd-agentic-skills/skills/godot-master -g -a <agent> -y(swap the skill path for a Domain Skill when needed). - Verify:
npx skills list -g -a <agent> - Restart the host agent after install — most agents load skills once at session start.
- Clone / DIA path (no
npx skills add): queryskills_index.json, then readskills/<name>/SKILL.mdwith the agent's file tool. Do not hand-symlink into host skill dirs unless the user asks for that. - Canonical store:
~/.agents/skills/is the CLI's shared copy; per-agent discovery paths differ by design.
- Skill installed but missing in the agent → confirm with
npx skills list, re-run with the correct-a <agent>, then restart the agent. - Do not treat a manual Claude-only symlink into
~/.claude/skills/as the default fix — that only helps one host.
To keep your AI agent fast and accurate, follow these "Expert Efficiency" rules:
Either use godot-master (which orchestrates the other 96 skills via references) OR use individual Domain Skills.
- Godot Master is an "Orchestrator" skill. It is dense (~15k tokens) but provides a complete blueprint. Use it when the "Big Picture" matters.
- Domain Skills are "Surgical" skills (~2-5k tokens). They are fast, reliable, and keep the agent focused on one specific API.
Installing 97 skills simultaneously creates a "Metadata Flood":
- Token Bleed: ~15,000 tokens are "permanently" used just to tell the agent which skills exist.
- Instruction Conflicts: Having multiple overlapping expert instructions (e.g., 20+ different genre blueprints) can cause the agent to lose its specific focus.
- Reasoning Lag: The model has to sift through 100+ KB of text before deciding what to do.
- Plugin Install (
npx skills add): Copies/links the skill into your agent's skill directory (see Agent Installation Rubric). The agent can then discover it automatically. This is why installing too many at once causes a "Context Storm." - Repository Clone: If you merely clone this repo to a folder (e.g.,
Downloads/GDSkills), the agent will NOT auto-load skills unless you are working inside that directory. Useskills_index.json+ read eachSKILL.mdwith the agent's file tool (DIA loop below).
The godot-master skill is the crown jewel of this repository—a consolidated expert library that orchestrates all 97 specialized skills into a unified architectural framework.
Unlike individual Domain Skills that focus on isolated features, godot-master is your system architect. It provides:
📚 Comprehensive Knowledge Base
- 97 Reference Documents: Complete markdown guides for every skill, from foundations to advanced genres
- 982 Unique Production Scripts: Battle-tested, production-ready GDScript implementations
- 11 Workflow Patterns: Step-by-step architectural workflows (scaffolding, entity orchestration, persistence, optimization, multiplayer, Builder CLI scene builds, etc.)
🧠 Expert Frameworks
- Architectural Decision Matrix: Choose the right pattern for your project (component-driven, event-driven, resource-streaming, deterministic networking)
- 15 Anti-Patterns: Explicit "NEVER DO THIS" rules with non-obvious explanations (e.g., why
get_tree().root.get_node()breaks, whyload()in_processkills performance) - Performance Budgets: Concrete numbers for mobile/desktop targets (draw calls, triangle counts, script time)
- Server API Patterns: Expert escape hatch for 10K+ entities using RenderingServer/PhysicsServer RIDs
🏗️ The Layer Cake Architecture
Godot Master enforces a signal-based separation of concerns:
graph TD
UI[🎨 PRESENTATION<br/>UI / VFX / Audio] -->|Signals ⬆️| LOGIC[⚙️ LOGIC<br/>State Machines / Controllers]
LOGIC -->|Signals ⬆️| DATA[💾 DATA<br/>Resources / .tres / Stats]
DATA -->|Signals ⬆️| INFRA[🌐 INFRASTRUCTURE<br/>Autoloads / Signal Bus / Managers]
style UI fill:#1f2937,stroke:#58A6FF,stroke-width:2px,color:#fff
style LOGIC fill:#1f2937,stroke:#79C0FF,stroke-width:2px,color:#fff
style DATA fill:#1f2937,stroke:#A371F7,stroke-width:2px,color:#fff
style INFRA fill:#1f2937,stroke:#F778BA,stroke-width:2px,color:#fff
Critical Rule: Signals travel UP only. Presentation layer never modifies Data directly. Infrastructure speaks exclusively through signals.
flowchart LR
START([New Task]) --> Q1{Starting a<br/>new project?}
Q1 -->|Yes| MASTER[Use godot-master]
Q1 -->|No| Q2{Need architectural<br/>guidance?}
Q2 -->|Yes| MASTER
Q2 -->|No| Q3{Building a<br/>complete system?}
Q3 -->|Yes| MASTER
Q3 -->|No| MICRO[Use Domain Skill:<br/>targeted implementation]
MASTER --> DESC1[✓ Full workflow context<br/>✓ Decision frameworks<br/>✓ Anti-patterns<br/>✓ Performance budgets]
MICRO --> DESC2[✓ Quick implementation<br/>✓ Focused feature<br/>✓ Standalone pattern]
style START fill:#1f2937,stroke:#58A6FF,stroke-width:3px,color:#fff
style MASTER fill:#0d1117,stroke:#58A6FF,stroke-width:3px,color:#79C0FF
style MICRO fill:#0d1117,stroke:#A371F7,stroke-width:3px,color:#F778BA
style DESC1 fill:#1f2937,stroke:#58A6FF,stroke-width:2px,color:#fff
style DESC2 fill:#1f2937,stroke:#A371F7,stroke-width:2px,color:#fff
Use godot-master when:
- Starting a new Godot project from scratch
- Auditing an existing project to find anti-patterns or standards violations
- Designing game or application architecture
- Building entity/component systems
- Debugging performance or physics issues
- Choosing between 2D/3D approaches
- Implementing multiplayer
- Optimizing draw calls or script time
- Porting between platforms
Use Domain Skills when:
- Adding a specific feature to an existing codebase
- Learning a targeted Godot API pattern
- Implementing standalone functionality (UI component, particle effect, save system)
# Skill path
skills/godot-master/SKILL.md
# Contains
├── 91 reference markdown files (references/)
├── 185 production scripts (scripts/)
└── Complete architectural decision treesIndividual Domain Skills are modular add-ons for targeted functionality. Each is atomic, self-contained, and production-ready—perfect for when you need a specific implementation pattern without the full architectural context.
Think of Domain Skills as your component library: Drop them into your project for instant, expert-level functionality.
🏗️ Architecture & Foundation (10 skills)
- godot-autoload-architecture: Singleton patterns, global state management, signal-based communication
- godot-composition: Entity-Component architecture for scalable game systems (NPCs, weapons, actors)
- godot-composition-apps: Composition patterns for applications and tools (UI-focused)
- godot-debugging-profiling: Print debugging, breakpoints, profiler, memory leak detection
- godot-gdscript-mastery: Static typing, signal architecture, unique nodes, style guide
- godot-project-foundations: Feature-driven folder structure, project scaffolding, conventions
- godot-project-templates: Base
.gitignore, export presets, input maps - godot-resource-data-patterns:
.tresworkflows, data-driven design, resource factories - godot-signal-architecture: Global vs scoped signal buses, signal-driven decoupling
- godot-state-machine-advanced: Hierarchical FSMs, pushdown automata, state stacks, transition validation
🎮 2D Systems (10 skills)
- godot-2d-animation:
AnimatedSprite2D, skeletal cutout rigs, procedural animation - godot-2d-physics: Collision layers/masks,
Area2Dtriggers, raycasting,PhysicsDirectSpaceState2D - godot-animation-player: Timeline animations, track types, root motion, RESET tracks
- godot-animation-tree-mastery:
AnimationTree,StateMachine,BlendSpace2D, layered animations - godot-camera-systems: Smooth following, camera shake, trauma system, deadzone logic
- godot-characterbody-2d: Platformer movement (coyote time, jump buffer), collision handling
- godot-particles:
GPUParticles2D/3DvsCPUParticles, visibility AABB, particle effects - godot-shaders-basics:
CanvasItemshaders, post-processing, parameter animation - godot-tilemap-mastery:
TileMap, autotiling, chunking, runtime modification - godot-tweening:
TweenAPI, juice/game feel, easing functions
🌍 3D Systems (7 skills)
- godot-3d-lighting:
DirectionalLight3D, shadow cascades,VoxelGIvsSDFGI,LightmapGI - godot-3d-materials:
StandardMaterial3D, PBR workflows, ORM textures, transparency modes - godot-3d-world-building:
GridMap,CSGgeometry,WorldEnvironment, volumetric fog - godot-navigation-pathfinding:
NavigationAgent2D/3D, RVO avoidance, async NavMesh baking - godot-physics-3d:
CharacterBody3D,RigidBody3D, ragdoll physics, collision shapes - godot-procedural-generation:
FastNoiseLite, WFC (Wave Function Collapse), chunk loading - godot-raycasting-queries: RayCast/ShapeCast, DirectSpaceState, hitscan, LOS, mouse picking
⚔️ Gameplay Mechanics (17 skills)
- godot-ability-system: Cooldowns, skill trees, combo systems, upgrade paths
- godot-combat-system: Hitbox/hurtbox architecture, damage calculation, invincibility frames
- godot-dialogue-system: Branching dialogue, character portraits, typewriter effects, localization
- godot-economy-system: Multi-currency, shop systems, dynamic pricing, loot tables
- godot-game-loop-collection: Scavenger hunt logic, volumetric spawning, collection tracking
- godot-game-loop-harvest: Resource depletion, interactive gathering, drop calculation
- godot-game-loop-time-trial: Ghost recording, race logic, checkpoint-based timing
- godot-game-loop-waves: Wave-based spawning, difficulty scaling, round management
- godot-inventory-system: Slot-based containers, stacking logic, drag-drop UI
- godot-mechanic-revival: Souls-like mortality, corpse runs, revival charges, consequence tracking
- godot-mechanic-secrets: Input sequence buffering (Konami code), interaction thresholds, secret persistence
- godot-monte-carlo-balancer: Source-driven Monte Carlo balance lab, playstyle win-rate bands, economy careers, CI snapshots — co-authored by
@DedInc
- godot-quest-system: Quest graphs, prerequisites, state tracking
- godot-rpg-stats: Stat modifiers, attribute scaling, damage formulas
- godot-save-load-systems: Dictionary serialization, delta-save patterns, encryption
- godot-scene-management: Async scene loading, transitions, pooling
- godot-turn-system: Turn-based combat, active time battle (ATB), timeline management
🎨 UI & UX (5 skills)
- godot-input-handling:
InputMap, controller support, rebinding, input buffering - godot-ui-containers: Responsive layouts, anchor presets, margin containers
- godot-ui-rich-text:
RichTextLabel, BBCode, custom effects - godot-theme-easter: Seasonal theming, runtime StyleBox duplication, juice components (wobble/bounce)
- godot-ui-theming:
.themeresources, style inheritance, global skinning
🌐 Connectivity & Platforms (11 skills)
- godot-audio-systems:
AudioBusrouting, positional audio, music crossfades, audio pooling - godot-export-builds: Multi-platform exports, CI/CD, codesigning, headless mode
- godot-multiplayer-networking:
MultiplayerSynchronizer, client prediction, server reconciliation - godot-performance-optimization: Profiling, draw call batching,
MultiMesh, LOD systems - godot-platform-console: Console certification, controller compliance
- godot-platform-desktop: Steam integration, window management, settings menus
- godot-platform-mobile: Touch controls, safe areas, battery optimization
- godot-platform-vr: XR toolkit, VR physics, hand tracking
- godot-platform-web: HTML5 exports, JavaScript bridge, browser limitations
- godot-server-architecture: Headless servers, authoritative networking, RID patterns
- godot-testing-patterns: GUT framework, unit tests, integration tests, CI/CD testing
🔄 Adaptation Guides (5 skills)
- godot-adapt-2d-to-3d: Dimension conversion, camera migration, sprite-to-model pipeline
- godot-adapt-3d-to-2d: Flattening 3D to 2D, orthogonal projection, performance gains
- godot-adapt-desktop-to-mobile: Touch controls, UI scaling, battery optimization
- godot-adapt-mobile-to-desktop: Mouse/keyboard, resolution scaling, Steam features
- godot-adapt-single-to-multiplayer: Client-server architecture, lag compensation, anti-cheat
🎯 Genre Blueprints (27 skills)
Action & Combat
- godot-genre-action-rpg: Loot generation, skill trees, stat-based combat, equipment systems
- godot-genre-fighting: Frame data, hitbox/hurtbox, motion inputs, rollback netcode
- godot-genre-platformer: Coyote time, jump buffer, game feel polish, level design
- godot-genre-shooter: Hitscan, recoil patterns, weapon archetypes, hit registration
- godot-genre-shooter-fps: FPS movement physics, camera sway, weapon bobbing, high-precision hit registration
Strategy & Tactics
- godot-genre-moba: Lane management, tower aggro, fog of war, ability cooldowns
- godot-genre-rts: Unit selection, command queues, fog of war, pathfinding
- godot-genre-tower-defense: Wave spawning, targeting priority, mazing mechanics
Exploration & Adventure
- godot-genre-metroidvania: Ability gating, interconnected worlds, map revelation
- godot-genre-open-world: Chunk streaming, floating origin, HLOD, POI discovery
- godot-genre-roguelike: Procedural generation, permadeath, meta-progression, seeded RNG
- godot-genre-survival: Needs systems, crafting recipes, base building, resource gathering
Narrative & Puzzle
- godot-genre-card-game: Deck management, effect resolution, hand layouts, Command pattern
- godot-genre-educational: Adaptive difficulty, spaced repetition, mastery tracking
- godot-genre-horror: Tension pacing, Director AI, sanity systems, sensory perception
- godot-genre-puzzle: Undo systems, grid logic, non-verbal tutorials
- godot-genre-visual-novel: Branching narratives, rollback, typewriter effects
- godot-genre-romance: Relationship tracking, affection systems, dating mechanics
Simulation & Social
- godot-genre-battle-royale: Shrinking zones, deployment systems, relevancy networking
- godot-genre-idle-clicker: Big number handling, exponential growth, prestige systems
- godot-genre-party: Minigame collections, local multiplayer, split-screen
- godot-genre-racing: Vehicle physics, checkpoint systems, rubber-banding AI
- godot-genre-rhythm: BPM conductors, timing judgments, latency compensation
- godot-genre-sandbox: Voxel systems, cellular automata, emergent gameplay
- godot-genre-simulation: Economy systems, time progression, feedback loops
- godot-genre-sports: Ball physics, team AI, formation systems
- godot-genre-stealth: Vision cones, alert states, sound propagation, gradual detection
All skills are catalogued in the machine-readable skills_index.json with keywords, descriptions, and dependency chains.
Note
This JSON index is a repository-level file and is only present if you have cloned the source repository.
AI agents must follow the DIA loop for maximum quality:
Query skills_index.json to find the skill matching the user's intent.
Example: User wants "smooth character movement" → Agent finds godot-characterbody-2d and godot-tweening.
CRITICAL: Agents MUST NOT implement from general training data alone.
Required: Read the skill's SKILL.md with the agent's file tool to catch Godot 4-specific nuances (e.g., AudioServer.get_time_since_last_mix() for rhythm sync, StringName for O(1) dictionary lookups).
For complex projects: Load godot-master for architectural workflows and anti-patterns.
Follow the Skill Chain documented in the skill header. Apply patterns recursively, starting from the deepest dependency.
Example Workflow:
User: "Build a player controller"
Agent: Query skills_index.json → Find godot-characterbody-2d
Agent: Read godot-characterbody-2d/SKILL.md → See dependencies: godot-composition, godot-state-machine-advanced
Agent: Read godot-composition/SKILL.md → Implement component architecture first
Agent: Read godot-state-machine-advanced/SKILL.md → Build state machine layer
Agent: Return to godot-characterbody-2d → Implement movement with components + states
Documentation MUST remain in sync with implementation. If a Godot 4 API changes, update the relevant SKILL.md immediately.
Scene scaffolding and headless automation go through godot-builder (also mirrored in godot-master Workflow 11). Use Godot CLI scripts such as create_scene.py, add_node.py, and run_project.py.
All code follows Godot 4.7+ conventions:
- Static typing:
func move(vec: Vector2) -> void: Signal/Callable/Tween(Godot 4 syntax)StringNamefor performance-critical lookups- Component composition over deep inheritance
We welcome contributions from developers and agents!
📖 Read the full contribution guide: CONTRIBUTING.md
Quick Guidelines:
- Every skill must provide Expert Knowledge Delta (not tutorials)
- Include anti-patterns with non-obvious explanations
- Code must be Godot 4.7+ native, statically typed
- Scripts must parse without warnings
Submit: Open an issue with [Request] tag or submit a PR describing the knowledge delta your skill adds.
If this project accelerates your Godot development or empowers your AI agents, consider starring the repository! ⭐
| Metric | Value |
|---|---|
| Total Skills | 97 |
| Genre Blueprints | 27 |
| Production Scripts | 982 |
| Reference Documents | 97 |
| Target Engine | Godot 4.7+ |
| License | LGPLv3 |
We are seeking financial sponsors and infrastructure partners to sustain the Godot Agentic Ecosystem. Every contribution helps us maintain these skills and keep them free for the community.
🚀 View our Sponsorship & Support Opportunities
Get in Touch: [email protected]
This project is licensed under the GNU Lesser General Public License v3.0 - see LICENSE for details.
Why LGPLv3?
We chose this license because it strikes the perfect balance for an open ecosystem. It ensures that any improvements or additions made directly to the GDSkills library itself remain open-source and shared with the community. At the same time, it empowers you to use these agentic skills to build and compile your own incredible games, which you are completely free to commercialize and keep closed-source if you wish.
By contributing, you agree that your code will be licensed under the project's LGPLv3 License.
Maintained by the Agents
[!IMPORTANT] Anti-Erosion Policy: Documentation MUST remain in sync with implementation. If a Godot 4 API changes, update the relevant
SKILL.mdimmediately.