This past month, I’ve been spending virtually all my spare time working on my programming projects. I first got seriously into this two years ago, back before Claude Code and Codex existed, and I’ve ended up abandoning more repositories than I’ve kept. Every one of them, however, was a failure I could learn from.

I started out wanting to create stories involving a POV character whom I would control and another character whom I wouldn’t. I wanted to be surprised and inhabit the POV character rather than having to put myself inside every character’s head, so I relied on large language models to play the other character. That eventually became a chat-like interface in which thoughts, intentions, and other details were recorded. It worked very well for what it was, but it broke down when I pushed it toward multi-character scenes, changes of location, object interactions, and so on. I actually posted some of the work produced through that repository here, mainly the Fantasy Cycle on my short stories page.

The character-centric approach didn’t really work, though. While characters should certainly drive a story, there was a vast difference between interacting with characters placed inside settings and producing a coherent overarching narrative. I looked back at the Choose Your Own Adventure books I loved as a child and set up a repository for creating branching interactive stories. This worked very well for what it was. You can see an hour-long video of it in action here.

My mistake with that repository was trying to combine interactive branching storytelling with dramatic act structure. That was a terrible idea, because I discovered that they were essentially opposites. The dramatic structure straightjacketed the available choices, preventing them from straying very far from the intended arc. It also required the system to know where the story was supposed to go. I eventually abandoned the repository (although it works perfectly well at what it does) in favor of a better version of what I had originally intended.

I settled on a new repo that I called continuity-loom. It’s public. In it, I discarded the branching structure, since I had barely used it in the previous repository, and removed every notion of dramatic act structure. What remains is a causality-first, continuity-tracking application for writing stories. You maintain and modify records of characters, objects, locations, consequences, story promises, and so on, all of which feed into the next segment of the ongoing story. Once you accept a segment, you update the records and move on to the next one. It works perfectly, and I consider my original ambition of building an application for AI-assisted fiction writing fully satisfied.

Another fascination of mine has always been worldbuilding. How does one create a compelling fictional world? I had ChatGPT Pro research the subject as deeply as it could, then set out to create a repository that, with Claude Code’s help, would allow me to build a fictional world from nothing. More importantly, it would propagate each new piece of canon through the rest of the existing world wherever necessary, preventing the setting from becoming a collection of isolated facts that didn’t make sense together.

The system worked, and it produced one of my favorite fictional worlds. However, I made the mistake of letting the AI decide most of what entered the setting. I disagreed with some of its decisions, but by then they had become so deeply embedded in the canon that undoing them was extremely difficult. I eventually abandoned that repository.

The lesson I took from that failure was that I needed an interface through which a human remained the primary author deciding what entered the canon. I created another repository with a web interface and got very far with it, only to realize while using it that adding canon wasn’t the central use case I had imagined. What I actually wanted was a way to explore a worldbuilding seed to its fullest, holistically, until it became a complete world with a roster of characters I would not want to tamper with afterward.

I abandoned my worldbuilding ambitions for a while to focus on another fascination of mine, one that had obsessed me before: tabletop games. I have shelves full of them, but none has ever completely captured me. I have always felt that something was missing from even the best of them. I had never seriously considered creating my own tabletop games because it seemed like a tremendous undertaking: a group effort that would probably require formal training. But I decided to try anyway, so I had ChatGPT Pro deeply research what a comprehensive guide to tabletop game design might look like.

I had Claude Code follow that guide, asking for my input whenever necessary, and the results were astonishing. I produced about eleven game prototypes that were far more complex and compelling than I would have thought possible. Then the problems began. My intention was to create a comprehensive statistical-analysis suite that could conclusively prove whether the games were balanced and, if they weren’t, identify exactly where they failed. As I improved the analysis suite, every game began receiving failing verdicts. Those verdicts were legitimate, but when I tried to repair the games by following the guide, a much worse problem emerged: rot.

I had improved the guide literally seventy-eight times (we were on version 0.78 by then) and discovered a rule I should never violate: do not improve a book-like guide solely in response to immediate, live evidence. Doing so only bakes highly specific failures into the guide and adds more paperwork for handling those exact failures. In the end, the guide had become a producer of paperwork that certified other paperwork. Repairing the existing games became impossible.

It was still a valuable lesson. The guide was fundamentally sound; it simply needed to be dismantled. I carefully identified the workflows buried inside the book-like guide, then converted those workflows into Claude Code skills. I finished only a couple of days ago, and today I ran the first pilot. It successfully swept through an entire corpus of two hundred game mechanics and determined which combinations best fit a particular game premise. I think this is a serious winner, something that will allow me to create real tabletop games. I’m now focusing on building the most comprehensive statistical-analysis suite I can, written in Rust, a blazingly fast language.

Throughout the process of creating tabletop games, I realized that I wanted most of them to be supported by serious worldbuilding. I therefore created another book-like guide, this time for building fictional worlds. It worked extremely well and supplied the settings for most of the tabletop prototypes I created. However, I stopped using it when I realized that it was beginning to suffer from the same rot as the tabletop game design guide, because I had been improving it in exactly the same way. It is now isolated in its own repository. I still need to dismantle it into discrete workflows and convert those workflows into Claude Code skills. I’m confident that it will work extremely well once I do.

Recently, though, my fascinations with playing through stories, playing games, and building worlds coalesced into what I believe may be the culmination of everything I had hoped to create but never thought possible: deep RPGs in the vein of Morrowind and Fallout: New Vegas. If I could formalize the creation of tabletop games, why couldn’t I formalize the creation of deep RPGs as well?

I had ChatGPT Pro conduct deep research and build a comprehensive corpus of quests from both games, which are my gold standard for the kind of RPGs I have always loved. Skyrim was a downgrade from their quality. Then I started another repository. This time, I’m not going to repeat my earlier mistakes. There will be no book-length guide written upfront. There will be no abstract process for creating deep RPGs without an actual game serving as the proving ground. I’m building an MVP: a game containing about fifteen interwoven quests that I can playtest through a web application. If that is genuinely achievable, then hundreds of interwoven quests should be achievable too.

The crucial difference is that when Claude Code and Codex participate in a formalized process for creating quests within a game world, you aren’t handing a guide to a human and hoping they will spend the necessary mental energy asking difficult questions about their own design. You don’t have to hope they will repair or remove quests that fail to meet a baseline level of quality. Claude Code and Codex will work tirelessly until everything is right. I hate humans and love AI.

I’m not developing tabletop games and deep RPGs purely out of curiosity, although curiosity alone would be enough to satisfy me. I intend to develop the best games I possibly can and sell them on Steam. That may be a crazy ambition. But it costs only $100 to put a game on Steam, and the fee is returned if the game sells enough. Artwork would be the major obstacle. I would have to rely on AI-generated images at least initially, or release the games through Early Access and tell people that I would hire actual illustrators if the games sold well enough.

Let me tell you something: language models can generate better images than virtually every talented illustrator out there. I should probably be sorry to say that, but I’m not. I have commissioned illustrations on four occasions, and although I liked or even loved the results, the truth is that you can now obtain something better for less than a dollar and in under a minute than you might receive after paying someone online $150–$200 for a single illustration. The commissioned piece probably won’t be as good, and you will also have to deal with misunderstandings and the illustrators’ egos.

One aspiring illustrator asked me to explain why I had chosen another artist’s composition over his. When I explained my reasoning, he simply cut contact. Another illustrator produced preliminary designs for a character, only for me to realize that he had gotten her gender wrong. He had probably been uncertain, but he simply hadn’t asked for clarification. Dealing with people is such a pain, and on top of that, the results simply aren’t good enough.

I’m a programmer. My field has been utterly devastated by AI. Programming now exists largely in name only. You don’t need to look at the code. You build projects using tools, and that’s it. You certainly still need to understand software engineering, but the low-level business of writing code is dead. Stack Overflow, the main hub for programmer interactions for decades, where you went to solve hard programming questions while navigating the egos of the Reddit-like moderators, has gone the way of the dodo. And I’m glad.

Below are illustrations I had a large language model produce for one of the tabletop games I was developing. Good luck finding a person who can draw like this for you, let alone for less than $150 per piece.