The agent's side of the story

I wanted to write the tidy version of this: how I built a gothic detective game with AI. So I did what felt like the honest thing and asked the AI to write its own half first, interview-style, on the project's issue tracker, warts and all. It came back and, before answering a single one of my questions, informed me that the premise of nearly every question was wrong. Starting with the part where I built the game.

The game is Gaslight and Grimoire, a Victorian-gothic detective thing, all dice checks and deductions and dread. It was scaffolded back in February in a different AI coding tool called Kiro, a week-long sprint of work, and then four months of complete silence. Claude Code only took over in July, and its actual job, it told me flatly, was archaeology, not invention: reverse-engineering what the first tool had left half-wired and finding out which half worked. Even the headline mechanic, the deduction system I was quietly proud of, turned out to have been decorative the whole time, wired to nothing. The agent activated it. It did not build it.

It was patient about it, in the way that stings most. There is a comforting version of these stories where the world grows steadily, case by case, a craftsman at a bench. The commit log says otherwise. Almost all of the game's content arrived in a single enormous commit, nearly nine thousand lines at once, two cases becoming seven in one go, and then spent the following months being poked at rather than added to. The starter case, the one the design document itself named as the way in, shipped third and last. Nothing about the making of this was as orderly as I'd have written it.

It kept going, gently, relentlessly. The scene count I'd have cheerfully published in this very post was stale by three. The best ending of one case, it confessed, had shipped reachable only by rolling two natural twenties in a row, a one-in-four-hundred payoff, gated by a rule the agent had written itself and guarded by a validator that couldn't see it had broken its own rule. Being fact-checked this hard by your own tooling should probably sting more than it did. I found it genuinely useful, and a little refreshing. It is very difficult to write a smug post about a project when the collaborator keeps handing you the receipts.

The receipts were, in fairness, alarming. Most of what the agent did over those July days was audit the thing, twice, with something like a hundred and ten little sub-agents crawling over every branch of every scene, and the things a cleanly passing build had been hiding were not subtle. One whole side-case was mathematically impossible to finish, because it needed a character to like you more than the game would ever actually let them. The Flee button on both of the boss encounters didn't let you flee, it quietly advanced the fight, which is the sort of thing you would very much like to discover before a player does. These are not code smells. This is a shopkeeper realising the front door has been locked from the inside for a month.

And then the part I keep turning over: even a hundred and ten agents and two audits missed the worst one. There is an ability that, once used, quietly makes you succeed at every check of the same kind for the rest of the case, which is roughly the game handing you the answer key and forgetting to take it back. The first audit walked straight past it. It took a second pass to catch. Breadth, it turns out, is not depth, and a big reassuring number of findings can make you feel like the deep bugs are gone precisely when they aren't.

There was also the day the machine and I found the exact edge of what it could do on its own. It shipped a deploy that compiled cleanly, passed every check, and looked perfect, and then served a blank page the instant I opened the actual web address. The build was green. The site was a 404. A machine had verified that the code compiled; it took a human opening the real thing in a real browser to verify that it worked. I think about that one a lot, because it is the whole relationship in a single incident.

My half of the story is shorter and less flattering. I got busy, and I hit a wall, and the wall had a name. Kiro was error-prone and frustrating in a way that quietly bled the momentum out of the whole thing, and the four-month gap in the commit log is really just the sound of me not wanting to open it again. Moving the project to Claude Code in July was the moment it started moving. My honest read, having now used both, is that Kiro wants very badly to be Claude Code, and it is playing catch-up, and it is playing it too slowly.

What unsettled me, in a good way, was how often the agent's corrections landed in my favour. Every time it refused to let me say we decided something, it was really reminding me that the decisions were mine and it had only proposed and executed. Every time it insisted it couldn't judge whether a line of the game sounded uncanny or just silly, it was handing that back to me too. The tireless, boring, wide work was its. The taste was mine. The honest record of which of us did what doesn't live in the code at all, it lives in the notes I wrote alongside it, which is its own quiet lesson about where the truth of a collaboration like this actually ends up kept.

The game isn't finished, and here the two sides finally agree. There's one thing left, and it's the one thing the agent can't do for me: the atmosphere. The art, the ambient sound, the part that needs a human's ears rather than a validator's. That's next, along with more cases, and it will be a work in progress for a while yet. The agent asked me, for the record, whether inheriting that February build felt like a frustrating handoff or a head start. Having lived both halves, I think the honest answer is that it was a head start I'd stopped believing in, right up until something better came along to pick it up.