SkillAgentSearch skills...

gm-build

Implement game mechanic functions via worker dispatch. Covers risk-first then main implementation. Dispatches workers until PLAN is clean, then runs one verify+review pass; loops until convergence. Explicit invocation only β€” use /gm-build.

Install / Use

npx skills add RandallLiuXin/GodotMaker --skill gm-build

Installs into whichever agent you are using.

About this skill
πŸ“„

SKILL.md

Installable skill definition

Quality Score

90/100

Category

Other

Supported Platforms

Universal

Our assessment of gm-build

gm-build scores 90/100 on our quality scale, 91st of 328 Other skills we index (top 28%).

Its SKILL.md is 14 KB long, well organised into 17 sections with 2 code examples: a thorough specification that gives an agent plenty to work with.

It has 562 GitHub stars, a meaningful sign that others use it.

Substance
30/30
Structure
18/20
Description
15/15
Adoption
12/20
Freshness
15/15

Maintenance, license and trust

  • The repository was last updated 26 days ago, so gm-build is actively maintained.
  • Our last check on 2026-10-30 found the source still online.
  • No license is declared. By default that means all rights are reserved: you can read it, but reusing or redistributing it is not clearly permitted. Ask the author before building on it commercially.
  • Its trust signals score 88/100, with 1 caution from licensing, adoption, age or documentation. These come from repository metadata, not a code audit β€” read the skill file before letting an agent act on it.

Safety scan

No issues found

Our scan of the whole file found no instruction hijacking, hidden characters, credential access, data exfiltration or destructive commands. An AI review of the same text found nothing harmful.

AI review by kimi-k2.7-code on 2026-10-04. Automated pattern scan on 2026-10-04. It catches known dangerous patterns, not every risk β€” read a skill before letting an agent act on it.

gm-build compared with similar skills

All 4 of these similar skills score higher than gm-build; compare them before choosing.

SkillScoreStarsUpdatedFormat
gm-build (this skill)by RandallLiuXin9056226d agoSKILL.md
algorithmic-artby anthropics100177.9k57d agoSKILL.md
pptxby anthropics100177.9k57d agoSKILL.md
prospectingby coreyhaines3110060.1k7d agoSKILL.md
ad-creativeby coreyhaines3110060.1k7d agoSKILL.md

Frequently asked questions

How do I install gm-build?
Run npx skills add RandallLiuXin/GodotMaker --skill gm-build. The install tabs above show the steps for each supported agent.
Which AI agents does gm-build work with?
It is written for Universal, as a SKILL.md file. Other agents that read the same format can often use it too.
Is gm-build safe to use?
Our scan of the whole file found no instruction hijacking, hidden characters, credential access, data exfiltration or destructive commands. An AI review of the same text found nothing harmful. It declares no license and scores 88/100 on trust signals. Skills are instructions an agent will follow, so read the file before installing it and do not approve commands you do not understand.
Is gm-build still maintained?
The repository was last updated 26 days ago, so gm-build is actively maintained.

name: gm-build description: | Implement game mechanic functions via worker dispatch. Covers risk-first then main implementation. Dispatches workers until PLAN is clean, then runs one verify+review pass; loops until convergence. Explicit invocation only β€” use /gm-build. disable-model-invocation: true

GodotMaker Build

$ARGUMENTS

You are implementing a Godot game by dispatching Worker subagents. Risk tasks first, then main tasks β€” both surfaced from PLAN.md, which is scoped to the current tag (read the **Tag:** header at the top of PLAN.md). You do NOT build the whole game in one go; later tags will add features on top of this one.

Session Setup

FIRST ACTION β€” before anything else: Write build to .godotmaker/current_role.

Resume Check

Read .godotmaker/stage.jsonl (treat as empty if missing) β€” each line is {"role": X, "ts": Y}.

  • If project.godot does not exist β†’ STOP. Tell user to run /gm-scaffold first.
  • If ROADMAP.md does not exist β†’ STOP. Tell user to run /gm-gdd first.
  • If no event with role == "gdd" exists anywhere in the file β†’ STOP. Tell user to run /gm-gdd first.
  • If PLAN.md is missing the **Tag:** header β†’ STOP. Tell user the file is stale and to re-run /gm-gdd to regenerate it for the current tag.

Read .godotmaker/verify_report.json if it exists.

Define pending verify feedback as:

  • .godotmaker/verify_report.json exists.
  • Its top-level result is "fail".
  • Its ts is later than the latest role == "build" event in stage.jsonl, or there is no prior build event.

Apply the resume gates in this order:

  • If pending verify feedback exists β†’ proceed to Step 0, even if the last event is build and all PLAN.md tasks are already verified.
  • If the last event has role == "build" AND all PLAN.md tasks are verified β†’ STOP. Tell the user:

    "Build already completed for the current tag at {timestamp}. Recommended next: /gm-verify. If you need to redo this step or have other plans, just tell me."

  • Otherwise β†’ proceed (this includes resume from interrupted run AND new tasks added by reviewer).

Then read context:

  • PLAN.md β†’ current tag's **Tag:** header + Tag Mechanics + Inherited Mechanics + Playable Unit + pending/in_progress/completed tasks (anything not verified)
  • STRUCTURE.md β†’ architecture and build order (current tag scope: previous tags' systems already exist on disk and may be touched only when PLAN.md explicitly lists a refactor task for them)
  • ASSETS.md β†’ the generated-runtime authority; for a visual task, derive each asset with tools/asset_result_registration.py --snapshot
  • MEMORY.md index + sub-files β†’ stable architecture decisions and project constraints
  • docs/tags/<prev_tag>/STRUCTURE.md (only if PLAN.md has Inherited Mechanics or refactor tasks touching prior systems) β†’ know what already exists before adding/refactoring. Read docs/tags/<prev_tag>/SUMMARY.md first β€” it is one screen and often answers the question without opening the full archive; docs/tags/README.md lists every sealed tag if you are not sure which one to open.

Hard Rules

Asset Runtime Authority

ASSETS.md is the sole runtime-asset authority. For a visual task, derive the snapshot with tools/asset_result_registration.py --snapshot and never read a stable entry, manifest pointer, or root index. The snapshot resolves generated and complete user-provided runtime rows, including uniquely named rows introduced by earlier tags.

  1. You CANNOT write .gd/.tscn/.tres directly. All game code goes through Worker dispatch.
  2. You and your workers CANNOT write to e2e/ directory. E2E tests are owned by the Evaluator.
  3. Workers CANNOT modify PLAN.md/STRUCTURE.md/ASSETS.md.
  4. Worker reports are validated by hooks β€” incomplete reports are blocked and retried.
  5. MUST NOT skip stages. Fix issues first; apply the evidence-based five-repair gate in references/repair-attempt-accounting.md.
  6. MUST NOT self-certify completion. Dispatch verifiers, then reviewers. Triaging a reviewer finding to REJECT or SKIP requires a citation per references/reviewer-finding-triage.md (mandatory for critical/major; optional for minor).
  7. Tag scope discipline. Workers MAY touch files from previous tags only if PLAN.md has an explicit refactor / fix task naming those files. New systems live alongside existing ones; do not silently rewrite prior-tag code as a "cleanup" detour.
  8. Build the Playable Unit. PLAN.md tasks must integrate into the Playable Unit's player-experienced path. Do not treat isolated systems, simulation helpers, or unit tests as sufficient.

Honest Reporting

  • If tests fail, report failures with output β€” do not claim success
  • If a verification step was not run, say SKIP β€” do not imply PASS
  • If a worker's output is unclear, re-verify before accepting
  • Never characterize incomplete work as done

Plan Discipline (Single-Direction State)

Tasks transition forward only:

pending β†’ in_progress β†’ completed β†’ verified
  • Never move backward (e.g., verified β†’ pending)
  • Never skip states
  • Update PLAN.md IMMEDIATELY when a task changes status

When you ACCEPT a reviewer finding against a verified task: Do NOT change the existing task's state. Add a NEW task (status pending) describing the fix. The original task stays verified. The new task goes through the full lifecycle. REJECT and SKIP do not create tasks; see references/reviewer-finding-triage.md.

This way the state is always monotonic and the audit trail is preserved.

A failed task requires a new task or user escalation β€” do not retry in place.

Build Cycle

The cycle has three steps and runs until convergence (PLAN clean and the last verify+review pass produced no new ACCEPTED tasks). Reviewer is invoked once per cycle iteration β€” after every PLAN task reaches completed, not on a worker-count cadence.

Step 0 β€” Process Verify Feedback

Run this step before Step 1 only if pending verify feedback exists. Otherwise β†’ skip to Step 1.

Translate failures into pending tasks at the bottom of PLAN.md.

Project-code tasks (any checks.<name>.result == "fail") β€” go through the normal Worker β†’ Verifier β†’ Reviewer cycle:

  • checks.build.errors[] β†’ one task per distinct compile error (file + line + message in Notes).
  • checks.unit_tests.failures[] β†’ one task per failing test. If failed > 0 but failures[] is empty, one task: "investigate test runner output".
  • checks.lint.issues[] β†’ group by file when multiple issues hit the same file; otherwise one per issue.
  • checks.lint.format_drift β†’ one task: "run <format_drift.command> to format the drifted files (<file_count> files)".
  • checks.static_check.issues[] β†’ one task per issue, using check as the title prefix (e.g. missing_unit_test: s_player_input). For unknown check discriminators, use the raw value verbatim β€” generic project-code fix.

Config tasks (any checks.<name>.result == "error", paired with one tooling_notes[] entry) β€” main agent applies directly, NO worker dispatch:

  • Routable fallback (exclude_file / scope_narrow / add_gdlintrc_rule / skip_check) WITH operand present (per the fallback table in gm-verify/SKILL.md Section B) β†’ apply the structured edit using the note's operand. Mark verified after the next verify round confirms the tool no longer crashes there. Hard Rule 1 only restricts .gd/.tscn/.tres.
  • escalate, OR routable with missing operand, OR unknown discriminator β†’ do NOT auto-fix. Surface tool + error + crashed_on (and any original suggested_fallback) to the user verbatim, halt the build cycle, leave the task pending until the user resolves the underlying issue.

Do NOT delete project code as a "fix" for a tool crash.

Step 1 β€” Dispatch Workers (until PLAN is clean)

  • Read references/worker-dispatch.md for the brief template
  • Read and apply references/repair-attempt-accounting.md after every worker handoff. Increment dispatch_count for the handoff, then classify it from the report evidence before changing any retry counter or task state.
  • Use subagent_type: "worker". Each worker implements ONE game mechanic function + its tests.
  • Include the relevant Playable Unit fields in each worker brief.
  • For visual tasks, fill the Asset Runtime Snapshot and Visual Asset Contract sections from references/worker-dispatch.md. The snapshot is tools/asset_result_registration.py --snapshot output pasted verbatim. If it fails for an asset, report its error instead of dispatching against an invented path.
  • Max 3 in parallel with disjoint file sets via isolation: "worktree" (send all Agent calls in one message).
  • After each worker reports DONE, mark its task in PLAN.md as completed.
  • main_scene retarget is your job. Scaffold leaves run/main_scene="res://scenes/main.tscn" (placeholder). After the worker that creates this tag's entry scene (per SCENES.md) completes and the .tscn is on disk, Edit project.godot's [application] run/main_scene to res://<path>.
  • Continue dispatching until PLAN.md has no pending or in_progress tasks (everything is completed or verified). Then go to Step 2.

Step 2 β€” Verify + Review Pass

Run ONE verifier, then ONE reviewer, on the integrated state:

Verifier:

  • Read references/verifier-dispatch.md for the brief template
  • Use subagent_type: "verifier". Pass all completed-but-not-yet-verified workers' deliverables.
  • On FAIL: add NEW pending fix tasks in PLAN.md. Failed tasks stay completed. Go back to Step 1.
  • On PASS: update those tasks from completed β†’ verified.

Reviewer (after verifier passes):

  • Read references/reviewer-dispatch.md for the brief template
  • Use subagent_type: "reviewer". Reviewer reports back; do not let it modify project files.
  • Ask the reviewer to check gameplay authenticity for the integrated Playable Unit.
  • Include Asset Runtime Snapshot when reviewed files use visual assets.
  • Triage each finding per references/reviewer-finding-triage.md into one of three options:
    • ACCEPT β†’ add NEW pending fix task to PLAN.md.
    • REJECT β†’ finding is wrong; do not create a task (citation required for critical/major).
    • SKIP β†’ finding is real but not worth fixing now; do not create a task (citation required for critical/major).
  • Defaults when uncertain: critical/major β†’ ACCEPT; minor β†’ SKIP.
  • If you ACCEPTED any findings β†’ go back to Step 1.
  • If verifier passed AND reviewer added zero ACCEPTED tasks β†’ exit cycle (proceed to "When Done").

The build cycle continues until ALL tasks are verified AND the most recent verify+review pass produced no new ACCEPTED tasks AND the verifier passed.

Retry Limits

Five effective production repairs, not five dispatches, are the only failure gate. Apply references/repair-attempt-accounting.md: incomplete handoffs and orchestration failures use its no-progress process, keep the task continuable, and do not consume the repair budget.

Parallel Worker Rules

  • Never parallelize workers that share files
  • Workers with disjoint file sets use isolation: "worktree"
  • Max 3 parallel workers at once (file isolation constraint)
  • After parallel workers complete, merge branches and build-check
  • See references/worker-dispatch.md β†’ Parallel Worker Dispatch for merge procedure

Architecture and Constraints Record

MEMORY.md              <- Architecture and constraints index
memory/
  {system_name}.md     <- Detailed system architecture and constraints
  • Read MEMORY.md before dispatching workers.
  • Write only stable architecture decisions or project constraints. Do not record task history, failures, gotchas, workarounds, reviewer triage, or other dynamic learning.
  • Do not update MEMORY.md when no durable architecture or constraint changed.
  • Where the runtime exposes SubagentStop lifecycle hooks

Truncated for display β€” read the full file on GitHub.

Related Skills

View on GitHub
GitHub Stars562
CategoryOther
Updated26d ago
Forks50

Languages

Python

Trust signals

88/100

From repository metadata: license, adoption, age and documentation. Not a code audit β€” see the Safety scan above for what the skill file itself contains.

1 medium
gm-build β€” Universal Skill: Install & Safety Check | SkillAgent