A coding agent can write a lot of a game today: the player controller, the menu logic, the save system. Then you need a mascot, a coin sound, a background loop and a third level, and the agent can't help anymore. It can't see a render, hear a sound or play a level, and it has no idea when any of those is good enough.
AI generators don't fix that. You type a prompt and get a 3D model, a picture or a voice line in seconds, and then the real work starts. Does it match your sketch? Is it the right orange? Does the loop click at the seam? Does it look like it belongs in the same game as the other forty assets? The generator made a guess, and you're the one who has to check it.
polyweave is a free, open-source plugin for Claude Code that takes on that checking.
Where it came from
polyweave started inside a real game. Cottony is a plush-themed match-3, with hearts, drops and stars made of felt that squash when they land. Its tiles are rendered in Blender, and getting them to look right meant tuning fourteen render settings by hand: change one number, wait about two minutes for a render, look at it, decide, repeat.
Making the model was quick. Most of the time went into the stretch between having a model and knowing it's right. That stretch is what polyweave is for.
The idea: write down what "correct" means
With polyweave, every part of your game starts as a short file that says what correct means for it. You don't write that file yourself. You describe what you want in plain words, and Claude Code writes it down as a list of checks with limits:
- the silhouette has to match my sketch
- the face has to be this cream colour, within a small tolerance
- the sound has to be in C, not too loud, and loop without a click
- this level has to be a little harder than the last one
Once that bar exists, the work no longer depends on someone squinting at renders. Claude Code can make a candidate, measure it against the bar, adjust the settings and try again, and the misses get thrown out before they ever reach you.
How it works, in four steps
- Ask. Tell Claude Code what you need: "a mascot like this sketch", "a coin sound in C", "make level 3 a bit harder".
- Make. polyweave drives the right tool for the job, whether that's Blender, Godot, a 3D or picture generator, a synth or a voice service.
- Check. Each result is measured against the bar. A miss gets tuned and tried again.
- Approve. The best candidates show up side by side on a review page, each with its checks next to it. You approve, reject, or ask for a change in your own words ("make the ears rounder"), and Claude Code goes back to work.
What it makes
The same loop covers every layer of a game:
- 3D models, built in Blender or bought from a generator and fitted to your drawing
- Images: concept art, icons, sprite sheets, store capsules
- Music loops that close without a seam
- Sound effects, synthesised or bought, checked for loudness and clicks
- Visual effects like particles, glows and hits
- Voices, read in each character's own voice
- Words: names, dialogue and text, checked against your world and your fonts
- Levels, measured for difficulty before anyone plays them
- Animation, kept as text so a timing change is one edit you can diff
- Game kits: menus, settings, saves, controls and accessibility, installed already tested
Every layer shares one config file, one record of how each part was made and one review page, so you judge the game's parts together instead of one tool at a time.
It works with the tools you already have
polyweave doesn't replace Blender, Godot or your favourite generator. It sits in the middle and talks to each one in its own language:
| Layer | Tools it drives |
|---|---|
| 3D | Blender, Meshy |
| Pictures | FLUX, Ideogram |
| Sound and music | sfxr, MIDI |
| Voice | ElevenLabs |
| Game engine | Godot |
Here's what that looks like for a mascot drawn from your sketch:
- Before anything is bought, polyweave checks the request against your drawing, so a credit isn't spent on a request that plainly won't match.
- Meshy generates the model. polyweave keeps a copy in your project along with the prompt, seed, cost and licence, so nothing expires on the service's side.
- Blender renders it, and polyweave measures the render against your sketch: does the silhouette line up, and is the colour right where it should be?
- Claude Code adjusts the render settings until every check passes, and only then do the best candidates reach your review page.
- Godot opens the game and takes a screenshot, so you see the mascot where the player will actually meet it.
There are plenty of tools that connect an agent to Blender or Godot. What they don't tell the agent is when to stop. In polyweave that's the job of the bar, so the agent works on the tools until the result is right, not just until it's done.
Which tool you use is a line in a config file in your repo. Swap models whenever you like and the bar each part has to pass stays the same.
You stay in charge
Handing an agent a credit card and your art direction is a fair thing to be nervous about. polyweave has three rules about that, and the agent can't get around any of them:
- The agent can't approve its own work. It can measure a part, but only you can accept it. Whether something looks right, sounds right or feels fair is your call.
- The agent can't spend money on its own judgement. You set a spending ceiling once. Every paid request is quoted first and written to a ledger, and a request that clearly won't match your reference is refused before any credit is spent. Claude Code works freely under the ceiling and can never raise it.
- Everything stays on your machine. There's no account and no hosted service. Specs, jobs and records are plain files in your repository, so a teammate can review or repeat anything.
Each file also keeps its history: which model, prompt, seed, cost and licence produced it. Writing your credits screen and checking licences become a lookup.
Real games are being made with it
Viglet Games is making its games with polyweave, and both are in development for Steam:
- Cottony, the plush match-3 where it all started
- Spinhold, a neon ring shooter where you fly around the outside of a spinning colony
Try it
You need Claude Code and Python 3.11 or newer. Blender and Godot are optional: polyweave tells you which tools it found and what each missing one would unlock.
pip install git+https://github.com/alegauss/polyweave
/plugin marketplace add alegauss/polyweave
/plugin install polyweave@polyweave
Then ask:
Set up polyweave in this project, and make me a mascot from docs/sketch.png.
- Website: alegauss.github.io/polyweave
- Code: github.com/alegauss/polyweave
If you're making a game with an agent, I'd like to hear which part of it is still eating your time. Leave a comment.
Top comments (2)
The explicit acceptance bar is the important piece: it turns “looks right” into checks the agent can fail before a human review. For subjective assets, retaining the rendered comparison, tool version, prompt/seed, and the failed checks beside the approved candidate would make later art-direction changes reproducible rather than starting the tuning loop from scratch.
Thanks! Yeah, that's the whole idea: the agent should fail on its own before I ever have to look.
Most of that is already kept. Every file gets a small record next to it with the versions, seed, prompt and parameters, plus the scores against the bar it passed. Each search also keeps everything it tried, failures included, and a side-by-side of the best few.
The bit I haven't nailed yet is what you describe at the end: when the art direction changes, starting the next round from the approved version instead of from zero. Good push, I'll look into it.