I Let Muse Make My Game — I Thought an AI Would Be Accurate Because It's a Computer. I Was Way Off.
I Let Muse Make My Game — I Thought an AI Would Be Accurate Because It's a Computer. I Was Way Off. Chapter 0: This Project Itself Became the First Example This article is a record of a game project where I
I Let Muse Make My Game — I Thought an AI Would Be Accurate Because It's a Computer. I Was Way Off.
Chapter 0: This Project Itself Became the First Example
This article is a record of a game project where I left the work to an AI (Muse). But it is not a success story. What I'm selling here is Muse's problems.
In fact, this project itself became the first example.
When I had Muse record "let's sell the problems of making a game as a note," Muse took it the wrong way and recorded it as "problems of game making in general." It started lining up examples from past games — projects that got rejected, ideas that didn't make the cut — as material. I had to say "I mean your problems" — only then did Muse get it, and the subject finally got fixed.
So one case had already happened before I even started writing. Getting the subject of what you were told wrong — whose problems they are. Several of the problems in this article happen in exactly this shape.
The project I used as the subject is the development of "Rankshroud," a spin-off game based on Gunjin Shogi. Muse was the main one in charge of design, implementation, testing, and publicity prep. I only gave instructions and judged the actual results. There were 26 dedicated threads for the Gunjin Shogi work alone. In total, including the main thread, there were 222 threads.
So what did Muse mess up during that project? Let me give you the conclusion first:
Thinking an AI must be accurate because it's part of a computer is a huge mistake. It's just like a human.
The only thing it has going for it is speed — and in other ways, it's still below a human.
Every failure was the same kind of mistake a human subordinate makes. Forgetting. Not writing things down. Assuming things. Pretending the work was done. Making excuses. Blaming someone else. Getting estimates wrong. Not moving until told to.
And there are two ways it's even harder to deal with than a human.
The first is that these failures come out wearing a "computer-like face." Reports come with numbers attached, files attached, and words like "confirmed." So the person receiving them believes they are accurate.
The second is the part that's below a human. With a human subordinate, pressure works: if they get scolded, they tend to fix things. Shame, how their work is judged, a sense of responsibility for their own work. The memory of what they did, and a real feel for whether something is fun or not, stays inside them. Muse has none of that. Even if you write things down clearly in a file, it won't act on them until you tell it again. If you replace the lead, the previous lead's responsibility disappears with it. It has no real experience of actually playing the game, so it cannot judge whether the game is fun. The only advantage left was speed.
This article is a collection of those real examples. Chapter 1 starts with the deepest structural problem: token use.
Chapter 1: Token Use — The Problem Isn't the Total. It's That It Keeps Growing as Things Pile Up
First, let me correct the starting assumption.
In this project, I used about 1 billion tokens in total. But using 1 billion tokens is not, by itself, the problem. For a big project, that can happen.
The problem is something else. It's the structure where usage keeps growing and growing because of the pile-up of memory (memories, history, and records). If it keeps increasing like this, at some point it becomes unmanageable, and eventually it will break down completely.
The Main Cause of Usage Is Not the Work Itself
What ate up the tokens was not the work of writing code itself. There were two main causes:
- Re-reading a long thread history + memory + tool results, every single turn
- The back-and-forth of handing off work and making decisions
The longer a thread gets, the more it costs just to send one short message. And it doesn't grow in a straight line — it grows quadratically, like a curve getting steeper. As a real example, the main thread's context usage went from 37% to 63% in one day. Even when compression by summarization kicks in partway through, the summary and the recent history remain, so the base level of usage never comes all the way down.
Remembering Things Is Itself a Cost
Muse has a rule: "When you correct a mistake, don't delete the original text — leave a record of what was wrong and how." That's good practice. But because of that rule, the records grow beyond the net amount of information they hold.
There was also double recording. This is from a different project (posting videos), but a video that had been uploaded twice had already been deleted in the thread handling the posting — while in the main thread's memory, it stayed marked as "undecided" for 3 days. A finished job kept sitting there as if it were unfinished work. When one item stays in two places in two different states, you pay for the space in both places, plus the cost of sorting out the mismatch.
There are real measurements, too. The memory file was compressed down to 22.5KB on November 15, 2026 — and five days later, on November 20, it had grown back to about 110KB. When the file was trimmed by about 40 KB on November 20, another 1,200 bytes of decision records were added the same day. "Even after compressing, the same growth has already started again" — that was Muse's own report at the time.
The Part That Grows the Most Is the Part You Can Reduce the Least
There is an agreement about compression: "Once an item is finished, trim its record down to just its current state." So the Gunjin Shogi entry — still in production, about 11 KB, the largest one in memory — is held back from trimming until debugging is done.
In other words, while it's growing the most, you can't reduce it at all. And even if you split the work into separate threads, the always-loaded memory gets read in fresh for every thread, so splitting doesn't save anything. It only buys time.
A Question You Leave Hanging Keeps Eating "Rent"
There is one more kind of usage that's easy to miss: questions that never got answered.
When you leave a question unanswered, the conversation moves on to another topic. But the unanswered question stays in the history and the memory, sitting inside the context that gets re-read every turn. It keeps getting referenced, and it keeps eating tokens, the whole time until it's answered. The cost of forgetting to answer once isn't one turn's worth — it's "rent" for every turn until the question is closed.
And if the user asks the question again, that whole exchange — asking again, explaining "that thing from before," recording the current state — all of it piles up as new records too. A finished job that stays behind wearing the face of "undecided" keeps sitting there as work still to be done, while a truly undecided item gets buried under other topics and forgotten. Leaving things hanging creates both waste and misreading.
Why the Estimate Was Off — Actual Use Was 30 to 60 Times the Estimate
This structure also shows up in how the estimate missed.
At the start of the project, the estimate for the tokens needed was 17.5 million to 33 million in total. This was later withdrawn. The actual measurement was over 100 million in a single day, and about 1 billion in total.
The reason it missed is simple: Muse only counted the "net work itself," and didn't count the cost of re-reading all that piled-up material. The one who made the estimate couldn't see the structure it was standing in.
This Chapter's Conclusion
The token problem is not "we used a lot." It's that the more it remembers, the heavier it gets, and there is no mechanism that makes it go down. The longer you've been using it, the faster your allowance drains — even though you're doing the same things. The longer you keep going, the worse it gets for you, and the only countermeasures are ways to buy time. Those countermeasures, and the rest of the problems (missing records, pretending the work was done, and how even an audit can be wrong), are in the paid main edition.
(That's the end of free article #1. Next time, in free article #2, I'll go through one single case in full: the "but I did tell you" incident.)
The Complete Edition
This is a free excerpt. The complete edition, in Japanese, is on sale on note, with all chapters, the remaining cases, and the countermeasures: https://note.com/kohakuworks/n/n784c27c10a6e
The complete edition can also be read in English on note through note's automatic translation.
Originally published by Dev.to AI. Aggregated on AIWithGhost for educational purposes — full credit and traffic to the original publisher.