Case Studies

Claude Ported 68000 Assembly to Godot in One Night — The 33-Year Story Behind It

A developer used Claude to bring a 1993 Amiga assembly game into Godot overnight, but the real work was 33 years of notes, git history, and human memory. LLMs are better translators than reverse engineers.

Font size

An 11-year-old in Baghdad wrote an Amiga game in Motorola 68000 assembly. Thirty-three years later, Claude moved it into Godot in a single evening. It sounds like an AI fairy tale, but after reading the original blog post, the more interesting story isn't how powerful Claude is. It's that the model is useless without a human attached.

Some facts first, so this doesn't get passed around as legend:

  • The game is Babylonian Twins, released in 1993, originally written in 68000 assembly
  • The core port to the Godot engine took one evening — the author's words: "It took an evening!"
  • The tool was Claude. The "Claude Fable 5" mentioned in the blog is a typo; it's actually Claude 4.5
  • After the prototype came together, tuning the feel and packaging it for release took several more weekends

One evening: 1993 Baghdad assembly running in Godot

The input for the port wasn't a disassembly dump. It was:

  • The author's own git repositories (his iterative versions over the years)
  • Notes accumulated over 33 years
  • His own memory of how the game was originally structured

Claude took those inputs and produced a Python script plus a GDScript project. Godot 4 ran it directly. The prototype landed that night.

I've spent a few years on adjacent work with Amiga emulators, so I know what the real cost is when porting 68000 assembly to a modern language — it's not writing code, it's understanding the original system. How the registers were allocated, how memory was laid out, how the copperlist drew double buffering. Trying to figure that out from disassembly alone will drive you around the bend.

Claude finished in "one evening" because those 33 years of comprehension cost weren't on its side of the table — they were on the author's. The LLM received design intent that had already been chewed through by a human, not raw bytes. This is the part of these AI stories that gets hyped the hardest and understood the least.

What input does an LLM actually need to port assembly?

Most people see a story like this and instinctively credit Claude, concluding "LLMs can write assembly now." That conclusion is wildly off.

Try the counterfactual: feed Claude only the raw 68000 binary from 1993 — no notes, no repos, no Q&A with the author. What does it produce in one evening?

My bet: nothing useful. At best, a tool that parses Amiga's HUNK format and generates equivalent C — the kind of thing hobbyists wrote in the '90s. It wouldn't know which offset maps to sprite layer 3, or that the player's hitbox should shrink by one pixel when stepping into a pit.

The original author was notably restrained about it. His exact words:

"I wasn't just feeding it assembly code. I was feeding it my 33 years of memory of how I built the game, my notes and the git repos."

Plain English: Claude's role in this project was "typist plus translator," not "reverse engineer." The mental work was the author's; Claude only translated the output of that mental work into a language Godot could swallow.

That's the boundary of AI assistance — it doesn't replace the programmer, it replaces the drudgery of reading old code. Architectural decisions, naming conventions, module boundaries, debugging instinct — all human.

One evening for a prototype, several weekends for a playable game

The original blog splits this out in a way worth quoting:

"It took an evening to get a working port. Getting the feel right and shipping it took a few more weekends and evenings."

"Runs" and "plays" are different things.

  • Runs = no console errors, sprites show up, the protagonist moves
  • Plays = jump arc feels right, controls are smooth, collision doesn't drop frames, BGM doesn't clip

I've done similar work — moving an old JS core project over to TypeScript. The LLM absolutely produced a "runs" version in one evening. Then came hours-to-days of work per item: tightening types, adjusting async semantics, reordering the event loop.

The original author didn't showboat about that second phase. He just recorded the time split honestly. One evening was the LLM's contribution. Several weekends were human. Anyone planning a "project-level migration" with AI should do that math first — don't build a business case around "LLM did X in one night." X is 5% of the work. The other 95% of feel-tuning is the actual project.

A 1993 level editor screenshot — first boot in 33 years

One image in the blog held my attention for a while: a screenshot of the author's old level editor, running 33 years later.

That vintage Amiga Workbench color scheme, the sparse few-line toolbar, the tiles dragged into place with a mouse — the level data matches what's in his current Godot project on GitHub exactly.

Translation: 33 years passed, the data didn't change, only the language carrying it.

# Godot 4 level loading snippet (illustrative)
const LEVEL_DATA = preload("res://levels/world_1.tres")

func _ready():
    for tile in LEVEL_DATA.tiles:
        var sprite = Sprite2D.new()
        sprite.texture = load("res:://sprites/" + tile.asset_id + ".png")
        sprite.position = tile.world_pos
        add_child(sprite)

That GDScript does the same job the 1993 68000 assembly did when stuffing tiles into a copperlist. Five generations of language, four platform swaps — the abstract skeleton of "draw a map onto a screen" never moved.

That's also why the LLM port worked — because the abstraction stayed stable. If the original author had relied heavily on hardware-specific tricks (say, odd/even row optimizations for the Amiga Blitter), the LLM might still translate the code, but it would run like a slideshow, because modern GPUs don't play along.

Editor's note: what this actually proves

The easiest read is "Claude can do assembly now," which is also the most useless read.

The more accurate read: LLMs are an underestimated translation accelerator and an overestimated understanding machine. Translation, they're genuinely strong at — Python to GDScript, C to Rust, 68000 assembly to Python, as long as the abstraction levels line up, they can clear the distance in one evening. Understanding, they don't do at all. That's been the author's job for 33 years.

My prediction: over the next 12–18 months, more "old code, new platform" cases will surface, and each will be packaged as "an AI milestone." Crack one open and the pattern is the same — humans laying groundwork, LLMs taking shortcuts behind them. That doesn't mean LLMs are useless. In scenarios where the groundwork is done and the shortcut is expensive, they're worth a lot. But it also doesn't mean LLMs can independently handle project-level migration. They can't, at least not today.

What makes this case different from past LLM coding demos? Past demos were mostly "write a small project from scratch" or "rewrite a known algorithm." This one is 33 years of real legacy baggage plus a real human knowledge injection. That makes the credit allocation hard to read, which is exactly why it gets misread.

One last detail from the blog: the blog post itself was drafted by Claude, then edited line by line by the author over a week. At the end, he complains that "AI-written text reads like AI," and that he spent a week fixing it.

That detail is more worth remembering than "Claude ported assembly in one evening" — he knows when to use AI and when to do it himself. That's what writing code in 2026 should look like.


Source: Porting a 1993 Amiga game to Godot with Claude - babyloniantwins.com

Source: https://babyloniantwins.com/blog/porting-a-1993-amiga-game-to-godot/