Claude Code can write your game.
Now it can make the rest of it, to your bar.
A generator makes a guess and leaves the checking to you. With polyweave, every part starts as a short file saying what correct means. Claude Code drives Blender, Godot and AI generators to make it, measures each result against that file and tunes until it passes. Only then do the best candidates reach the page where you approve what ships.
Other tools make a guess. polyweave makes it pass.
There is no shortage of tools that make game content. What they share is the step they leave to you: deciding whether the result is right. polyweave drives them rather than replacing them, and takes that step off your plate up to the point where only taste can answer.
| Kind of tool | What it gives you | What it leaves to you |
|---|---|---|
| AI generators for 3D, images, sound and voice | A part from a prompt, in seconds. | Checking it against your drawing and your style, and the cleanup when it misses. |
| Blender and Godot bridges for agents | An agent that can work the tool. | Knowing when to stop. Nothing says what correct is, so the agent guesses or asks you. |
| Prompt-to-game builders | A playable prototype from a sentence. | Holding each part to a bar of your own, in your own engine and repository. |
| Procedural suites with parameter sweeps | Many variants of one node graph. | A person at a screen to run them, and every layer that is not geometry. |
 polyweave | A file per part saying what correct means, every result measured against it, a search that tunes until it passes, and one record of how each part was made. | Only the verdict no measure can give: whether it looks, sounds and plays right. |
Correct is written down
Each part has a short file of checks with bounds: silhouette, colour, loudness, difficulty. A search aims at it instead of a person eyeballing renders.
One loop for every layer
Models, images, sound, words and levels share one config, one record and one review page, so a game's parts are judged together, not tool by tool.
The agent cannot pass itself
Claude Code measures and tunes, but it cannot approve its own work or spend money on its own judgement. The verdict and the budget stay yours.
Everything Claude Code gains with polyweave.
On its own, Claude Code writes code and reads text. It cannot see a render, hear a sound or play a level, and it has no way to know when a part is good enough. polyweave gives it all of that through one MCP server, installed with the plugin.
Hands on every tool
Drives Blender, Godot and the 3D, image, sound and voice generators through one set of calls, each tool in its own language.
Eyes
Every render comes back with its numbers: silhouette, colour, contrast, and how it reads at the size a player sees it.
Ears
Loudness, clipping, loop seams and spoken takes are measured, so a sound is checked before a person hears it.
A bar to aim at
Each part has a short file saying what correct means. A search tunes the settings until every check passes.
Hands on the game
Opens your game, presses buttons, waits for a state, takes screenshots and replays a run, all without a screen.
Your verdict, on tap
Sends the candidates to your review page and waits for your answer, so it never has to guess your taste.
Errors that carry the fix
Every failure has a stable code and the exact call that resolves it. No traceback to decode, no second round trip.
Memory across sessions
Long jobs return a handle, and jobs, traces and records are files in the repo, so the next session picks up where this one stopped.
Tools that explain themselves
Each operation lists its parameters, ranges and defaults, and the plugin says which tools this machine has.
A budget it can work inside
You set a spending ceiling once. Claude Code works freely under it and can never raise it.
The history of every file
Which model, prompt, seed, cost and licence made each part. Credits and licence checks are written from it.
Game parts already proven
Menus, settings, saves, controls, co-op and accessibility arrive as kits, installed and tested in your project.
From a request to a part you approved, in four steps.
Ask
Tell Claude Code what you need, in plain words: “a mascot like this sketch”, “a coin sound in C”, “make level 3 a bit harder”. Claude Code writes it down as the bar: a short file saying what correct means.
Make
polyweave picks up the right tool and drives it: Blender, Godot, a 3D or image generator, a synth or a voice.
Check
Every result is measured against the bar you set. A miss is tuned and tried again before you ever see it.
Approve
The best candidates land on your review page. Approve, reject, or ask for a change, and Claude Code takes it from there.
One plugin for every part of a game.
Each layer works the same way: say what the part should be, let it be made and checked, approve the result. All of them share one project config, one record and one review page.
3D models
Built in Blender from a declaration, or bought from a generator and fitted to your drawing.
Images
Concept art, icons, sprite sheets and store capsules, held to your style.
Music
Loops that close without a seam, rendered from MIDI and heard mixed.
Sound
Effects synthesised or bought, put in a key, checked for loudness and clicks.
Effects
Particles, glows and hits declared as data and previewed before they ship.
Game kits
Menus, saves, settings, controls, co-op and accessibility, installed already tested.
Voices
Lines read in each character's own voice, priced before anything is spent.
Words
Names, dialogue and string tables checked against your world and your fonts.
Levels
Declared as data, built into the engine, measured for difficulty before anyone plays.
Animation
Skeletons and clips kept as text, so a timing change is one edit you can diff.
Real games, made with it.
Viglet Games makes its games with polyweave. Both are in development for Steam.
What Claude Code actually does.
Six calls: search the bar Claude Code wrote from a sketch, follow the handle, take the final render, check it, and get a failure that says how to fix it.
# Claude Code wrote the bar from the drawing: assets/mascot.accept.toml, # 3 predicates and the 2 parameters a search may move. No number set by hand. > polyweave search.sweep --spec assets/mascot.accept.toml --out .polyweave/samples/mascot --job job j_7f3a stage=queued > polyweave job poll j_7f3a job j_7f3a stage=rendering rung=preview 17/24 elapsed_s=212 > polyweave job result j_7f3a --wait done score 0.94 light=2.8 form=1.9 sheet .polyweave/sheets/mascot-7f3a.png (5 candidates) trace .polyweave/traces/mascot-7f3a.json (24 samples, 9 cached) > polyweave render.bake --spec assets/mascot.accept.toml --rung final --out assets/mascot.png done 1024x1024 rung=final > polyweave accept.check --spec assets/mascot.accept.toml --subject assets/mascot.png --rung final accept: 3/3 predicates pass saturation_p99=0.87 delta_e=1.4 silhouette_iou=0.981 > polyweave render.bake --model assets/shelf.glb --rung final --out assets/shelf.png post.render-uniform: every visible pixel of the render is #3a3a3a, so it carries no image do: the scene was empty or the light never fired; if a flat #3a3a3a is what was wanted, pass allow_uniform=True
Each command is a real operation, the same one Claude Code calls as an MCP tool; docs/specs/tool-surface.md says how every call behaves. The values are illustrative.
Many models. One bar for all of them.
Claude Code talks to polyweave, and polyweave talks to each tool in its own language. Pick the models you like; the bar each part must pass stays the same when you switch.
Chosen in one config
Models, budgets and paths live in polyweave.toml, in your repo. Switching is a config change, not a rewrite.
Checked before you pay
A request is checked against your drawing before a credit moves, and every price is quoted before it is spent.
Kept, with its receipt
What a service made is copied into your project with its prompt, seed, cost and licence, so nothing expires out from under you.
You judge the result. Never the file.
Only a person can say a look is right, a line sounds true or a level feels fair. polyweave makes that the quick part.
- Every candidate side by side, with the checks behind it, so you compare instead of opening files.
- Ask for a change in your own words. Claude Code makes it, runs the checks again, and comes back to you.
- A desktop window for every project on your machine: each item with its bar, its history and its next step.
- Sounds heard mixed, words seen in place. You judge a part the way the player will meet it.
- Claude Code cannot approve its own work. The verdict is always yours.
Your project. Your money. Your call.
Runs on your machine
No account and no hosted service. polyweave works on files in your own repository.
You set the budget
A ceiling you agree once. Every spend is bounded, quoted and written in a ledger.
You approve every look
An agent can measure a part. Only you can accept it.
Everything is a file
Specs, records and jobs live in your repo, so a colleague can review and repeat any of it.
What polyweave will never be.
These constraints bind the project, and every new idea is read against them first.
✗ A graphical editor
The caller here is an agent in a terminal, so a surface only a person can operate is one the agent cannot use. A local page where a person looks and answers is not an editor: it edits nothing, and its one write is the verdict call an agent would make.
✗ Replacing Blender, Godot or the generative service
Those three already do the work; what is missing is the loop around them, so this orchestrates and measures and never re-implements a renderer, an engine or a mesh generator.
✗ Spending money on the agent's own judgement
A fetch draws on a real balance, so the ceiling is a person's to set and the plugin's job is to make a spend bounded and visible, never to decide one is worth it.
✗ One project's palette, rig or paths compiled in
Cottony is the first consumer and not the specification, so anything it needs that a second project would not is configuration, and a default that cannot be overridden is a defect.
✗ A hosted service or an account to sign into
Everything runs on the developer's machine against files in their own repository, because a plugin that needs an account is one that fails on the day the account does.
✗ An agent accepting or rejecting its own look
A look, a sound, a line a character says and how hard a level feels are each what a person agreed to, so an agent that can write the verdict on its own run turns the one check the loop cannot automate into one more number it tunes.
✗ One genre's level format built in
A match-3 level is three numbers and a shooter's is a spawn timeline, so polyweave checks, compiles and measures a level through what the project declares, and a schema that assumes a genre fails the next game; PW205 exists to catch that.
✗ Writing a game's story for it
A world is a person's authorship, so polyweave holds what the game shows to the world a person declared and routes a line's tone to their verdict, and never invents the canon it then checks against.