Age of LLMs

Over the last few months I’ve dived head first into LLMs starting from running them locally understanding all the ins and outs of what that requires, to running them in data centers on serverless GPUs paid by usage, to finally joining the rest and paying a provider for a plan. I haven’t quite gotten into finetuning/post-training but I got pretty close that I can quickly set that up within a day provided good training datasets are already prepared.

I feel like my journey is the opposite of most devs 😅 but that’s fine as I learned so much from it all.

At the beginning I used LLMs as a peer-developer. The LLM reviewed the code as I write it, writing test suites, utilities, and helping with debugging. This was very effective and impacted my development pipeline and productivity positively.

Then I transitioned into deeper LLM involvement especially as I started using higher end ones such as GLM, in this stage I wrote the critical path and planned everything else completely, and only used the LLM to implement specific portions that are already well defined or trivial code that would just be a waste of time for me. This felt like magic. It was incredibly liberating in that I can essentially remain mostly in flow by offloading any distractions to the LLM (ie. research a compatibility issue). I wrote about the epiphany I had of “Whose Experience is This?” and the approach I adopted to resolve this inner conflict.

In the third stage, I delved into the vibe-dimension and dipped my neural network into building harnesses. It’s prophecied that every dev who explores LLMs shall ultimately build a harness (or several). I started building one but then I read about deepseek’s harness which just came out at the time and really liked that it’s a template for building harnesses because every single thing in it is essentially a plugin and it already comes with all the skills necessary to build plugins for itself.

Through dsh (deepseek harness), I tried vibe-coding for the first time as it allowed me to experiment with building plugins for the harness. This kinda got out of control simply because of how fast LLMs can build features.. here’s a brief list of the main projects I ended up doing either fully or almost fully vibe-coded using my dsh-kanban plugin:

LLM-assisted Projects

dsh-kanban harness plugin

This ended up being the highest value experiment I did simply because of how compatible it is with my current development pipeline. I implemented the integration first in deepseek harness as a full integration and then in opencode/pi as a minimal integration.

Portable Kanban is the core of this, it’s an excellent and compact vscode/codium extension that implements a fully operational kanban board through a single json file that lives in the repo with the project.

The integration is to give LLMs the tools to be able to fully and directly read and manipulate the kanban board using the Portable Kanban json schema as the collab platform between the developer and the LLM.

In deepseek harness, I re-implemented the kanban board UI into the harness workspace itself from an AGENTS.kanban file that is read from the workspace path (when available). This allows working on multiple projects in parallel without the need for vscode to be open (vibe-coding).

In opencode and pi I dialed back the integration so it’s just the kanban tools for the LLM, the UI part is already implemented in the vscode plugin. This is more compatible with my process and is less vibe and more assisted development.

Star Pulse browser-game concept

A browser-based procedurally generated galaxy for a space trading and combat game.

Galaxy is made of thousands of sectors. Each sector has 10s of systems. Each system has stars, planets, moons.

Each terrestrial body may have mineable resources and some planets (mainly within the habitable zone) have cities, cultures, currently living or ancient dead civilizations.

You can choose one of 3 pilot profiles for your pilot: retired fighter pilot, exiled royalty, or descendent of pirates. Each has their own campaign and pool of traits that directly relate to their past. Base stats are fixed. A new trait can be acquired by choice every N levels, each trait has advantages but also a hidden disadvantage.

And that’s as far as it went. I’d like this to not just be about trading and fighting. But to have a portion of side-quests be dynamically generated by an LLM (seed-based) but in a controlled way. And I’d really like it to have early/mid/late game mechanics that evolve. Think X3 scale mechanics: ability to own many ships controlled by AI or hired pilots, establish trading routes, ability to build mining stations and ore processing facilities, and later on factories.

betaPages Rewrite

This project is personal. It is based on my first attempt at building my own blog CMS when I was in university to run my website on. I lost betaPages along with many other projects when my main harddrive died (my backup was on the same drive on a different partition, it taught me a lesson.. and I used version control ever since).

I didn’t re-attempt betaPages as I discovered static generated websites at some point and used Jekyll for this blog for the next decade or so (until I migrated to hugo last year).

betaPages was special for me because it ran almost like a wiki. To create a new page or post, you just point your URL to it and if you’re logged in as admin (via OAuth), betaPages would let you create that content on the spot.

This mechanic extended to the website pages and even the home/footer menus. Everything was editable in-place so websites can be built dynamically and progressively which naturally made it perfect for a blog compared to the bloat of WordPress et al or the monolithic nature of drupal/django/etc.

I wrote the spec I remembered from betaPages and used my kanban plugin with dsh to revive betaPages again using PHP and MariaDB up to the point where it is usable and looks distinctive.

In its current states after a few fixes and features, the system is extremely easy and fast. Everything you see here is directly customizable except the All Pages menu item, the sun button (to switch day/night mode) and the account stuff next to it.

For example the Blog menu is defined as all pages under blogs/*, while About is defined as the about page.

There are many predefined themes, each with day and night modes. Here’s amber-retro:

Shortcodes to embed youtube, video (mp4 and webm), and audio (mp3 and ogg) are supported via {< type "src" >} format in the markdown content.

It’s sophisticated enough to track where each uploaded resource is used and clean up orphaned resources.

The only missing piece is a mechanism for templated CSS themes. But in the age of LLMs, do we really need that anymore? instead it should just be a skill for declaring a theme and throw your LLM of choice at it.

MinBasic fantasy computer

I’ve tried building my own BASIC interpreter multiple times to varying levels of success. My most successful attempt wasn’t an interpreter, but a transpiler from my own higher level basic into a GW-BASIC/MSX-BASIC compatible output.

MinBasic is just a BASIC interpreter based on my own BASIC flavor meant to run inside a browser to simulate a fantasy computer visually (similar approach to Breadbox but running inside a browser). Early days.

ARM1176 SoC baremetal computer

One of my most recurring desires is to develop a minimal OS and assembler/middle-ware that boots baremetal on a Raspberry Pi Zero (has an ARM1176JZF-S chip). Then I can use it to build barebones software starting possibly with a FORTH compiler. One may argue this is another fantasy console idea (like MinBasic) and that’s most likely accurate lol

The reason why I never seriously attempted this one beyond a simple baremetal boot + minimal C/C++ kernel; is because I knew how much work it needed and I knew that if I finished it in reality, I’d most likely never use it 😅

But now is different times. LLMs are perfect for a potentially throwaway project like this. And so it was..

(This is running via this QEMU fork. Written using C and arm6 assembly, font used is the DEC VT100 8x10 font)

Goimo Physics Engine

Last year I started developing a remake of my retro FPS shooter Zamron to modernize it and expand it into a full game. I chose to use Go and G3N for the principle-layer, with the intention to heavily modify G3N as the project evolves to implement more elaborate features.

I got to the point of implementing Physics, and was surprised to find out that there’s no native stable physics engine for Go! about the only real option out there is using a cgo binding for Bullet which looked very early and abandoned.

I decided that it’s worth my time to port a stable physics engine to native Go, after researching options I chose to port the excellent OimoPhysics engine written in Haxe which had everything I needed for Zamron and is sufficiently battle-tested and very stable. I called the port Goimo and it’s also MIT licensed naturally (the phase2 branch has the latest changes with LLM-written refactoring and test suites).

The engine is ported entirely by hand up to this point the good old way complete with human-caused bugs (look below lol). I only used LLMs for scripts and reviewing ported code to catch any errors I made. The last big feature ported was the broadphase BVH pass.

Last time I worked on Goimo I was debugging this physics bug that caused the engine to explode on stacking boxes:

I spent several days back in January (2026) debugging this issue, caught a few mistakes but the core bug wasn’t caught and my LLM reviewer script couldn’t really catch much back then especially using the prehistoric LLMs I had access to..

Long story short, with some scaffolding I tossed GPT-5.6 Sol at the problem and it uncovered several actual bugs in my port but the most egregious cause was this:

yep.. while porting my eyes saw that l in haxe as a 1 😅 my mind must have been on vacation at that point.. and of course it was in quaternion math.. 🤦 I’d have caught this if I wrote a Quaternion test suite, which was in my task list.

Anyway, I’ve added goimo to the projects tracked by my dsh-kanban plugin and implemented an additional 2 demos to test that the rest of the port is now stable enough for me to progress to the next part. Here’s the towers stacking demo showing box-box physics working beautifully using BVH for the broadphase:

Game Dev when?

I get this question a lot and I’ve been thinking about it..

A lot of people who don’t know any better think that current LLMs can just make any game they want (and make no mistakes) or that it’s negatively effecting the game industry.