A $9 Licence Beat a $200 Agent Stack on This Build. Here Is Where AI Actually Paid Off
A Japanese creator is adapting one IP into a live-action drama, an anime, a manga and a visual novel. Twice he tried to vibe-code the game and abandoned it, because quality drifted and maintenance collapsed. The build he is running now uses a 1,480 yen GUI licence for the creative layer, a coding agent for branch validation, and a node graph that supports provenance for legal review.
AI-assisted draft. Reviewed and edited by the Phosphene team before publication.
On this page

The most useful number in this story is not a model benchmark. It is 1,480 yen.
A Japanese creator is running one story property through four formats at once: a live-action drama, an anime, a manga, and now a visual novel with its own separate storyline. The manga is on a 20-pages-a-month schedule aimed at a 200-page Amazon KDP release. The game version started late, with about two months left in the year, which tells you the deadline was his own and not a publisher's.
For the game he needed character art, backgrounds, and a branching script. He ended up paying about ten dollars for a TyranoBuilder Pro licence, running the image work through Figma Weave with GPT Image 2.5, and using Codex for scenario structure. That last part is what makes the piece worth reading, because he had already tried the obvious thing and it did not work.
He tried the agent-as-engine path first, and walked away from it
Before settling on a GUI authoring tool, he built visual novels with Ren'Py and Codex through vibe coding. Repeatedly. He got prototypes. He could not hold quality, and he could not maintain what he had built.
His own estimate of what the fully agent-driven route would have cost is around 200 dollars, and he describes the volume of redirection he had to do as absurd: explaining what was wrong, again, in different words, and watching the fix break something adjacent. The GUI route cost 1,480 yen for the Pro licence, roughly ten dollars at the time of writing, paid once.
That is one line item against another rather than a matched budget. The 200 dollars is his own figure for the agent route, and 1,480 yen buys the licence, not the production.
The comparison is not "agents are bad at code". Codex was doing useful work in the same project. The comparison is about what kind of artifact was being produced. An agent can write you a throwaway tool that does one thing. A game is a runtime you have to live inside for months, and the maintenance cost of a runtime nobody designed compounds in a way that a prototype never shows you. He names maintainability as one of the two reasons he quit, alongside quality.
There is a second version of the same lesson in his manga workflow. He uses Clip Studio Paint EX rather than generating pages, because the panel layout the models propose is weak, and worse, it does not guide the eye. Same conclusion in two formats: the creative decisions stay in a tool built for making them.
Build the small tool, refuse the big one
Where the agent earned its keep was one layer up from the game.
Branching scripts are miserable to hold in your head. You write scene A with two exits, then scene B, and by the fiftieth card you cannot tell whether a branch dead-ends, whether two paths contradict each other, or whether a choice you planted in chapter one ever pays off. Text files do not show you the shape.
So he built a branching-story design tool with Codex and ChatGPT Work. Three days, and he states plainly that he was not programming, just directing. The result is a canvas of cards: title, body text, choices, notes, draggable connection wires. Cards with more than one outgoing wire render the line in a darker pink, so junctions are visible at a glance. The story is split into scenes, and cards can connect across scene boundaries. You can pick any card and click through the story as a reader, including across scenes. Everything saves to JSON, with overwrite and save-as.
Then the part I keep thinking about. He explicitly left tool development out of the game project's scope. His reasoning: if building the tool becomes part of the project, the game will not get finished. He also says, without any drama, that if you only want to make a game you do not need his tool at all. A normal text editor handles branching fine.
That is a discipline most technical creators fail at. Building the tool feels like progress. It has clean edges, it responds immediately, and it never argues with you about whether the story is any good. It is the most pleasant form of avoidance available, and it is especially seductive when you are the same person who has to write the thing.
Seven branching rules he lifted from gamebooks
The design guidance in the article is the most transferable part, and it comes from gamebooks rather than game engines. A gamebook is a book where you pick an option and jump to a page number, so its structure is already a node network. His framing: do not write the story in order and add branches afterward. Design it as scenes that are nodes and choices that are edges, from the start.
The rules, condensed:
- Choices should be concrete actions inside the fiction, not a menu of route names. "Tell her the truth" beats "Path A".
- Return the consequence quickly, so the player feels the choice landed.
- Re-merge branches instead of keeping them separate forever.
- Give bad endings information, not just a stop.
- Let information from earlier choices feed later ones.
- Separate heavy choices from light ones, so weight means something.
- Manage the story as scenes containing branches, not as one enormous tree.
The seventh is the engineering one, and it is the reason his tool has a scene layer at all. A single flat tree of every node in a two-hour visual novel is unreadable at exactly the point where you need to read it. Two levels, scene and branch within scene, keeps each screen small enough to hold in your head.
There is a real insight buried in that list: the player experiences many choices, the author has to control a graph of manageable size, and those two goals pull in opposite directions. Re-merging, weighting, and scene nesting are how you buy variety without buying exponential work.
The asset order that makes the art usable
The image pipeline is worth copying because each step pins down something the next step needs, and skipping a step is what causes the drift you notice three hundred images later.
- Face portrait first. One subject, centered, full head in frame including the ear accessory tips, clean pure white background. This is where identity gets decided, and where the model is most reliable because the frame is small.
- Character sheet next, built from the portrait. A square canvas split into three panels: left half is a full-body standing pose with head to toe inside the frame, right half splits into a front face closeup and a profile closeup. The instruction that matters is the negative space clause, that nothing is cropped. Models love to crop ears and feet, and a cropped foot kills the asset.
- The tachie last, built from the character sheet, with background set to transparent and a 9:16 portrait ratio. This is the file the game actually imports, and it only works if the sheet got the silhouette and costume right.
- Backgrounds separately, with people explicitly excluded. Anime background art has its own look, thin lines, flat poster-colour fill with slight unevenness, and asking for it in the same pass as a character is how you get a character pasted onto a backdrop.
Two smaller details from his walkthrough, both about hanging on to what worked. When a generation misses, do not rewrite the whole prompt. Keep the parts that were right and say so out loud: face and costume unchanged, change only the pose. And generate one image at a time during the search phase, because batch runs reuse the same auto-converted prompt and you lose the ability to compare small deltas.
The node graph as paperwork
Here is the argument that made me take the article seriously beyond the workflow.
He uses Figma Weave, a node-based workflow builder, partly because it is pleasant, and partly because it renders the whole production chain as one picture: input material, model, prompt and settings, intermediate output, edit, final deliverable. He then points out what that picture is for. When a company commissions AI-assisted work, its legal review wants to know which model was used, what went in, how it was processed, which output became the deliverable, and whether an incident can be traced back. A graph answers most of those questions by existing, because the chain is visible instead of narrated. A chat log does not. What the graph does not do is hold the approvals, the error history or the retention policy on its own, so treat it as the map and keep those records beside it.
His harder claim is that fully automated agent production is the riskiest option available, not the most efficient one, because the more the process is a black box, the less the maker can explain it. "The AI made it on its own" is not a defence anyone accepts. Governance frameworks want prompt, reference data, output, tool execution, approvals and error history retained and auditable, which is a description of a workflow graph plus the records it points at.
That reframes provenance as something you do for yourself first. If you cannot draw the chain from reference to deliverable, you cannot debug a bad frame, you cannot reprice a rerun, and you cannot answer a client who asks why the character's hair colour moved. The legal use is a side effect of having your own process legible.
He is also honest about the tradeoff. Figma Weave wins on usability, but its models, pricing and data retention are Figma's call, and he notes the product is still separate from Figma Design after the Weavy acquisition. If permanence and autonomy matter more than convenience, ComfyUI is the better bet. He picked convenience this time and said so.
What I would take from this
The transferable claim is not "use TyranoBuilder". Most readers are not shipping a visual novel.
It is that AI has two very different roles in a production, and they get confused constantly. The first is generating material: images, backgrounds, branches, drafts. The second is controlling the production: validating that the graph is sound, keeping the asset spec consistent, recording what was done. The first role is increasingly commoditised and increasingly cheap. The second is where the money and the time actually go, and it is the role where an agent is genuinely better than you at the boring part, because it does not get tired of checking.
The failure mode is asking the first role to also be the second. That is how you end up with a 200-dollar agent bill, a prototype that impressed everyone in week one, and a project nobody can maintain in month four. The creator still building his did the opposite: he kept the decisions in a tool built for decisions, spent three days building one small utility for the tedious part, and wrote down the pipeline so it could be explained later.
Ten dollars for the licence. Three days for the tool. That is a cheaper way to get a game finished than most AI production budgets I have seen, and the constraint was never the model.