Over roughly four to five hours of active work spread across a couple of days, Keith used Claude Code to port the game "2048" from an open-source Javascript implementation to a C/C++ version that runs on an inexpensive ESP32-S3 microcontroller. Claude wrote all of the resulting code. But the reality of the collaboration is more nuanced than that number suggests.
Claude was fast at producing working code — display drivers, build systems, CI pipelines, animation logic — generating in minutes what would have taken Keith days or weeks to do by hand. It could hold dozens of files in context and make coordinated changes across all of them. When the game crashed with a cryptic memory dump, Claude decoded the call stack and traced the bug to a specific line where a division by zero was happening inside the graphics library. This is expertise Keith does not have. It was also good at grunt work: converting font files, writing build configuration, organizing changes into clean commits.
The game runs on a physical device. Claude cannot see the screen, touch it, or swipe. Every observation about how the game actually looked and felt came from Keith.
This was the project's biggest bottleneck. After Claude implemented tile slide animations, Keith tested on hardware and reported: "The tiles pop in and out of existence as they move." Claude spent considerable effort theorizing about buffer management and rendering order — thorough analysis, but blind. Keith captured slow-motion video of the screen and identified the actual problem in one observation. They went through four different animation approaches. Claude could rewrite the code in minutes each time, but the feedback loop — flash the device, test, observe, describe — was bound by the physical world.
Keith's value wasn't in writing code. It was in holding a clear vision of what "done" meant. A working game wasn't enough. The animations had to feel smooth. The tiles had to look right. The input had to feel responsive. Most of Keith's interventions were in service of user experience — pushing past "it works" to "it works well."
The touchscreen has a hardware bug that forces a full-screen redraw every frame. Keith knew this from earlier work. This single fact, invisible to Claude, shaped every rendering decision in the project.
When Claude implemented slide animations, a dark background area would be revealed when a tile moved. The rendering of the now vacant spot was repaired on the next frame, but it was a jarring visual flicker. Claude proposed changing the board's color to match that dark background in order to eliminate the flicker. But doing so would also eliminate the visible grid lines between tiles, creating a significant aesthetic change. Keith rejected it. Claude then suggested layering sixteen static background objects behind the grid, but Keith pointed out this would add rendering overhead on an already frame-rate-constrained device.
Keith eventually proposed a targeted fix: create a temporary object behind a tile just before it starts moving. The temporary object covers up that dark background and then is removed as soon as it's no longer needed. This way it incurs zero cost at all other times. The solution required understanding the visual goal, the performance constraint, and the rendering architecture simultaneously — a kind of multi-dimensional judgment call that the AI repeatedly struggled to make on its own.
The game initially ran at 16 frames per second — technically functional but visually choppy. Keith treated frame rate as a user experience problem, not a technical curiosity. He suggested compiler optimization flags and pushed Claude to find solutions like increasing the CPU clock speed, double-buffered rendering, etc. He asked Claude to analyze where time was being spent per frame. When other animation effects caused more dark background flickers because the display couldn't render them fast enough, Keith made the call to remove them entirely rather than ship something that looked broken. Each of these was a judgment about what the player would actually experience, not just what the code could technically do.
Keith pushed the aesthetics well beyond "close enough." He provided a screenshot from the original 2048 app and asked Claude to match the font, identify the exact color palette from the original game's source code, tune the grid line thickness, adjust corner radii, and redesign the layout to match the app's proportions. These were things that Keith considered key presentation details, but Claude would never have pursued them without being asked.
Keith had set up rules preventing Claude from compiling code or pushing to GitHub without permission. This worked for GitHub operations — discrete, one-time events. But during debugging, Claude started running builds without asking, caught up in the momentum of fix-rebuild-test cycles. When Keith caught it, they had a productive discussion about why the guardrail failed. They replaced the (ineffective) self-policing mechanism with a simpler system that prompts Keith for every build. Less clever, but actually reliable.
Working successfully with it requires developing an intuition for where its behavior is reliable and where it isn't. Being new to AI, Keith is still running into unexpected problems (the "unknown-unknowns" gotchas) that require strategy shifts which themselves then lead to the next round of unpleasant surprises.
Without AI, the bottleneck would have been writing code. With AI, it shifted to wherever human judgment is still required. Writing less code didn't mean doing less work. The effort shifted from production to judgment.
Claude did about 90% of the typing. Keith made about 70% of the decisions that mattered. The project would have taken Keith a week or more without Claude. But it would have stalled at the first crash without Keith — someone who could look at the physical device, recognize what was wrong, and decide what to do about it. And even where it didn't stall, it would have stopped at "functional" — a game that worked but didn't feel good to play.
Neither party could have completed this project efficiently alone.