In 2007-2009, when I was 17-ish, I created a browser game in PHP. If you are unfamiliar with the concept, this kind of game typically has a few hundred players in a world which typically runs for a few months or so, and you can trigger actions (e.g. build something) which then take e.g. 5 hours to complete and keep running even if you close the game. It’s similar to OGame or Travian if you know (and remember) those.
Being written in PHP 5, it went offline in like 2011 when that was no longer maintainable.
I was a bit sad to see it gone, I mean sure it won’t be played, but it would have been nice to have it online as an archive. I was thinking about spinning up an old Debian 4 VM to run it somehow, but never got around to doing that, also because it would have required a fair bit of fiddling.

Enter 2026, everything anyone is talking about in the vicinity of software development is LLMs. So let’s try if Claude Opus 5.5 can revive this game!
A new engine
So I wrote half a page of instructions, boiling down to keep everything looking as it was, but write a new backend engine in Go with no external dependencies except sqlite; do not keep the old code structure and database layout, but restructure in a way that makes more sense.
And, impressively, after an hour or so with no further input, the game is running again!

Impressive results
A little bit of tweaking was needed because all the building CSS coordinates were screwed up, but basically the tool one-shot this and the first result kind of worked. All else aside, it is very impressive that this is possible now. In the first version and all future iterations, I have seen 0 error messages, 0 data corruption/loss events, and 0 crashes.
The core gameplay mechanics worked from the start, like building things, ressource production, training troops, troop movement, the map, the leaderboard, and the message system.
The devil is in the details
Despite the first impression being “wow, it’s basically done” that was not true. There are several categories of problems we’ll have a look at now.
Made-up things
Despite an explicit instruction to keep user-visible texts the same, the LLM didn’t do that. It copied some text, but invented new text in a lot of places. Especially some pages were apparently considered too complicated and were simplified a lot with new text and layout.
In other places, new functionality was invented, like buttons doing things that were previously not there.
Functionality degradation
There were also a lot of bugs or small degradations which took a while to note. Overall, there were hundreds such issues. The repo now has 218 commits, all of which fix one or several such issues, most of which were found through manual testing. A small selection of such problems includes
- Various game-logic bugs, such as not requiring a Worker’s quarters to train Workers, moving of troops not working, starvation setting production to 0, hero abilities not having a level requirement, sea trade not requiring ships, bounties showing who set the bounty (this is supposed to be secret), server speed scaling food consumption (this doesn’t make sense since it will quadratically increase food consumption with speed), …
- A lot of convenience features were dropped, like the pop-up menu for coordinates. After requesting them to be re-added, they were often lacking details, such as the pop-up remembering the last selected action and placing the cursor over it.
- Various UI bugs, including funny things such as “archive” always archiving the newest report because it didn’t pass an ID to the AJAX request,
/newestopening the oldest report, switching villages staying on the same slot ID instead of the same building, Claude somehow thinking storing the currently selected village in the UI in the players table (instead of the session) was a good idea, … - Presentation degradation, such as, the original game had timers set up to make resource display tick up evenly in real-time and animations which made progress bars smooth. The LLM kept these features, but broke them, by e.g. using a single timer for all resource increase which caused weird uneven tick intervals; and using a 1-second timer to advance progress bars which is fine for very long times but looks bad for 39 seconds.

A special mention is deserved by the troop routing algorithm, which calculates which route troops can take to move between villages (if any).

This was pretty difficult for 18-year old me to implement correctly, and while it did have some bugs back then, Claude also struggled with this quite a bit (and its first attempt definitely had a lot more bugs). It required several iterations with detailed explanations to get it somewhat correct. The problem is that a rough look suggests it’s a simple A* path search which requires either “water accessible” or “land accessible” tags on the tiles crossed, but in practice you need sub-tile routing with a 3×3 grid on each tile or another set of similar rules to make e.g. crossing between two parallel rivers work correctly, and to prevent e.g. crossing from (-1|-46) directly over to (-1|-47) in the above screenshot.
A new tech stack with old design flaws imported into it
I didn’t specifically instruct this, but I expected “rewrite in a new tech stack” to include e.g. new CSS and HTML layout techniques. Instead, the tool lazily stuck with the old CSS and HTML 4.01 Transitional. I mean, okay, fine.
Less defensible is the picked database layout in many places. For example, this is the map table:

It is very similar to the old map table, which is not a good thing. If I had redesigned this, I would have reduced it to x, y, id, terrain_id (which is what terrain this tile is) and variant (which is what variant of the graphics is used to make the map look less uniform). Everything else, especially the image column, is unneeded. height is for a feature never implemented and not at all referenced in the new code. But it was in the old table, so the LLM was “inspired” to do the same nonsense data duplication 17-year old me did again.
The same goes for many other properties of the layout, e.g. a lot of things are strings which could be integers (e.g. whole messages contained in each row even though there are only 5 possible strings), odd normalization (sometimes the 5 resources are normalized out into a separate table, sometimes not), duplicate data, … It is for sure much better than the old layout, but that’s not a high bar to set. It is for sure much worse than the first shot a somewhat competent human would have come up with.
The code is somewhat similar, there’s a “transaction” god object and basically the whole code base is a member function of that object. Not how I would have done it.

It’s… fine, but it would be so easy to separate the database-related concern out of this function that I would definitiely have done it and it’s like this everywhere. Also for some reason the category is a string which is also a common pattern.
We also have 20ksloc in effectively 2 Go modules, a backend and a frontend one. Ah, the frontend module has a different god object.
Final words about this project
For this purpose, having the LLM tech was absolutely great. I’m pretty sure this project would never have seen the light of day again without LLMs.

But like this, I could show it to my wife (who got quite hooked, haha) and have it preserved for the future, since I think the pile of Go code which now can run it will age pretty well.
Making smaller changes or fixes to the game would be very easy with this tech.
Some thoughts on the overall situation with LLMs for software development
I think there are various political points around this topic which need discussion, but this is a technical blog so I won’t say much here.
Apart from that, I am very much undecided what the role of LLMs will be in software development in the future.
So far, the best results I’ve had in terms of “I’m 100% sure this saved a lot of time” were of the form “look at this code and explain to me why it might deadlock, and in what situations”, or “find all occurences of this pattern and analyze which of them can be replaced by this other pattern”.
The code generation tasks were pretty mixed in my experience.
If you have an opinion on how the code should look like, it’s a lot of detailed baby-sitting, which sometimes leaves me feeling like “blargh, I could have done that myself in the same time”. I think there are the two sub-situations here where you either start with “write a class with this name which does that in this way” or somesuch, or where you say “solve this problem” and then review the result (in both cases). The former is more likely to be successful, but also saves you less of the thinking, which makes it slower upfront.
If you have no opinion about the code, it’s extremely fast but then you have code which doesn’t look the way you want it to (like in the example from this post). Which might be fine, I guess? It depends on the project. It’s great for short-term or one-shot utilities. It’s probably okay for tools which are either small, or do not see much churn after initial development.
What I am currently skeptical about is the life cycle of these “I cloned photoshop by assembling a team of fifty claudes”-style projects. Who is going to maintain that medium-term, and how? Are LLMs capable of doing changes to the resulting 3 MLOC code bases with some confidence after they have seen three years of churn? We do not really know this yet, it just remains to be seen.
In my limited experience, this doesn’t go so well beyond the initial bootstrapping, for a variety of reasons — overfitting to specific situations, overemphasis placed on tiny issues, loss of coherence (like it happens for projects with many human developers), and increasing loss of focus with respect to what end-user problem is actually being solved by the software product.
But only time will tell. For now, my opinion is that LLM code generation in a professional setting is only worth it for one-shot tools or personal utilities, or when you have yourself more-or-less thought through how it should work and just have the LLM do the typing and detail flesh-out. As a debugging and code analysis aid, LLMs are usually great.
Categories: Everything