The balance call came back 3,105 credits. That was September 3rd. The rig pipeline had been running for two days on a humanoid made of skinned capsule parts.
Not a single credit spent. That was the point.
The project
EVA Music is a 24/7 radio-style stream with a real-time visualiser. Godot 4. A 2.5D toon render. One persistent World3D. A host avatar of me on stage reacting to the music. The avatar starts as a Meshy API generation: reference photo in, 3D mesh out. It’s rigged in Blender, exported as a Godot-compatible scene, then wired into an animation tree that responds to audio amplitude bands.
Building it left-to-right has an obvious failure mode. Start with the avatar, wire everything up around it. Meshy charges credits per generation. Getting from a reference photo to a usable, Godot-compatible mesh isn’t guaranteed in one attempt: mesh topology can be poor, rigging incompatibilities surface only in Blender, bone naming conventions have to match what the downstream Godot systems expect. Discovering any of those problems after the mesh exists means paying for the same failure in both credits and rework.
The right order inverts it: build every downstream system first, prove it against a zero-cost proxy, then generate the real mesh once into a pipeline you know works.
September 1st: the stage, the clock, the music
P0 was the bootstrap. Repo, toolchain, Godot skeleton, set-pipeline scaffold, MCP wiring. One morning.
P1 was the studio set. blender/tools/kit.py generates 11 assets from bmesh primitives: procedural, deterministic, licence-free, toon-friendly. build_set.py instances them from a sets/studio/spec.json spec. The set isn’t baked geometry; it’s declarative. A Sky3D clock tracks real time. By end of afternoon the resting shot was locked.
P2 was the audio pipeline. The original plan used a .mjs script for the Remotion manifest; I switched to Python to keep one test stack rather than two. tools/manifest_from_remotion.py converts the Remotion manifest into data/stream-manifest.json, joining NAPA masters by TRACK_NN number. Amplitude bands got wired into stage reactivity: lights, particle effects, set elements all reacting to the music in real time.
By end of day one: a working studio set, a live Sky3D clock, a music-reactive stage, and no avatar. All three systems were production-ready. None required a mesh.
The placeholder host was enough to verify the full environment. The stage had something to react to. The resting shot confirmed the camera framing. Every visual system that would eventually surround the avatar was proven without it.
September 2nd: the proxy rig
blender/cj/proxy_rig.py.
The script generates a Mixamo-named humanoid stand-in: 22 core mixamorig: bones at human proportions, skinned capsule parts, five VRM-named face shape keys. The naming convention is the important part. Every downstream system was written against these bone names: Godot’s animation tree, the blend shape bindings, the IK constraints. Not against the proxy’s geometry. The geometry is throwaway.
The proxy exercises the full rig pipeline at zero cost. By end of September 2nd, the proxy had been through every animation state the real avatar would need. The IK constraints held. The blend shapes responded to amplitude bands. The import pipeline from Blender to Godot was verified.
What the proxy is not for: appearance. It looked like a capsule person with bones. That was correct and deliberate. Any work spent on visual fidelity at this stage is waste.
The proxy also encodes the bone contract as an executable artefact. This matters more than it might seem. A bone-naming convention written in a README can drift silently. A convention that lives in a generatable script gets tested every time the script runs. If the convention changes, the proxy regenerates with the new names, and every downstream system that still references the old names breaks immediately, in Blender, before the real mesh is touched. The contract is machine-verified, not assumed.
September 3rd: the real mesh
tools/meshy.py.
Stdlib-only. TDD, 7 tests. Wraps the Meshy API without a dedicated SDK dependency. The Meshy API key lives in Keychain under meshy-api-key. The balance call (3,105 credits) was the first live call made against Meshy in two days of active development. First, because there was nothing to test it against until the pipeline existed.
The wrapper handles the generation request, polls for completion, and retrieves the mesh. The real Cj avatar came back carrying the bone names the proxy had been holding for two days. It slotted in. No structural changes to any downstream system.
One planned step was cut: the Mixamo retargeting. The mixamorig: convention the proxy had enforced from day one meant the real mesh was already Mixamo-compatible at the rig stage. There was nothing to retarget. Mixamo was never opened.
The accounting
Credit accounting is blunt. A mesh generated against an unproven pipeline costs the same number of credits as a mesh generated against a working one. The difference is entirely in what you discover afterwards.
The proxy approach moves discovery forward. Any rig incompatibility (bone count, naming, weight painting, shape-key binding) surfaces on a capsule person, at zero cost, before the generation request is ever sent. By the time the real mesh existed, the pipeline had been in continuous operation for 24 hours. There was no category of failure that hadn’t already been exercised.
The proxy also prevents a more expensive failure mode: the half-working mesh. Without a proven pipeline, it’s possible to spend credits on a mesh that’s visually close enough to accept, integrate it, and discover rigging problems only when the animation system tries to use it. That failure is the worst kind: it looks like success until it doesn’t, and fixing it requires regeneration. The proxy makes that failure happen cheaply and early, or not at all.
The trade-off
One day of proxy work before any visible avatar progress. On a progress chart, that day looks like nothing.
It isn’t. It’s the day that made September 3rd a clean integration rather than a multi-day debugging session.
The proxy has an ongoing maintenance cost. If the bone convention changes, proxy_rig.py needs to track it and the real mesh needs regeneration or retargeting. That’s the right place for the cost to live: at the convention layer, explicitly, rather than discovered late in integration.
Out of scope for this sprint: automating mesh regeneration when the convention changes. Current state is manual: update the script, regenerate the proxy, verify, then decide on the real mesh. One manual step. Acceptable at this stage.
Where it stands
Three days from a blank repo: a working studio environment, a music-reactive stage, a proven rig pipeline, and a real Meshy-generated avatar in the scene. The Meshy credit balance dropped once, from a known starting point, into a working system. Mixamo was never involved.
The proxy is still in the project, not archived. It’s the fastest way to test rig changes before they touch the real mesh. The build log is at docs/devlog.md.
