Day 1 with Claude: Five Games, One Website, and 128 Million Tokens
Saturday I sat down with Claude Code (Opus 4.6) and decided to see how much I could get done in a day. The answer: a lot more than I expected. By the end of the day I had resurrected a dead website, ported four games from Haxe/OpenFL to Godot 4, built a brand new game from scratch, deployed everything to the web, and wrote blog posts about all of it.
Here’s the full recap of Day 1.
What Got Done
1. Resurrected My Personal Site
The task: A Concrete5 CMS website that hadn’t been touched since 2014. MySQL database still running by inertia. Six blog posts trapped in CollectionVersionBlocksOutputCache. Flash embeds everywhere.
The result: A clean Jekyll static site with all original content recovered, Flash demos running via Ruffle WebAssembly, custom layouts, SCSS, and deployed to shared hosting via FTP. Full write-up here.
| Stat | Value |
|---|---|
| Sessions | 4 |
| Prompts | 44 |
| Tool calls | 350 |
| Tokens | 33.6M |
| Active AI time | 61 min |
2. Ported TappyPlane (Flappy Bird Clone)
The task: A 3-hour game jam Flappy Bird clone in Haxe/OpenFL with Nape 2D physics. Convert to Godot 4 for browser play.
The result: Pixel-perfect port with polygon collision extracted from the original Nape PhysicsData.hx — 12-vertex rock shapes, 14-vertex plane shape, 25-vertex ground surface profile. Three collision iterations: AABB (ghost hits), tuned AABB (better), full polygon via Geometry2D.intersect_polygons() (correct). Full write-up here.
| Stat | Value |
|---|---|
| Sessions | 1 |
| Prompts | 19 |
| Tool calls | 140 |
| Tokens | 20.5M |
| Active AI time | 51 min |
3. Ported QuickSki (Slalom Game)
The task: A Haxe/OpenFL slalom ski game. Port to Godot 4 and make it actually fun.
The result: Not just a port — a redesign. Added forgiving flag collision (ski tips can brush gates), progressive speed ramp, and AI skiers that spawn after gate 12 and weave unpredictably. Full write-up here.
| Stat | Value |
|---|---|
| Sessions | 3 |
| Prompts | 23 |
| Tool calls | 253 |
| Tokens | 15.5M |
| Active AI time | 29 min |
4. Ported Snake (10-Level Snake Game)
The task: A 4-hour game jam Snake game in Haxe/OpenFL. Three hand-crafted levels, frame-counter movement.
The result: Went way beyond the original — 10 levels (7 procedurally generated), pixel-styled snake with directional eyes, pulsing diamond food, procedural chiptune music, event-driven input queue that fixed the original’s self-death bug. 1,155 lines of GDScript, zero external assets. Full write-up here.
| Stat | Value |
|---|---|
| Sessions | 3 |
| Prompts | ~20 |
| Tool calls | 124 |
| Tokens | 15.2M |
| Active AI time | 36 min |
5. Built SquirrelDefense (New Game)
The task: Build a new game from scratch — inspired by the slap minigame from the Simpsons arcade game. Bird feeder in the center, birds land and generate points, squirrels try to climb the pole, player slaps them away.
The result: A complete game with hawk swoops (growing shadow warnings), bird seed mechanics, slick pole upgrades, ground-walking birds, day/night cycles. The most iterative project of the day — 86 edits across sessions as we tuned squirrel spawning, bird behavior, and visual feedback. All built in Godot 4. Full write-up here.
| Stat | Value |
|---|---|
| Sessions | 3 |
| Prompts | ~20 |
| Tool calls | 296 |
| Tokens | 43.7M |
| Active AI time | 66 min |
The Grand Total
| Metric | Day 1 Total |
|---|---|
| Projects completed | 5 games + 1 website |
| Claude Code sessions | 14 |
| Human prompts | ~126 |
| AI responses | ~1,523 |
| Tool calls | ~1,163 |
| Total tokens processed | ~128.5M |
| Total active AI processing | ~243 minutes (~4 hours) |
| Wall clock time | ~12 hours (including playtesting, breaks, deploying, writing) |
| Blog posts written | 5 (plus this recap makes 6) |
| Games playable in browser | 4 (TappyPlane, QuickSki, Snake, SquirrelDefense) |
| Model | Claude Opus 4.6 across every session |
128 million tokens. That number looks absurd until you understand how Claude Code works: the vast majority (~95%) are cache-read tokens — the conversation history replayed from cache on each turn. That’s dramatically cheaper than fresh input. The actual new output across the whole day was roughly 500K tokens — the code, the analysis, the blog posts.
Lessons Learned: Optimizing for Opus 4.6
After 14 sessions and 126 prompts, patterns emerged. Here’s what I learned about getting the most out of Claude Code.
1. Front-Load Everything
The single biggest time-saver: give Claude all the context upfront. Point it at the entire codebase before asking it to write anything. The TappyPlane conversion read all seven Haxe source files, both sprite sheet XMLs, and the UI layouts before generating a single line of GDScript. The result ran on the first try.
When I drip-fed information (“oh, there’s also a database” … “oh, the images are in git history”), each reveal cost a round trip. The website resurrection took 44 prompts partly because context arrived in pieces. TappyPlane took 19 prompts because everything was available from the start.
2. Describe Feel, Not Implementation
“Ghost collisions where the plane crashes but I don’t see anything touching” was more useful than “shrink the AABB by 10 pixels.” Claude diagnosed the tapered-sprite-vs-rectangle problem and proposed the right fix. When I said “precise and brutal like the original,” it went straight to the Nape polygon data.
For QuickSki: “real skiing doesn’t work that way — your ski tips can brush past a gate” produced better collision forgiveness than specifying pixel offsets would have.
3. State Quality Bars Early
My first TappyPlane prompt didn’t mention collision precision. The AI correctly defaulted to the simplest approach (AABBs). Two iterations later we had polygon collision. If I’d said “use polygon collision matching the original Nape shapes” from the start, we’d have shipped in one pass.
The Snake input system was the same story — polling-based input in session 1 caused a self-death bug that wasn’t fixed until session 3. Specifying “event-driven input with a queue” upfront would have eliminated the bug from day one.
4. Fewer, Meatier Sessions
SquirrelDefense used 3 sessions and 296 tool calls — the most of any project. Some of that was inherent complexity (new game, lots of tuning), but some was session overhead. Each new session re-establishes context. The Snake project also used 3 sessions but could have been 2 if I’d combined the initial port with the first polish pass.
For future work, I’d aim for one session per major milestone rather than splitting fine-grained tasks across sessions.
5. Let the Explore Agent Do Its Thing
Claude Code has a subagent pattern — it spawns a focused “Explore” agent to read a codebase before the main agent writes code. The TappyPlane session did this automatically: the explore agent read every source file and reported back a structured summary. The main agent then wrote the conversion in one pass.
I didn’t ask for this — Claude decided the codebase was complex enough to warrant exploration first. In future sessions I’d explicitly request it for unfamiliar codebases: “explore the entire source tree and summarize the architecture before writing any code.”
6. Cache is Your Friend (and Your Budget)
128M tokens sounds expensive. It’s not. Cache-read tokens cost a fraction of fresh input tokens. The real cost drivers are output tokens (~500K total) and cache-creation tokens (~5M total, when new context enters the cache for the first time). The 120M+ cache-read tokens are just the conversation replaying itself efficiently on each turn.
Practical implication: long sessions with many tool calls are cost-efficient because the cache hit rate is high. Short sessions with large initial context loads are expensive because the cache has to be populated fresh.
What’s Next
Day 1 was about proving the workflow: take old projects, point Claude at them, iterate through playtesting, deploy. It works. The bottleneck isn’t the AI — it’s me describing what I want clearly enough.
The backlog includes more old Haxe/OpenFL projects to port, more side projects to tinker with, and whatever else catches my interest outside of my day job as Director of Engineering at Samsara. The _posts/ directory is filling up fast.
If you’re sitting on old game jam projects collecting dust: it’s never been easier to bring them back. Pick a Saturday, fire up Claude Code, and see what happens. You might surprise yourself.