GameForge: Pipeline de IA para Gerar Jogos Mobile com Godot
qmertesdorf/mobile-gen
Pipeline de IA multi-skill que converte ideias em jogos Godot playáveis
Ver no GitHubSkill que transforma um prompt de uma linha em um jogo mobile Godot funcional através de uma cadeia de oito agentes Claude especializados (concept → builder → validator → deepen → asset → visual-audit → audio → packager). O foco é aprimorar as skills de geração e iteração, não apenas os jogos finais.
Instalação
npx convez-ai qmertesdorf/mobile-gen1 comando no terminal: detecta o formato do repositório (marketplace ou plugin avulso) e instala via Claude Code. Requer Node 18+ e o Claude Code instalado.
Métricas
Casos de uso
- Prototipagem rápida de conceitos de jogos mobile com IA
- Desenvolvimento iterativo guiado por validação e auditoria visual automática
- Geração de assets, áudio e builds completos via orquestração de skills
Veredito

Projeto ambicioso que demonstra orquestração sofisticada de múltiplas skills Claude para um fluxo de trabalho complexo. O foco na melhoria das skills (não apenas nos games) e a arquitetura manifest-driven revelam engenharia sólida, embora requeira setup pesado (ComfyUI, Godot, Android SDK) e seja melhor servido como referência técnica do que solução plug-and-play.
README
A tradução para o português deste README ainda está na fila.
GameForge (POC)
An AI pipeline that turns a one-line prompt into a playable mobile game, built as Claude Agent Skills. A chain of eight skills — concept → builder → validator → deepen → asset → visual-audit → audio → packager — drives a manifest-based design "spine" from idea to a buildable Godot project. The real deliverable is better skills, not the games themselves.
Quick start
The manifest tooling and the full test suite run with nothing but Node — no GPU, Godot, or ComfyUI needed:
npm install
npm test # 196 tests, network/SDK mocked
node tools/manifest.mjs create demo "My Demo" # scaffold a manifest (status=concept)
node tools/manifest.mjs validate demo # schema-check it
The agent skills themselves (.claude/skills/) run inside Claude Code. The asset/audio/build stages additionally require local ComfyUI, Godot 4.6.3, and the Android SDK — see the per-stage sections below and CLAUDE.md for the reference environment. Set GODOT_BIN to your Godot console executable and COMFY_HOST to your ComfyUI server if they aren't on PATH / at the defaults.
Pinned Godot version
4.6.3.stable — source of truth for every manifest's build.engine_version. Both machines must match (§11). Update here and in existing manifests if you bump it.
Layout
.claude/skills/— theconcept,builder,validator,deepen(in-place iteration),asset(re-skin/art),visual-audit(composited-screen audit),audio(SFX+music), andpackagerskills.manifests/<id>.json— one manifest per title (the spine; §5).games/<id>/— generated Godot projects.tools/manifest.mjs— the manifest CLI (create/set-status/merge/validate).schema/manifest.schema.json— the manifest schema.
The loop
prompt → concept → builder → validator → human playtest → ( deepen → validator → playtest )* → asset → visual-audit → audio → packager
The deliverable is better skills, not the games. deepen is the loop's first in-place ITERATION skill — it grows a validated/playable game along one depth axis (systemic / content / run-meta) without advancing status. A playable title's art re-skin runs the sub-chain asset → visual-audit → validator(re-run) → [styled].
Manifest CLI
node tools/manifest.mjs create <id> "<name>" # new skeleton, status=concept
node tools/manifest.mjs merge <id> '<json>' # deep-merge a partial (e.g. the concept block)
node tools/manifest.mjs set-status <id> <status> # concept→generated→validated→playable | →failed
node tools/manifest.mjs validate <id> # schema-check; exit 1 if invalid
Raster asset tool (M1.5)
tools/comfy.mjs turns a recipe into a committed RGBA PNG via a local ComfyUI server (assumed installed and running by the owner, like the Godot binary — not managed here). Default host http://127.0.0.1:8188, override with COMFY_HOST.
node tools/comfy.mjs --check # ping ComfyUI; report reachable + checkpoints
node tools/comfy.mjs gen <id> <asset-name> '<recipe>' # generate games/<id>/art/<name>.png
Stack: ComfyUI + SDXL (Juggernaut XL v9 fp16, no offload on 16 GB) + the ComfyUI-layerdiffuse node (RGBA at generation time, proven on an RTX 5080). Workflow-JSON templates with %placeholder% tokens live in tools/comfy-templates/. The asset skill's raster method owns the art judgment; comfy.mjs gen owns the deterministic HTTP plumbing (unit-tested with the network mocked — no GPU in CI).
Required local setup (not in this repo):
- ComfyUI pinned to v0.3.16 (commit
26c7baf) — required for LoRA-patch compatibility. - A one-line join-patch to
custom_nodes/ComfyUI-layerdiffuse/layered_diffusion.pyLayeredDiffusionDecodeRGBA.decode: build the RGBA tensor directly (torch.cat([rgb, alpha], -1)) AND use the parentdecode's alpha as-is — do NOT invert it. - ComfyUI venv on torch ≥2.7 / cu128 (we run 2.11.0+cu128) for any RTX 50-series/Blackwell GPU.
These requirements were validated end-to-end at a local raster feasibility gate.
Audio asset tool (M1.6)
tools/comfy.mjs gen-audio generates SFX and music clips via the same local ComfyUI server (COMFY_HOST).
node tools/comfy.mjs gen-audio <id> <clip-name> '<recipe>' # writes games/<id>/audio/<name>.wav
The audio skill (.claude/skills/audio/SKILL.md) owns the audio judgment — deriving the audio system, mapping core-loop events to SFX, and authoring recipes. comfy.mjs genAudio owns the deterministic HTTP plumbing (same unit-tested, network-mocked, no-GPU-in-CI pattern as gen).
Template: tools/comfy-templates/stable-audio.json. Stable Audio Open uses a separate CLIPLoader loading t5-base.safetensors (type:"stable_audio") that feeds both positive and negative CLIPTextEncode. KSampler uses scheduler:"exponential" (baked into the template). Clip duration comes from EmptyLatentAudio (minimum 1.0 s — do not go below).
Output format is WAV for this milestone (Godot-native, lossless, matches the schema format enum, zero extra deps). A 30 s music track is ~5 MB uncompressed; OGG is a future optimization.
Proven recipe defaults:
- SFX:
kind:"sfx",format:"wav",duration_s1.0–2.0,steps~8,cfg~5–6,sampler:"dpmpp_3m_sde_gpu". Negative excludes "music, melody, voice, speech". - Music:
kind:"music",format:"wav",duration_s20–40,steps~50,cfg~7,sampler:"dpmpp_3m_sde_gpu",loop:true.
Required local setup (not in this repo):
- Two UNGATED model files: checkpoint
stable-audio-open-1.0.safetensorsfromComfy-Org/stable-audio-open-1.0_repackaged→models/checkpoints/; text encodert5-base.safetensorsfromComfyUI-Wiki/t5-base→models/text_encoders/. - A
save_audiosoundfile-WAV patch tocomfy_extras/nodes_audio.py: under torch ≥2.11/cu128,torchaudio.saveroutes through TorchCodec (not installed, needs system FFmpeg). Patchsave_audioto write WAV viasoundfile(bundled libsndfile, no torchcodec/FFmpeg). This is the audio analog of the M1.5 LayerDiffuse join-patch. - Same ComfyUI v0.3.16 pin and torch 2.11.0+cu128 venv as the raster stack.
These requirements were validated end-to-end at a local audio feasibility gate.
Android export (build/ship)
tools/package.mjs carries a toolchain-guarded Godot Android export seam — the same pure-planner + impure-spawn + no-SDK-skip pattern as the raster/audio tools. The pure buildArtifactPlan and the preset emitters are unit-tested with no SDK; buildArtifact() spawns headless Godot and skips cleanly when ANDROID_HOME/ANDROID_SDK_ROOT is unset (CI posture).
node tools/package.mjs build <id> # debug APK → games/<id>/build/<id>-debug.apk
node tools/package.mjs build <id> --release --aab # signed AAB → games/<id>/build/<id>-release.aab
node tools/package.mjs verify-build <id> # assert the built file is a well-formed APK/AAB (skips w/o SDK)
The packager skill runs build after generating store assets and records store_pass.build_artifact (format, build_type, path, bytes, package). validator Method 5 runs verify-build when the toolchain is present. Build outputs and keystores are git-ignored (games/*/build/, *.apk, *.aab, *.keystore).
One-time machine setup (run tools/android-setup.ps1, then confirm the printed Godot editor-settings keys):
- Android SDK (Windows default
%LOCALAPPDATA%\Android\Sdk); exportANDROID_HOME/ANDROID_SDK_ROOTand addplatform-tools/emulatorto PATH. - Debug keystore at
~/.android/debug.keystoreviakeytool(aliasandroiddebugkey, store/key passandroid). - Godot editor settings (
%APPDATA%\Godot\editor_settings-4.tres): setexport/android/android_sdk_path+ the debug-keystore keys — headless CLI export reads these. - AVD via
avdmanager(verify a system-image boots inemulatorbefore relying on it).
Release signing (Phase B): the committed export_presets.cfg carries NO secrets. buildArtifact() for a release build sets Godot's GODOT_ANDROID_KEYSTORE_RELEASE_PATH/USER/PASSWORD env vars from tools/android-signing.local.json (git-ignored). AAB output requires Godot's gradle build enabled (gradle_build/use_gradle_build=true in the release preset) and an installed Android build template — this is the standard AAB path, not custom native gradle source. Play Console submission (developer account, listing, content rating, AAB upload) is the owner-gated final step.
Tests
npm test