An increasing share of software engineering is moving toward autonomy. Recently, I set out to explore the current frontier of coding agents, including IBM Bob, Claude Code, Codex, and Gemini, to see if I could build functional applications without writing, or even inspecting, the underlying source code.
A quick caveat before diving in: spec-driven development and structured oversight remain essential when architecting complex, mission-critical production systems. However, autonomous agents are already remarkably capable when tackling rapid prototyping, proof-of-concept experiments, documentation generation, and test suites. Advanced models, robust execution harnesses, and autonomous iteration loops make this shift possible.
C64
My first computer was a Commodore 64, which I originally used to write BASIC programs. Back then, commercial games were written in 6502 Assembly, a language that felt far too arcane and low-level for me at the time.
To truly test whether an autonomous agent could deliver software in a domain where I lacked deep syntactic expertise, I tasked it with building two classic C64 games in pure 6502 Assembly.
Initially, I anticipated having to feed the agent extensive technical reference manuals and sample codebases. Surprisingly, modern frontier models already possess a deep grasp of 6502 architecture, memory maps, and VIC-II registers. By leveraging autonomous task loops, goals, planning modes, and computer-use capabilities to run and verify code directly inside a local VICE emulator, the workflow proved remarkably straightforward.
Labyrinth
The first game I built was a classic maze crawler called Labyrinth (available as open source; see screenshot above).
Assembly operates directly against hardware registers and memory addresses without the safety net of high-level abstractions. Here is a brief snippet generated by the agent handling entity collisions and victory conditions:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
check_collisions:
lda ent_alive + ENT_BULLET
beq @hero_checks
ldx #ENT_MONSTER_A
jsr try_bullet_hit
ldx #ENT_MONSTER_B
jsr try_bullet_hit
@hero_checks:
ldx #ENT_MONSTER_A
jsr try_hero_hit
ldx #ENT_MONSTER_B
jsr try_hero_hit
lda gold_taken
bne @done
lda ent_off + ENT_HERO
bne @done
lda ent_cell_x + ENT_HERO
cmp #GOLD_CELL_X
bne @done
lda ent_cell_y + ENT_HERO
cmp #GOLD_CELL_Y
bne @done
lda #1
sta level_won
@done:
rts
Beyond the core game logic, I instructed the agent to generate unit and regression tests, which it completed and verified autonomously in parallel.
Baker Barney
To push the complexity further, I decided to build a three-level jump-and-run game from scratch.
I began by prompting the model for creative game concepts and character profiles. The winner: Baker Barney - The 3 AM Yeast Beast.
It is precisely 3:00 AM at Barney’s Bakehouse. Barney dumped an ancient, forbidden yeast culture from the catacombs beneath the flour cellar into the industrial mega-mixer, and the whole inventory has come to life. Across three single-screen rooms, Barney must collect every golden pretzel and reach the emergency steam vent before the flour dust closes in.
From there, the development unfolded in a few guided steps:
- Level Design: The agent drafted several stage layouts, from which I selected the three best candidates.
- Visual & Logic Specs: The model generated screen-by-screen layout specifications mapped to C64 character tiles, accompanied by precise state-transition logic.
- Autonomous Implementation: Running an iterative build-test loop, the agent assembled the game logic, compiled the code, and debugged edge cases against the specifications.
From initial concept to a fully playable 3-level C64 platformer, Baker Barney took roughly 3 to 4 hours of autonomous agent run time.
Next Steps
To find out more, check out the following resources: