Shattering the Technical Barrier: My Crash Course in Agentic Coding Tools

I have a lot of creative ideas floating around in my head. In this blog, we take some of that noise, learn about modern AI tools, and turn it into a signal.

• Today's Idea: Otter Video Game. 
• Today's Tools: Antigravity, Codex and Claude Code 
• My takeaway: The technical barrier to translating an imagination into a structured, playable product has been completely shattered.

Over the course of 20 days, after work or when the kids went to bed, I'd spin up my AI agentic coding tools and get lost in a state of creative bliss. The result was River Otter Survival, an arcade survival game where players control two otters drifting down a hazardous river. The core hook? The otters must hold hands to maintain their connection, but they naturally drift apart to dodge obstacles. Building a 30-level progression with multi-phase boss fights, a world map hub, and a rich meta-economy of clams and hearts was satisfying.

But the most fascinating part of this project wasn't the game itself—it was the workflow I built to create it. Here are the biggest takeaways from building a game where AI writes the code and the human directs the vision.

1. Game Design Becomes a Natural Language Conversation

Traditionally, game design requires writing a massive, static Game Design Document (GDD) and passing it off to an engineering team. Working with AI fundamentally inverted this process into a dynamic, conversational loop.

Instead of opening a spreadsheet to endlessly tweak physics variables, I could playtest a build and simply tell the AI, "Make them hold hands tighter, but drift faster when swimming apart". The AI instantly translated that abstract design feedback into living Phaser 3 physics code.

Why this matters: This conversational loop drastically lowers the friction of finding the "fun" in your game. You iterate on the "feel" and the narrative via natural language, rapidly prototyping and discarding mechanics in a single afternoon. It proves that AI speeds up iteration, but human judgment remains at the center.

2. The "Tech Lead" Multi-Agent Strategy Saves the Codebase

One of the most dangerous pitfalls of using AI for a large project is hallucination—if you ask one AI to do everything, the codebase will eventually collapse under its own weight. To solve this, I orchestrated a "Tech Lead" workflow.

Instead of having a single agent do all the work, I had Google's Antigravity analyze the codebase and write strict, highly detailed markdown blueprints. I then handed those architectural "tickets" to a second, specialized AI agent to actually execute the code. Finally, Antigravity reviewed the diffs, compiled the code, and verified the functionality.

Why this matters: Separation of concerns is just as vital for AI as it is for humans. Using one AI for architecture and another for execution kept the game incredibly stable and drastically reduced errors during our fast-paced 211-commit sprint.

3. Hybrid Architecture is the Secret to Painless UI

If you've ever tried to build complex UI menus inside a traditional game engine, you know it can be an absolute nightmare. Relying on Antigravity's architectural guidance, we bypassed this bottleneck entirely by using a Hybrid Architecture.

The core game logic, entity pooling, and arcade action ran entirely on Phaser 3 and TypeScript. However, the complex menus—like the interactive Store, the Home Builder, and the World Map—were built using a distinct HTML and Tailwind CSS DOM layer that hovered seamlessly over the game canvas. We engineered a seamless Pub/Sub communication bridge that passed real-time game state back and forth without causing memory leaks.

Why this matters: This approach marries the pure performance of a game engine with the ease of web development. We were able to build rich, responsive UI elements (complete with volume sliders and dynamic screen sizing for the iPad) in a fraction of the time.

4. Stop Building the Game; Build Tools to Build the Game

To move at blinding speed without losing control, you have to build custom tooling alongside your gameplay. Scaling production requires scaling your tools.

Instead of manually placing 15,000 obstacles across 30 levels, I had the AI write Node.js and Python scripts to procedurally generate massive level data files. When I needed to process AI-generated art, I didn't do it by hand; the AI wrote Python scripts (clean_checkerboard.py, fix_alpha.py) to bulk-process the images and make them engine-ready.

Most importantly, when a notorious "Game Over Freeze" bug appeared, the AI built headless Puppeteer browser bots to autonomously play the game, reproduce the crash, read the console logs, and write regression tests.

Why this matters: The true superpower of AI isn't just writing game code; it's instantly generating bespoke developer tools, automated QA bots, and asset pipelines that empower solo developers to operate with the capacity of an entire studio.

5. The Human Role Shifts from Typist to Director

We often fear that AI will replace the soul of a game, but the reality is the exact opposite. Because the AI agents handled the tedious architecture, the CSS grids, the background asset processing, and the collision algorithms, my role completely shifted.

I stopped being a solitary programmer and started acting as a creative director. I spent 90% of my time focused purely on pacing, player emotion, and tuning the core gameplay loop. I established strict fairness and readability rules so the harder levels felt demanding but not sloppy. I designed the emotional escalation of the boss fights, while the AI calculated the projectile math needed to make them punishing but fair.

Why this matters: AI didn't make the game for me—it gave me the bandwidth to focus on the human elements of game design. It proved that AI becomes most useful when paired with strong human constraints, validation tools, and a clear design point of view.

The Final Takeaway

Building River Otter Survival over those 20 days was a profound shift in how I view software development. AI agents are no longer just novelty tools or code-suggesters; they are iterative collaborators that fundamentally elevate the developer's role from "programmer" to "director". The technical barrier to translating an imagination into a structured, playable product has been completely shattered.

The only question left is: what will you direct first?