On November 21, 2026, I released Legend of the Green Dragon: Resurrection 1.0.0. I started this project because I wanted an old browser game I remembered to run on modern systems again, and I'm stepping away from it now because I accomplished what I set out to do.
A Game From an Older Internet
Legend of the Green Dragon isn't a game most people are going to recognize in 2026. It belongs to an earlier Internet, when people logged into small browser games, made characters, fought a few monsters, checked their messages, and came back the next day to do it again. You didn't need a gaming PC, a storefront, or a hundred gigabytes of downloads. You needed a browser and a little time.
You started in a village, went into the forest, earned experience and gold, bought better equipment, trained, and worked toward fighting the Green Dragon. Around that simple loop were clans, other players, specialties, taverns, odd encounters, and modules that made one server different from another. It had personality. I enjoyed it, and I remembered it long after I stopped playing.
The original game was created by Eric Stevens and JT Traub, inspired by Seth Able's Legend of the Red Dragon, with later development by the DragonPrime team and contributions from module authors. That's their work, not mine. What I had was the 1.1.2 DragonPrime Edition, an old PHP codebase that was part of a much larger community history.
In 2019 I uploaded the 1.1.2 core and an archive of 187 historical modules to GitHub because I didn't want the files to disappear. I wasn't planning a new edition. I was preserving something from a part of the web I liked. Then the repositories sat there for years.
By September 2026, I wanted to see whether I could actually bring the game forward. Not turn it into a different game with a familiar name, and not just patch it enough to get a homepage to load. I wanted the old game recognizable, but with an implementation that belonged on current software.
I Started With ChatGPT, Not a Rewrite
The first thing I did was ask ChatGPT to help investigate what I had. We examined the preserved files, the architecture, the installer, database access, authentication, modules, gameplay routes, and the areas where old assumptions could become security problems. The September 13 investigation was read-only. Before changing the game, I wanted to know what was actually there.
It quickly became obvious that updating the PHP version wasn't enough. The game had been written around PHP 5 and an obsolete MySQL interface. Modern PHP had removed functions it needed. There were places where the application trusted request values too easily, relied on risky dynamic execution, or carried state through old database and serialization behavior. A successful page load would have told me very little about whether the game could be trusted.
We made preservation a hard boundary. The original 417-file source was kept under the historical-source tag, and the modernization work lived in a separate Resurrection repository. That meant I could inspect the original behavior whenever a change raised a question without quietly rewriting the record of what 1.1.2 had been.
The direction was simple: preserve the game, modernize the implementation. That translated into real requirements. Move the database layer to PDO and bound queries. Modernize passwords and sessions. Make state-changing requests accountable to the server. Replace unsafe execution mechanisms without deleting the game rules they supported. Build tests on PHP 8.4 with MariaDB 11.4 and PHP 8.5 with MySQL 8.4 rather than assuming one passing setup represented every environment.
Then the actual implementation work started, through ChatGPT. We moved from an application that couldn't start on supported PHP to a modern installer, real authentication, working navigation, and progressively tested gameplay. We brought the 24 bundled modules into the process, but I wouldn't call a module supported simply because it installed. At one point, all 24 passed their lifecycle checks, but none had earned complete certification. I kept them blocked until their actual gameplay behavior could be tested.
The early stages grew into serious work on combat state, special abilities, forest encounters, training, daily resets, account operations, and server authority over character changes. We found tests that passed for the wrong reasons, implementation problems that appeared only in one supported stack, and regressions where a new change disturbed behavior that had already been accepted. We kept working through those problems instead of treating a green result in one area as permission to declare the whole game finished.
By early October, the modernization branch had accumulated substantial real work. The historical source was protected, the core runtime and installer worked, and significant gameplay and security testing existed. But the original modernization pull request was still open. There was no 1.0.0 release, and there was still a lot left to do.
Changing AI Tools Didn't Mean Starting Over
I eventually moved the hands-on coding work from ChatGPT to Claude Code. I was getting better results from Claude for the next stretch of sustained repository work, and there was no good reason to keep fighting a workflow that wasn't the best fit anymore. I didn't throw away what we had built with ChatGPT. I changed the implementation tool.
That distinction matters to the history of this project. ChatGPT helped investigate the source, establish the boundaries, and implement a substantial part of the modern core. Claude inherited that work and carried the remaining modernization, release systems, interface redesign, and release-candidate corrections through to 1.0.0. Neither description is complete without the other.
The handoff worked because the project wasn't living inside one conversation. The decisions, source, commits, tests, documentation, and unresolved work were recorded in GitHub. The new coding session had to inspect the actual repository state and honor the same boundaries. On October 23, the original modernization pull request finally merged after the remaining acceptance work passed.
As development continued, I used separate sessions for different jobs. One was the command chat, where I worked through what the next task should do and evaluated the results. The other was the coding session, where Claude implemented changes and ran the checks. I made the decisions between them.
The work orders got specific. They identified the starting commit, the problem, what could change, what had to stay intact, which tests had to run, and what evidence the worker had to return. A report saying a task was finished wasn't enough. We checked the published GitHub Actions results, verified the expected branch and commit, and sent incomplete work back for a focused correction.
Sometimes the AI made a mistake. Sometimes a test was wrong. Sometimes a session lost its place or a report sounded more certain than the evidence supported. The answer wasn't to pretend those problems didn't exist. It was to check the repository, establish what had actually happened, and continue from a known state. I learned that being able to change tools without losing control of the project was just as important as getting code generated quickly.
The Decisions That Made Resurrection My Version
For a while, the modernization rule was to leave the player-facing game alone. Change the code underneath, but preserve how the game looked and played. That was a useful rule during the core work because it stopped the AI from redesigning something simply because it could.
On October 30, I changed that requirement deliberately. I still wanted Legend of the Green Dragon to feel like Legend of the Green Dragon, but I didn't want to stare at eighteen old skins on a phone in 2026. I approved one dark fantasy interface with responsive layouts, location scenes, creature and character portraits, improved character information, and original SVG artwork. Claude did the implementation and art production. I set the direction, reviewed what came back, and decided what belonged in the game.
I also had to decide what wasn't worth bringing forward. The original code included historical features and administrative surfaces that didn't belong in a modern release without a security model. Some were removed or disabled rather than carried over just for the sake of completeness. The archived 187 modules remained preserved, but they were not imported into Resurrection. The 24 bundled modules were enough to support, test, and release.
Hosting created another set of choices. I wanted someone with ordinary hosting-panel access to have an installation route, not only people comfortable at a command line. That meant a browser installer with a deliberate authorization mechanism, a documented upgrade path, and release packages that actually contained the instructions an operator would need. Account recovery and email verification had to be designed around real hosting capabilities, not an assumption that every server sends mail correctly.
Licensing set a boundary too. The original game carries noncommercial terms, and Resurrection is built on that code. It is not a commercial game I own outright, and I wasn't going to pretend the original authors' work became mine because I modernized it. Once I faced that reality alongside the amount of time I was investing, I had to decide what the project was for.
I set 1.0.0 as the finish line and limited the remaining work to what a real release needed: tested gameplay, installation, documentation, and a package other people could verify. That decision kept the final phase focused.
The Real Server Didn't Care About Green Checks
By November the automated testing was extensive. But the part of the process that mattered most to me was putting each release candidate on my own VPS and actually playing the game.
The first candidate, rc.1 on November 13, passed its release checks and still exposed problems after installation. Some were gameplay defects. Others were operator problems: the downloadable ZIP didn't include the modern installation instructions that existed in the repository. The code could pass, the release workflow could pass, and the person installing it could still receive an incomplete package.
Then I ran into a problem that was harder to dismiss. During rc.2 testing, the game day rolled over while I was in the forest. When I tried to look for something to kill, the action was rejected as expired or repeated, and the page gave me nowhere useful to go. I had to get out through an administrator's tool.
The next candidate exposed a related failure. I was in the middle of a fight when the game day changed. The new day's Continue button sent me to a forest search that refused because the old fight was still stored. Again, I was trapped. The automated test for the earlier correction had passed, but it had opened the destination page directly instead of following the actual Continue button a player would press.
That was a testing failure and a review failure. It wasn't enough to have a test that reached the right endpoint. The test had to follow the same route the player followed, with the same state and the same buttons. We changed how those paths were verified.
Rc.4 uncovered more variations. A training-yard action could lead to a bare refusal after the game day changed. Using a special ability could leave the battle screen without the enemy or any useful Fight or Run control. Each bug had its own trigger, but by that point I was seeing a pattern.
I stopped asking for one more isolated fix and directed the work at the entire category: player-facing actions that failed and left the person stuck on a dead-end page. The resulting review identified hundreds of refusal paths, distinguished the ones that intentionally stayed plain from those that belonged inside gameplay, and changed 172 player-facing refusals to return a useful response within the game. The tests were expanded to catch that class of problem in the future.
That decision is a better example of my part in the work than any line count. The AI could implement each correction. I had to recognize that we were repeatedly fixing symptoms of a bigger issue and change the assignment. The game became more reliable because we stopped treating every failure as unrelated.
Rc.5, released November 19, passed the real-server paths that had been causing problems. I followed it with documentation work and a small final correction pass. On November 21, the 1.0.0 release was published.
What Version 1.0.0 Actually Delivers
Resurrection 1.0.0 is a real downloadable release, not a mockup or a pile of promising source files. It runs on the two supported PHP and database combinations, has an installation and upgrade process, modernized account handling, server-controlled game actions, a redesigned interface for desktop and mobile, original artwork, and the original game's recognizable progression and bundled modules.
The historical 1.1.2 source remains protected under its tag. The released game includes all 24 certified bundled modules and a current 41-table database schema. Its automated checks include 534 PHPUnit tests, broader web and tooling tests, fourteen required CI jobs, and historical integrity verification. The release workflow creates verifiable packages and publishes a checksum so a host can check the actual download.
The work also has a record. The repository contains the source, the modernization history, the decisions, test evidence, issue corrections, host documentation, and release notes. I don't expect someone to take my word that the project was substantial. They can look at the code and the work that got it here.
I also want to be precise about what 1.0.0 doesn't mean. The release has not had an independent security audit, and the project does not claim that every requirement for operating a public multiplayer server has been completed. The documented hosting responsibilities still belong to whoever chooses to run it. Finishing the modernization isn't the same as claiming that no further review or operational work could ever be needed.
The official 1.0.0 GitHub release is public, and the Resurrection repository contains the documentation and development record. I also wrote about the work while it was happening, first in my September 2026 Builder Receipt and then in my November rc.1 article. Those earlier posts show the project at different stages. This one records the finish.
What This Work Shows About How I Build
I didn't personally type the PHP that makes Resurrection run. ChatGPT and Claude handled the implementation. My work was choosing what we were building, turning that choice into bounded assignments, evaluating what the AI produced, identifying where the evidence was weak, testing the actual software, and deciding what was accepted.
I had to understand enough of the application, the tools, the release process, and the failure modes to ask better questions and recognize when the results didn't hold up. That meant reading reports, checking actual behavior, and sometimes rejecting work that had already passed automated tests.
I learned to use the repository instead of a chat's memory as the durable project record. I learned how to direct work against exact starting commits and acceptance requirements. I learned to challenge a passing test when it didn't actually represent the user's route. I learned that an implementation report is a claim until someone checks it. And I learned when the correct response to a defect is to widen the investigation rather than keep making small repairs.
Those abilities apply beyond an old role-playing game. They matter in product implementation, QA, technical operations, publishing systems, release management, and teams trying to use AI for real development. If someone wants to understand how I approach that work, they can inspect the project or visit Work With Jim.
The Modernization Is Finished
I could keep going. There are always more features to add, more historical modules to revisit, new art ideas, and another thing somebody might want changed. The fact that I can think of more work doesn't mean the project needs more work from me.
My objective was never to operate a commercial game or spend the next few years developing a new one. I wanted to take software I remembered, preserve its history, replace an obsolete implementation, and produce a modern release that could be examined and installed. I did that. Version 1.0.0 is the point where I can call the modernization complete.
I'm not planning another development phase. I might come back to Resurrection someday, and a specific bug could deserve attention, but I'm not committing myself to ongoing features or a maintenance schedule. For now, the work is done and my attention is going somewhere else.
I kept Legend of the Green Dragon's source in 2019 because I didn't want it to disappear. In 2026, I brought it forward with AI tools I learned to direct, tested the result on my own server, and released it with the evidence attached. That's what I wanted to accomplish. I don't need to keep adding to it to make the accomplishment count.
New Here?
Read Next:
- Builder Receipt: Resurrecting Legend of the Green Dragon
- Legend of the Green Dragon: What rc.1 Revealed
- How I Actually Build Software With AI