I finally knocked out one of those projects that had lived in the someday pile for years: I got Starting Lineup Talking Baseball, a little electronic game from 1988 that I loved as a kid, running in the browser.

A big part of why I had never done it was simple: the fun-to-effort ratio looked terrible. This thing runs on an Intel 8051 microcontroller. Getting something accurate enough to emulate that hardware in the browser via WASM sounded like real work, not weekend messing around.

Then I tried it with Codex.

I handed it some reference docs I had collected over time plus a half-baked open source 8051 emulator, and it went to work. Important detail: that emulator was not designed for WASM or the browser. It was just a C program meant to run from the command line. Codex figured out how to make it compile under Emscripten, target WASM, and actually work inside a browser. Within an hour or two over the weekend, I had the game booting and basically playable.

The UI is still absolutely in debug mode, and there is a major cleanup pass ahead of me there. But the part I wanted most is real now: the game runs, it plays, and it is weirdly satisfying to see a childhood object come back to life inside a tab. I am playing this game again in the browser for the first time in 30 years. It is still fun, and it brings back good memories.

AI makes odd little personal software cheaper

This is maybe my favorite category of AI-assisted programming right now.

Not the giant product roadmap. Not the polished demo. The weird personal project that is too specific to justify a week of focused engineering, but interesting enough that you never quite stop thinking about it.

For me, this was one of those. Starting Lineup Talking Baseball is not some culturally important artifact. It is a niche game that probably mostly resonates with people around my age. But it's fun and I enjoy it. A problem that used to feel like a heavy lift suddenly felt light enough to try on a weekend.

WASM without the configuration headaches

Part of the appeal was technical, obviously. The original game runs on an Intel 8051. That is old, small, idiosyncratic hardware. If you want it on the web, you need an emulator that is accurate enough to preserve the behavior that actually makes the game feel like itself.

That is why WASM is such a fun target for this kind of thing. Once the emulation core is stable, the browser becomes a distribution format, a demo environment, and a little preservation layer all at once.

You can hand someone a link and let them touch the thing. That is different from uploading photos or writing a nostalgic thread about old hardware. It turns memory into interaction.

I did not start from a browser-ready emulator. I started from a rough open source C program that expected to live in the command line. Codex was useful here less as a magician and more as a very fast collaborator: take the docs, inspect the code, patch the rough spots, and bridge it into an Emscripten build that could target WASM and behave in a browser.

This worked because there was real reference material and a real starting point. Codex was able to connect the dots and get it working. I was especially impressed that it was able to get the audio buffer running on the browser in the first pass. This game is entirely audio based so getting the audio interface working is a requirement rather than something nice to have.

The first pass was impressive. The debug loop was the real win

The funny part is that the emulator basically worked on the first pass.

That sounds like the kind of sentence that makes people roll their eyes about AI, so let me be precise: it booted, it ran, and it felt way closer than I expected. That alone was enough to make the whole weekend feel worthwhile.

But then it would sometimes lock up in the middle of a game.

And that is exactly the kind of bug that can eat all the joy out of emulation work. A lockup like that is rarely obvious. It is usually some subtle CPU behavior, flag handling, timer logic, memory issue, or instruction edge case that only surfaces later when the game has wandered into just the wrong state.

This is where the project got interesting.

Instead of asking Codex to keep guessing, I had it generate a tool that would dump memory the next time the emulator wedged itself. That gave me a concrete artifact from the failure instead of just a vague description of a random hang.

When I fed that dump back into Codex, it found two bugs in the emulator and fixed them. Since then I haven't had any issues playing the game.

That is the workflow I keep coming back to with agentic coding: not please be smart for me, but help me build the right instrumentation, then reason from evidence. The flashy part is generating code quickly. The actually valuable part is shortening the path from weird behavior to useful data.

Old toys are a good test for new tools

There is also something nicely backwards about using modern AI tooling to revive a late-80s electronic baseball game.

It is easy to talk about coding agents in the language of productivity, enterprise leverage, and velocity. Sometimes that is fair. But I think there is another test that matters too: do these tools let us do more small, delightful, unnecessary things?

This project passed that test for me.

I had wanted to do this for a long time, but writing or fixing a custom emulator, getting it compiled to WASM, and wiring up a browser front end always felt like more effort than the joke was worth. The joke, in this case, being that the finished thing mainly amuses me and maybe a handful of other people who remember this game.

But that is not a knock against it. That is the whole point.

Personal computing used to have more room for projects that were specific, unserious, and useful to only a few people. AI is at its best when it expands that category, not when it flattens everything into one more generic app.

The part that still needs work is the part everyone can see

Right now the UI looks like what it is: a debug-heavy workbench that accidentally happens to run a baseball game.

I have more cleanup to do there than anywhere else. The core emulation is in good shape now, but the presentation layer still needs a real pass if I want this to feel like a polished little web experience instead of a developer screenshot with a childhood obsession hidden inside it.

That is fine. Debug mode is an honest phase.

I would much rather have a slightly ugly version that really works than a pretty shell around a flaky emulator. The nice part is that the hard psychological barrier is gone. The thing exists. It runs. The remaining work is refinement, not uncertainty. I'll get it to that point in the next few weeks.

This is exactly what I wanted from AI coding tools

The best part of this whole experiment is not that it saved me months. This was never going to be months. The best part is that it turned a long-standing someday project into something real with maybe an hour or two of weekend effort.

That is a big deal to me.

There are a lot of things I want from tools like Codex, but high on the list is this: help me make the stuff that is too small to staff, too weird to justify, and too fun to ignore.

Starting Lineup Talking Baseball in the browser is a ridiculous sentence. It is also, apparently, a thing I can now open in a tab.

That feels like progress.

If you had one of these as a kid, you probably understand exactly why this made my weekend.