Agent skill

Godot Genre Puzzle

by thedivergentai in thedivergentai/GD-Agentic-Skills

Expert blueprint for puzzle games including undo systems (Command pattern for state reversal), grid-based logic (Sokoban-style mechanics), non-verbal tutorials (teach through level design), win…

LGPL-3.0Auto-check passedGame Development

Install Godot Genre Puzzle

skills CLI
$ npx skills add thedivergentai/GD-Agentic-Skills --skill godot-genre-puzzle -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install thedivergentai/GD-Agentic-Skills godot-genre-puzzle --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/thedivergentai/GD-Agentic-Skills.git skills-src && mkdir -p .claude/skills && cp -r skills-src/skills/godot-genre-puzzle .claude/skills/godot-genre-puzzle && rm -rf skills-src

Use ~/.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/

Facts

Skill name
godot-genre-puzzle
GitHub stars
821
Token cost
~3.2k tokens
SKILL.md length
552 words
Files
18 (incl. scripts, references)
Skills in repo
98
Repo updated
First seen
Licence
LGPL-3.0

At a glance

Expert blueprint for puzzle games including undo systems (Command pattern for state reversal), grid-based logic (Sokoban-style mechanics), non-verbal tutorials (teach through level design), win…

  • Physics puzzles
  • SKILL.md covers NEVER Do (Expert Anti-Patterns), 🛠 Expert Components (scripts/), Core Loop and Decision Trees, plus 3 more sections
  • Reaches docs.godotengine.org
  • Keywords: puzzlegame

What it does

Godot Genre Puzzle is an agent skill from thedivergentai/GD-Agentic-Skills. Expert blueprint for puzzle games including undo systems (Command pattern for state reversal), grid-based logic (Sokoban-style mechanics), non-verbal tutorials (teach through level design), win condition checking, state management, and visual feedback (instant confirmation of valid moves). Use for logic puzzles, physics puzzles, or match-3 games. Trigger keywords: puzzlegame, undosystem, commandpattern, gridlogic, nonverbaltutorial, statemanagement.

Its SKILL.md is about 3.2k 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/migration-notes.md` and `references/puzzle-elite-implementations.md`).

It sits in Game Development, covering Game development, State management and Game design. 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

  • Physics puzzles
  • Keywords: puzzlegame
  • Nonverbaltutorial
  • Statemanagement

Example prompts

  • “/godot-genre-puzzle”

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 15 files in scripts/, which the agent can run.

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    Hosts in commands or code, which the agent is likely to contact:

    • 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 Genre Puzzle loads about 3.2k tokens when it runs, and up to ~5.3k if it reads all its reference files. Until then it costs about 120 tokens; SKILL.md has 552 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~120
When it runs · the whole SKILL.md, loaded when a task matches
~3.2k
With references · SKILL.md plus every file in references/, read only if the agent opens them
~5.3k

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). 552 words, ~3,239 tokens.

Download SKILL.mdSave it as .claude/skills/godot-genre-puzzle/SKILL.md (or your agent's skills folder). This skill also uses 17 other files; get the full folder from GitHub.
name
godot-genre-puzzle
description
Expert blueprint for puzzle games including undo systems (Command pattern for state reversal), grid-based logic (Sokoban-style mechanics), non-verbal tutorials (teach through level design), win condition checking, state management, and visual feedback (instant confirmation of valid moves). Use for logic puzzles, physics puzzles, or match-3 games. Trigger keywords: puzzle_game, undo_system, command_pattern, grid_logic, non_verbal_tutorial, state_management.

NEVER Do (Expert Anti-Patterns)

Design & Player Experience
  • NEVER punish experimentation; strictly provide Undo/Reset functionality to allow risk-free hypothesis testing.
  • NEVER require pixel-perfect input for logic puzzles; strictly use Grid Snapping or large, forgiving hitboxes.
  • NEVER allow undetected Soft-Locks (unsolvable states); strictly notify the player or provide immediate backtracking.
  • NEVER hide the rules of the world; strictly ensure visual feedback is instant and unambiguous (e.g., powered wires must glow).
  • NEVER skip the Non-Verbal Tutorial phase; strictly introduce mechanics in isolation before combining them.
Grid Logic & State
  • NEVER use floating-point numbers (Vector2) for grid coordinates; strictly use Vector2i to prevent precision drift.
  • NEVER use _process() for grid-state or win-condition validation; strictly trigger checks only when a piece moves.
  • NEVER rely on the SceneTree structure as the source of truth; strictly maintain grid data in a separate script/dictionary.
  • NEVER modify a Dictionary or Array size while iterating over it; strictly use a copy or a separate queue for modifications.
  • NEVER calculate heavy recursive solvers in _process(); strictly cache results or use threaded workers for solve-checks.
  • NEVER ignore diagonal rules in pathfinding; strictly configure AStarGrid2D.diagonal_mode correctly.
Architecture & Performance
  • NEVER ship dual undo authorities; strictly use Godot's built-in UndoRedo via puzzle_undo_manager.gd — do not also maintain a hand-rolled Command stack.
  • NEVER intermingle "do" and "undo" logic in the same function; strictly maintain separation for predictable rollbacks.
  • NEVER use exact floating-point equality (==); strictly use is_equal_approx() for spatial constraints.
  • NEVER use load() for resetting large rooms dynamically; strictly use ResourceLoader.load_threaded_request().
  • NEVER leave Tween objects unreferenced; strictly kill active tweens before starting new movement on the same object.

🛠 Expert Components (scripts/)

MANDATORY reads before implementing the matching system:

  1. puzzle_undo_manager.gd — sole undo authority (UndoRedo)
  2. grid_manager.gd — Vector2i grid as truth
  3. puzzle_state_validator.gd — soft-lock / win checks on commit
Original Expert Patterns
Show full SKILL.md (252 more words)Show less
Modular Components

Do NOT load command_undo_redo.gd — legacy hand-rolled Command stack superseded by UndoRedo.


Core Loop

  1. Observe → 2. Hypothesize → 3. Commit move → 4. Validate → 5. Undo/Reset if needed

Decision Trees

Genre → scripts
Puzzle typeMANDATORY reads
Sokoban / push gridgrid_manager.gd, grid_tween_mover.gd, puzzle_undo_manager.gd, puzzle_state_validator.gd
Match-3match_three_logic.gd, grid_tween_mover.gd, puzzle_undo_manager.gd
Physics / spatialSnap on settle → then same undo/validator path; do not treat rigid bodies as truth
Hints / solverspuzzle_pathfinder.gd (AStarGrid2D.diagonal_mode)
Undo authority
NeedAction
Player undo/redoOnly puzzle_undo_manager.gd
Level editor historyStill UndoRedo — wrap editor actions the same way

Skill Chain

PhaseSkillsPurpose
1. Datadictionaries, resourcesGrid truth, level .tres
2. Inputgodot-input-handlingSnapped moves
3. Motiongodot-tweeningPiece Tweens
4. AI/hintsgodot-navigation-pathfindingA* hints
5. Persistgodot-save-load-systemsLevel / progress

Common Pitfalls

PitfallSolution
Dual undo APIsDelete Command-stack path; use UndoRedo manager only
Win check in _processValidate on move commit via state validator
Float grid coordsVector2i only

MANDATORY for depth beyond decision trees and script catalog: puzzle-elite-implementations.md. Do NOT Load on first-pass wiring — use bundled scripts/ first.

Architecture Overview

1. Command Pattern (Undo System)

Essential for puzzle games. Never punish testing.

gdscript

## Godot-Specific Tips

*   **Tweens**: Use `create_tween()` for all grid movements. It feels much better than instant snapping.
*   **Custom Resources**: Store level data (layout, starting positions) in `.tres` files for easy editing in the Inspector.
*   **Signals**: Use signals like `state_changed` to update UI/Visuals decoupled from the logic.

---

## Reference

> Progressive disclosure: open Official Documentation links only when researching a specific API;
> load Related Skills when routing work to a peer domain — do not preload the whole lattice.

### Official Documentation
- [UndoRedo](https://docs.godotengine.org/en/stable/classes/class_undoredo.html) — Built-in action history for do/undo/redo so puzzle experimentation does not require a hand-rolled command stack.
- [AStarGrid2D](https://docs.godotengine.org/en/stable/classes/class_astargrid2d.html) — Uniform-grid pathfinding (`diagonal_mode`, `jumping_enabled`) for hints and reachability on Sokoban-style boards.
- [Tween](https://docs.godotengine.org/en/stable/classes/class_tween.html) — Interruptible `create_tween()` motion for cell-to-cell feedback while logical `Vector2i` state updates immediately.
- [Using TileMaps](https://docs.godotengine.org/en/stable/tutorials/2d/using_tilemaps.html) — TileMapLayer workflows for painting walls/targets while keeping puzzle truth in a separate grid dictionary.
- [Saving games](https://docs.godotengine.org/en/stable/tutorials/io/saving_games.html) — Persist level progress, stars, and mid-puzzle snapshots without relying on scene reload as save.
- [Using InputEvent](https://docs.godotengine.org/en/stable/tutorials/inputs/inputevent.html) — Device-agnostic click/drag/action routing for forgiving grid selection and move commits.
- [Resources](https://docs.godotengine.org/en/stable/tutorials/scripting/resources.html) — Store layouts and starting piece sets as `.tres`/`Resource` data editable in the Inspector.
- [Physics introduction](https://docs.godotengine.org/en/stable/tutorials/physics/physics_introduction.html) — RigidBody sleep, layers, and integration hooks for physics-driven puzzle pieces.
- [Idle and Physics Processing](https://docs.godotengine.org/en/stable/tutorials/scripting/idle_and_physics_processing.html) — Why win/soft-lock checks belong on move commits, not every `_process` frame.
- [Data preferences](https://docs.godotengine.org/en/stable/tutorials/best_practices/data_preferences.html) — Prefer integer grid keys (`Vector2i`) and explicit dictionaries over SceneTree-as-truth.
- [Runtime file loading and saving](https://docs.godotengine.org/en/stable/tutorials/io/runtime_file_loading_and_saving.html) — `FileAccess`/`user://` patterns for custom level JSON and editor export packs.
- [JSON](https://docs.godotengine.org/en/stable/classes/class_json.html) — Serialize compact puzzle boards when splitting `Vector2` fields for portable level files.

### Related Skills

#### Prerequisites
- [godot-input-handling](https://github.com/thedivergentai/gd-agentic-skills/blob/main/skills/godot-input-handling/SKILL.md) — Buffered InputEvent/action maps so grid clicks and directional moves stay device-agnostic and forgiving.
- [godot-signal-architecture](https://github.com/thedivergentai/gd-agentic-skills/blob/main/skills/godot-signal-architecture/SKILL.md) — Safe `state_changed` / `level_complete` wiring so UI and VFX stay decoupled from grid truth.
- [godot-project-foundations](https://github.com/thedivergentai/gd-agentic-skills/blob/main/skills/godot-project-foundations/SKILL.md) — Autoload/project layout baselines before stacking undo managers, savers, and level packs.

#### Complements
- [godot-tweening](https://github.com/thedivergentai/gd-agentic-skills/blob/main/skills/godot-tweening/SKILL.md) — Deeper Tween composition when cell moves, match clears, and resets need interruptible juice without logic races.
- [godot-save-load-systems](https://github.com/thedivergentai/gd-agentic-skills/blob/main/skills/godot-save-load-systems/SKILL.md) — Progress ownership, versioning, and threaded loads beyond per-level JSON snapshots.
- [godot-tilemap-mastery](https://github.com/thedivergentai/gd-agentic-skills/blob/main/skills/godot-tilemap-mastery/SKILL.md) — TileMapLayer painting, custom data, and terrain patterns that visualize walls while scripts own solvability.
- [godot-navigation-pathfinding](https://github.com/thedivergentai/gd-agentic-skills/blob/main/skills/godot-navigation-pathfinding/SKILL.md) — Broader Navigation/A* stacks when puzzle hints outgrow a single `AStarGrid2D` region.
- [godot-2d-physics](https://github.com/thedivergentai/gd-agentic-skills/blob/main/skills/godot-2d-physics/SKILL.md) — RigidBody sleep, layers, and queries for physics puzzles that still need deterministic settle/win checks.
- [godot-state-machine-advanced](https://github.com/thedivergentai/gd-agentic-skills/blob/main/skills/godot-state-machine-advanced/SKILL.md) — Phase FSMs (observe → move → resolve → win) when puzzles mix animation locks with input gates.
- [godot-camera-systems](https://github.com/thedivergentai/gd-agentic-skills/blob/main/skills/godot-camera-systems/SKILL.md) — Camera2D/3D framing and unproject helpers for perspective/world-space puzzle overlays.
- [godot-ui-containers](https://github.com/thedivergentai/gd-agentic-skills/blob/main/skills/godot-ui-containers/SKILL.md) — Minimal undo/reset HUD layouts that stay non-intrusive during non-verbal tutorials.

#### Downstream / consumers
- [godot-monte-carlo-balancer](https://github.com/thedivergentai/gd-agentic-skills/blob/main/skills/godot-monte-carlo-balancer/SKILL.md) — Sample solvability, move-count distributions, and soft-lock rates so level packs stay fair as mechanics combine.
- [godot-procedural-generation](https://github.com/thedivergentai/gd-agentic-skills/blob/main/skills/godot-procedural-generation/SKILL.md) — Generate candidate boards that still pass this skill's validators, undo constraints, and win-condition contracts.
- [godot-genre-roguelike](https://github.com/thedivergentai/gd-agentic-skills/blob/main/skills/godot-genre-roguelike/SKILL.md) — Consumes grid/undo patterns when dungeon runs embed discrete puzzle rooms or locked-door logic.

#### Master
- [godot-master](https://github.com/thedivergentai/gd-agentic-skills/blob/main/skills/godot-master/SKILL.md) — Library router and mirrored module entry for discovering this genre skill beside sibling domains.

© 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-genre-puzzle of thedivergentai/GD-Agentic-Skills.

  • SKILL.md
  • references/migration-notes.md
  • references/puzzle-elite-implementations.md
  • scripts/command_undo_redo.gd
  • scripts/grid_input_manager.gd
  • scripts/grid_manager.gd
  • scripts/grid_tween_mover.gd
  • scripts/match_three_logic.gd
  • scripts/perspective_overlay.gd
  • scripts/puzzle_history.gd
  • scripts/puzzle_pathfinder.gd
  • scripts/puzzle_saver.gd
  • scripts/puzzle_state_validator.gd
  • scripts/puzzle_undo_manager.gd
  • scripts/puzzle_validator.gd
  • scripts/shuffle_bag.gd
  • scripts/sleepy_block.gd
  • scripts/tile_animator.gd

Open the folder on GitHubat commit 4c4d0ff

Compare with similar skills

Godot Genre Puzzle 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.

Godot Genre Puzzle compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Godot Genre Puzzle this skillthedivergentai/GD-Agentic-Skills821—~3.2kAutomated safety check: PassLGPL-3.0
Godot Gdscript Patterns925236118/AlphaAgent10310 repos~5kAutomated safety check: PassMIT
Godot Ability Systemjame581/GodotPrompter805—~3kAutomated safety check: PassMIT
Godot Camera Systemsjame581/GodotPrompter805—~2.8kAutomated safety check: PassMIT
Input MapperRandallLiuXin/GodotMaker5501 repos~727Automated safety check: PassCustom licence
Godotautonomous-ai/openharness1.2k—~570Automated safety check: PassMIT

Similar skills

  • Godot Gdscript Patterns

    925236118/AlphaAgent

    Master Godot 4 GDScript patterns including signals, scenes, state machines, and optimization.

    103 GitHub starsUsed in 10 repos~5k tokens
    Game DevelopmentAuto-check passed
  • Godot Ability System

    jame581/GodotPrompter

    Builds a data-driven ability system in Godot 4 from Resources and a component node, with cooldowns, buffs, stat modifiers, gameplay tags and HUD binding.

    805 GitHub stars~3k tokensUpdated 2 days ago
    Game DevelopmentAuto-check passed
  • Godot Camera Systems

    jame581/GodotPrompter

    Shows how to build cameras in Godot 4.3 and later: smooth follow, trauma-based screen shake, camera zones and transitions, with GDScript and C# examples for 2D and 3D.

    805 GitHub stars~2.8k tokensUpdated 2 days ago
    Game DevelopmentAuto-check passed
  • Input Mapper

    RandallLiuXin/GodotMaker

    Manage Godot input action mappings in project.godot. An agent skill from RandallLiuXin/GodotMaker.

    550 GitHub starsUsed in 1 repo~727 tokens
    Game DevelopmentAuto-check passed
  • Godot

    autonomous-ai/openharness

    Build Godot games with GDScript, native gameplay assertions and sandboxed Web exports.

    1.2k GitHub stars~570 tokensUpdated yesterday
    Game DevelopmentAuto-check passed
  • Game Design

    ericrisco/rsc-harness

    A skill your agent uses when designing or repairing what makes a game fun — verbs and mechanics, moment-to-moment/session/meta loops, progression, economy faucets and sinks, difficulty curves…

    180 GitHub stars~3.6k tokensUpdated yesterday
    Game DevelopmentAuto-check passed

More from thedivergentai/GD-Agentic-Skills

All 98 skills in this repo
  • Godot 2D Animation

    thedivergentai/GD-Agentic-Skills

    Expert patterns for 2D animation in Godot using AnimatedSprite2D and skeletal cutout rigs.

    821 GitHub stars~3.6k tokensUpdated 1 mo ago
    Auto-check passed
  • 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.

    821 GitHub stars~3.3k tokensUpdated 1 mo ago
    Auto-check passed
  • 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…

    821 GitHub stars~4.7k tokensUpdated 1 mo ago
    Auto-check passed
  • 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…

    821 GitHub stars~4.5k tokensUpdated 1 mo ago
    Auto-check passed
  • 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…

    821 GitHub stars~3.5k tokensUpdated 1 mo ago
    Auto-check passed
  • 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…

    821 GitHub stars~3.6k tokensUpdated 1 mo ago
    Auto-check passed

Works with

Questions about Godot Genre Puzzle

What does Godot Genre Puzzle do?

Expert blueprint for puzzle games including undo systems (Command pattern for state reversal), grid-based logic (Sokoban-style mechanics), non-verbal tutorials (teach through level design), win…. Godot Genre Puzzle is an agent skill from thedivergentai/GD-Agentic-Skills. Expert blueprint for puzzle games including undo systems (Command pattern for state reversal), grid-based logic (Sokoban-style mechanics), non-verbal tutorials (teach through level design), win condition checking, state management, and visual feedback (instant confirmation of valid moves).

When should I use Godot Genre Puzzle?

Godot Genre Puzzle fits situations like: physics puzzles; keywords: puzzlegame; nonverbaltutorial; statemanagement.

How do I install Godot Genre Puzzle in Claude Code?

Run `npx skills add thedivergentai/GD-Agentic-Skills --skill godot-genre-puzzle -a claude-code`. Or copy the skill folder (skills/godot-genre-puzzle in thedivergentai/GD-Agentic-Skills) into .claude/skills/godot-genre-puzzle in your project. Claude Code loads it when a task matches its description.

How do I install Godot Genre Puzzle in Codex?

Run `npx skills add thedivergentai/GD-Agentic-Skills --skill godot-genre-puzzle -a codex`. Or copy the skill folder (skills/godot-genre-puzzle in thedivergentai/GD-Agentic-Skills) into .agents/skills/godot-genre-puzzle in your project. Codex loads it when a task matches its description.

Can I use Godot Genre Puzzle 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-genre-puzzle -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-genre-puzzle, .gemini/skills/godot-genre-puzzle, .github/skills/godot-genre-puzzle and .opencode/skills/godot-genre-puzzle in your project.

What does Godot Genre Puzzle need to run?

SKILL.md names no scripts, command-line tools or credentials: Godot Genre Puzzle is instructions for the agent only.

Does Godot Genre Puzzle access the network?

SKILL.md names 1 domain. In commands or code: docs.godotengine.org; the agent is likely to contact it when it follows the instructions. This is read from the text; nothing was executed.

Is Godot Genre Puzzle 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 Genre Puzzle use?

Godot Genre Puzzle 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 Genre Puzzle use?

About 3.2k tokens (SKILL.md is roughly 13k 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 2.1k tokens, read only when the agent opens those files.

What are the alternatives to Godot Genre Puzzle?

Skills that share tags, products or a category with Godot Genre Puzzle: Godot Gdscript Patterns (925236118/AlphaAgent, 103 stars), Godot Ability System (jame581/GodotPrompter, 805 stars), Godot Camera Systems (jame581/GodotPrompter, 805 stars) and Input Mapper (RandallLiuXin/GodotMaker, 550 stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Godot Genre Puzzle?

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.