Agent skill

Godot Genre Rhythm

by thedivergentai in thedivergentai/GD-Agentic-Skills

Expert blueprint for rhythm games including audio synchronization (BPM conductor, latency compensation with AudioServer.gettimesincelastmix), note highways (scroll speed, timing windows), judgment…

LGPL-3.0Auto-check passedGame Development

Install Godot Genre Rhythm

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

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

GitHub CLI
$ gh skill install thedivergentai/GD-Agentic-Skills godot-genre-rhythm --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-rhythm .claude/skills/godot-genre-rhythm && 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-rhythm
GitHub stars
821
Token cost
~3.4k tokens
SKILL.md length
697 words
Files
15 (incl. scripts, references)
Skills in repo
98
Repo updated
First seen
Licence
LGPL-3.0

At a glance

Expert blueprint for rhythm games including audio synchronization (BPM conductor, latency compensation with AudioServer.gettimesincelastmix), note highways (scroll speed, timing windows), judgment…

  • Works in 4 steps: Audio latency: Calibrate with… → Input polling: Use _input not _process… → Shaders: UV scrolling for note highways → …
  • Keywords: rhythmgame
  • SKILL.md covers NEVER Do (Expert Anti-Patterns), 🛠 Expert Components (scripts/), Core Loop and Decision Trees, plus 3 more sections
  • Reaches docs.godotengine.org

What it does

Godot Genre Rhythm is an agent skill from thedivergentai/GD-Agentic-Skills. Expert blueprint for rhythm games including audio synchronization (BPM conductor, latency compensation with AudioServer.gettimesincelastmix), note highways (scroll speed, timing windows), judgment systems (Perfect/Great/Good/Bad/Miss), scoring with combo multipliers, input processing (lane-based, hold note detection), and chart/beatmap loading. Based on DDR/osu!/Beat Saber research. Trigger keywords: rhythmgame, audiosync, timingjudgment, notehighway, combosystem, BPMconductor, latencycompensation.

Its SKILL.md is about 3.4k tokens, which your agent loads only when the skill is triggered. The skill folder holds 16 other files, including scripts and reference files (for example `references/migration-notes.md` and `references/rhythm-systems-deep.md`).

It sits in Game Development, covering Game development and Game assets and audio. 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

  • Keywords: rhythmgame
  • Latencycompensation

Example prompts

  • “/godot-genre-rhythm”

Workflow steps

4 steps, taken from the first numbered list in SKILL.md.

  1. Audio latency: Calibrate with AudioServer and custom offset
  2. Input polling: Use _input not _process for precise timing
  3. Shaders: UV scrolling for note highways
  4. Particles: Use GPUParticles2D for hit effects

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 12 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 Rhythm loads about 3.4k tokens when it runs, and up to ~6.7k if it reads all its reference files. Until then it costs about 133 tokens; SKILL.md has 697 words of instructions outside code blocks.

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

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). 697 words, ~3,370 tokens.

Download SKILL.mdSave it as .claude/skills/godot-genre-rhythm/SKILL.md (or your agent's skills folder). This skill also uses 14 other files; get the full folder from GitHub.
name
godot-genre-rhythm
description
Expert blueprint for rhythm games including audio synchronization (BPM conductor, latency compensation with AudioServer.get_time_since_last_mix), note highways (scroll speed, timing windows), judgment systems (Perfect/Great/Good/Bad/Miss), scoring with combo multipliers, input processing (lane-based, hold note detection), and chart/beatmap loading. Based on DDR/osu!/Beat Saber research. Trigger keywords: rhythm_game, audio_sync, timing_judgment, note_highway, combo_system, BPM_conductor, latency_compensation.

NEVER Do (Expert Anti-Patterns)

Audio Sync & Logic
  • NEVER use Time.get_ticks_msec() / Time.get_ticks_usec() as the song clock; strictly use AudioStreamPlayer.get_playback_position() + AudioServer.get_time_since_last_mix() - AudioServer.get_output_latency() (see rhythm_conductor.gd).
  • NEVER process song logic in _process(); strictly use _physics_process() or a conductor loop to ensure deterministic timing regardless of render frames.
  • NEVER use _process() to capture hit inputs; strictly use _input(event) to record the exact timestamp of the button press event.
  • NEVER scale engine time_scale for song speed; strictly use AudioStreamPlayer.pitch_scale to adjust speed and avoid globally breaking physics logic.
  • NEVER neglect Audio Latency calibration; strictly provide a tool for players to adjust for hardware/Bluetooth delays (~30-100ms) to prevent "unplayable" sync issues.
  • NEVER use _process delta as the song clock; strictly read the conductor's get_song_time() (playback + mix − output latency).
  • NEVER move thousands of note sprites on the CPU; strictly use a Shader-Based Highway (UV scrolling) to offload track movement to the GPU.
  • NEVER use yield or await for beat timing; strictly use a sample-accurate Delta Accumulator tied to the audio clock.
  • NEVER assume a constant BPM; strictly build your conductor to handle a Tempo Map for complex track changes.
Feedback & Performance
  • NEVER judge inputs based on world position (pixels); strictly judge against the Song's Elapsed Time (ms) to ensure consistency across resolutions.
  • NEVER play hit sounds with static pitch; strictly add ±5% Random Pitch Variation to hit sounds to avoid the "machine gun" effect.
  • NEVER use tight timing windows (e.g., <25ms) for all players; strictly use Wider Windows for Beginners to prevent immediate frustration.
  • NEVER instantiate note nodes every beat; strictly use Object Pooling to recycle note instances and prevent GC spikes during dense tracks.
  • NEVER use standard Area2D signals for rhythmic hits; strictly Poll Inputs in the conductor loop to compare against target timestamps.
  • NEVER calculate FFT for visualization on the main thread; strictly use AudioEffectSpectrumAnalyzerInstance for optimized engine-side analysis.
  • NEVER allow note spamming/mashing; strictly penalize misses or break combos to maintain the game's integrity.
  • NEVER use load() dynamically during gameplay; strictly use ResourceLoader.load_threaded_request() to avoid thread stalling.
  • NEVER forget to pause the conductor/ highway; strictly sync with the audio player's pause state to prevent notes from scrolling while the music is stopped.

🛠 Expert Components (scripts/)

MANDATORY reads before implementing the matching system:

  1. rhythm_conductor.gd — canonical audio clock
  2. input_judge_logic.gd — time-window judging
  3. note_object_pool.gd — pooled notes (no per-beat instantiate)
  4. latency_calibrator.gd — player hardware offset
Original Expert Patterns
Show full SKILL.md (276 more words)Show less
Modular Components

Do NOT load unused lanes: skip audio_spectrum_analyzer.gd unless building reactive viz; skip dynamic_bpm_handler.gd for constant-BPM tracks.


Script map: Baseline MusicConductor samples → rhythm_conductor.gd; JudgmentSystem → input_judge_logic.gd; chart spawn → note_orchestrator.gd + note_object_pool.gd.

Core Loop

  1. Calibrate latency → 2. Conductor clock → 3. Spawn pooled notes → 4. _input judge → 5. Score/combo UI

Decision Trees

Clock (one recipe)
NeedAction
Song positionMANDATORY rhythm_conductor.gd get_song_time()
Visual highwayPosition from song time / beats — never _process delta integration as truth
Hit timestampCapture in _input / _unhandled_input, compare to note target time
Systems

Do not re-inline MusicConductor / NoteHighway / JudgmentSystem / RhythmScoring classes in this skill — load the scripts.

Skill Chain

PhaseSkillsPurpose
1. Audiogodot-audio-systemsStream clock + latency
2. Inputgodot-input-handlingTimestamped hits
3. UIgodot-ui-containersHighway / HUD
4. Perfpooling / shadersDense charts
5. Balancegodot-monte-carlo-balancerWindow difficulty bands

Common Pitfalls

PitfallSolution
Time.get_ticks_* conductorUse playback + mix − latency
Judge in _process_input + song time
Instantiate per notenote_object_pool.gd

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

Godot-Specific Tips

  1. Audio latency: Calibrate with AudioServer and custom offset
  2. Input polling: Use _input not _process for precise timing
  3. Shaders: UV scrolling for note highways
  4. Particles: Use GPUParticles2D for hit effects
3. Hardware-Synced Latency Calibration

Calculate precise offsets by compensating for OS/Hardware latency.

gdscript

## 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
- [Sync the gameplay with audio and music](https://docs.godotengine.org/en/stable/tutorials/audio/sync_with_audio.html) — Playback-position helpers (`get_time_since_last_mix`, output latency) that every BPM conductor and judgment window must use.
- [Audio streams](https://docs.godotengine.org/en/stable/tutorials/audio/audio_streams.html) — AudioStreamPlayer roles, pitch_scale for song speed, and how music reaches buses without breaking sync.
- [Audio buses](https://docs.godotengine.org/en/stable/tutorials/audio/audio_buses.html) — Route Music / HitSFX / UI so judgment SFX never fight the track bus.
- [Importing audio samples](https://docs.godotengine.org/en/stable/tutorials/assets_pipeline/importing_audio_samples.html) — WAV vs Ogg/MP3 tradeoffs for charts, hit clicks, and calibration tones.
- [AudioServer](https://docs.godotengine.org/en/stable/classes/class_audioserver.html) — Mix/output latency APIs and bus-effect instances used by conductors and spectrum visuals.
- [AudioStreamPlayer](https://docs.godotengine.org/en/stable/classes/class_audiostreamplayer.html) — Non-positional music/hit player API (`get_playback_position`, `pitch_scale`, pause) for the highway clock.
- [AudioEffectSpectrumAnalyzer](https://docs.godotengine.org/en/stable/classes/class_audioeffectspectrumanalyzer.html) — Engine-side FFT effect for reactive highways without main-thread FFT work.
- [Using InputEvent](https://docs.godotengine.org/en/stable/tutorials/inputs/inputevent.html) — `_input` / action press timing for lane hits instead of polling in `_process`.
- [CanvasItem shaders](https://docs.godotengine.org/en/stable/tutorials/shaders/shader_reference/canvas_item_shader.html) — UV scroll patterns for GPU note highways that avoid moving thousands of sprites on CPU.
- [Tween](https://docs.godotengine.org/en/stable/classes/class_tween.html) — Judgment splash, receptor pulse, and beat-synced scale pops without frame-tied lerps.
- [Background loading](https://docs.godotengine.org/en/stable/tutorials/io/background_loading.html) — Threaded chart/audio preload so dense tracks never stall the first note.

### Related Skills

#### Prerequisites
- [godot-project-foundations](https://github.com/thedivergentai/gd-agentic-skills/blob/main/skills/godot-project-foundations/SKILL.md) — Audio latency project settings, bus layout names, and input map lane actions must exist before the conductor runs.
- [godot-audio-systems](https://github.com/thedivergentai/gd-agentic-skills/blob/main/skills/godot-audio-systems/SKILL.md) — Buses, stream players, spectrum instances, and sync-with-audio helpers this genre skill consumes for BPM clocks.
- [godot-input-handling](https://github.com/thedivergentai/gd-agentic-skills/blob/main/skills/godot-input-handling/SKILL.md) — Action maps, `_input` vs `_unhandled_input`, and event timestamps for lane press/release and anti-spam.
- [godot-gdscript-mastery](https://github.com/thedivergentai/gd-agentic-skills/blob/main/skills/godot-gdscript-mastery/SKILL.md) — Typed Resources for NoteData/charts, signals for beat/judgment events, and deterministic timing loops.

#### Complements
- [godot-tweening](https://github.com/thedivergentai/gd-agentic-skills/blob/main/skills/godot-tweening/SKILL.md) — Judgment labels, receptor flashes, and beat pulses should be Tween-driven, not per-frame scale hacks.
- [godot-shaders-basics](https://github.com/thedivergentai/gd-agentic-skills/blob/main/skills/godot-shaders-basics/SKILL.md) — Shader highways and spectrum-driven uniforms keep dense charts off the CPU.
- [godot-particles](https://github.com/thedivergentai/gd-agentic-skills/blob/main/skills/godot-particles/SKILL.md) — Hit sparks and combo flourishes via GPUParticles2D without instantiating VFX every Perfect.
- [godot-ui-containers](https://github.com/thedivergentai/gd-agentic-skills/blob/main/skills/godot-ui-containers/SKILL.md) — Score/combo HUD, calibration sliders, and lane receptor layout as Control trees.
- [godot-save-load-systems](https://github.com/thedivergentai/gd-agentic-skills/blob/main/skills/godot-save-load-systems/SKILL.md) — Persist A/V offset, scroll speed, and difficulty windows across sessions.
- [godot-autoload-architecture](https://github.com/thedivergentai/gd-agentic-skills/blob/main/skills/godot-autoload-architecture/SKILL.md) — Conductor / scoring / pool owners are typically Autoloads with a clear boot order.
- [godot-signal-architecture](https://github.com/thedivergentai/gd-agentic-skills/blob/main/skills/godot-signal-architecture/SKILL.md) — Beat, judgment, combo-break, and chart-finished signals need owner boundaries so UI never owns the clock.

#### Downstream / consumers
- [godot-performance-optimization](https://github.com/thedivergentai/gd-agentic-skills/blob/main/skills/godot-performance-optimization/SKILL.md) — Escalate when note pools, highway draw calls, or mix callbacks still hitch after pooling and shader scroll.
- [godot-monte-carlo-balancer](https://github.com/thedivergentai/gd-agentic-skills/blob/main/skills/godot-monte-carlo-balancer/SKILL.md) — Simulate timing-window width, scroll speed, and miss penalties against clear rates before shipping difficulty tiers.

#### Master
- [godot-master](https://github.com/thedivergentai/gd-agentic-skills/blob/main/skills/godot-master/SKILL.md) — Library router and mirrored module entry; open when discovering which Domain Skill owns a cross-cutting rhythm 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 14 other files (scripts, references) in skills/godot-genre-rhythm of thedivergentai/GD-Agentic-Skills.

  • SKILL.md
  • references/migration-notes.md
  • references/rhythm-systems-deep.md
  • scripts/audio_spectrum_analyzer.gd
  • scripts/beat_synced_animator.gd
  • scripts/dynamic_bpm_handler.gd
  • scripts/input_judge_logic.gd
  • scripts/latency_calibrator.gd
  • scripts/note_lane_manager.gd
  • scripts/note_object_pool.gd
  • scripts/note_orchestrator.gd
  • scripts/rhythm_conductor.gd
  • scripts/rhythm_scoring_system.gd
  • scripts/rhythm_ui_feedback.gd
  • scripts/score_combo_manager.gd

Open the folder on GitHubat commit 4c4d0ff

Compare with similar skills

Godot Genre Rhythm 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 Rhythm compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Godot Genre Rhythm this skillthedivergentai/GD-Agentic-Skills821—~3.4kAutomated safety check: PassLGPL-3.0
Godot Assets Pipelinejame581/GodotPrompter805—~3.6kAutomated safety check: PassMIT
Godot Audio Systemjame581/GodotPrompter805—~3.7kAutomated safety check: PassMIT
Game Assetsglifxyz/glif-mcp-server213—~831Automated safety check: PassMIT
Scenario Game Assetsscenario-labs/skills946—~4.5kAutomated safety check: PassMIT
Scenario 3Dscenario-labs/skills946—~3.8kAutomated safety check: PassMIT

Similar skills

  • Godot Assets Pipeline

    jame581/GodotPrompter

    Explains how Godot 4.3 and later imports assets: image compression modes, 3D scenes, audio and resource formats, and import settings, with GDScript and C# examples.

    805 GitHub stars~3.6k tokensUpdated 2 days ago
    Game DevelopmentAuto-check passed
  • Godot Audio System

    jame581/GodotPrompter

    Godot 4.3+ audio guide: player nodes, audio buses, looping, decibel volume control, bus effects, music management and sound-effect pooling in GDScript and C#.

    805 GitHub stars~3.7k tokensUpdated 2 days ago
    Game DevelopmentAuto-check passed
  • Game Assets

    glifxyz/glif-mcp-server

    Make art and media for a game you are building with Glif: character reference sheets, consistent characters, pixel-art sprite sheets with animation cycles, seamless and PBR textures, 3D models, item…

    213 GitHub stars~831 tokensUpdated 2 days ago
    Game DevelopmentAuto-check passed
  • Scenario Game Assets

    scenario-labs/skills

    A skill your agent uses when creating game art through Scenario MCP: sprites, sprite sheets, icons, props, loot, tilesets and autotile terrain transitions, seamless tiles, isometric buildings…

    946 GitHub stars~4.5k tokensUpdated yesterday
    Game DevelopmentAuto-check passed
  • Scenario 3D

    scenario-labs/skills

    A skill your agent uses when generating or handling 3D assets through the Scenario MCP server, including text-to-3D or image-to-3D meshes, GPT-6 Astra 3D or Claude Opus 5.5 3D, GLB, FBX, OBJ, STL…

    946 GitHub stars~3.8k tokensUpdated yesterday
    Game DevelopmentAuto-check passed
  • 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

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 Rhythm

What does Godot Genre Rhythm do?

Expert blueprint for rhythm games including audio synchronization (BPM conductor, latency compensation with AudioServer.gettimesincelastmix), note highways (scroll speed, timing windows), judgment…. Godot Genre Rhythm is an agent skill from thedivergentai/GD-Agentic-Skills.gettimesincelastmix), note highways (scroll speed, timing windows), judgment systems (Perfect/Great/Good/Bad/Miss), scoring with combo multipliers, input processing (lane-based, hold note detection), and chart/beatmap loading.

When should I use Godot Genre Rhythm?

Godot Genre Rhythm fits situations like: keywords: rhythmgame; latencycompensation.

How do I install Godot Genre Rhythm in Claude Code?

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

How do I install Godot Genre Rhythm in Codex?

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

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

What does Godot Genre Rhythm need to run?

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

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

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

About 3.4k 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 3.3k tokens, read only when the agent opens those files.

What are the alternatives to Godot Genre Rhythm?

Skills that share tags, products or a category with Godot Genre Rhythm: Godot Assets Pipeline (jame581/GodotPrompter, 805 stars), Godot Audio System (jame581/GodotPrompter, 805 stars), Game Assets (glifxyz/glif-mcp-server, 213 stars) and Scenario Game Assets (scenario-labs/skills, 946 stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Godot Genre Rhythm?

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.