You’re probably skeptical. I would be too.
75,000 lines of code in 10 days sounds like either a lie or a mass of unusable garbage. Let me show you what actually happened.
| Metric | Value |
|---|---|
| Total lines of code | ~75,000 |
| Calendar days | 10 |
| Average output | ~7,500 lines/day |
| Projects shipped | 7 |
| Commits | 172+ |
| Project | Lines | Commits | Days |
|---|---|---|---|
| Game 1 (idle/clicker RTS) | 17,900+ | 62 | 3 |
| Game 2 (strategy) | 30,200+ | 77 | 6 |
| Game 3 (chess engine) | 7,200+ | 6 | 2 |
| Game 4 (2D character editor + scene system) | 9,100+ | 25 | 2 |
| Game 5 (arcade) | 3,300+ | 1 | 1 |
| VS Code Extension | 4,800+ | 2 | <1 |
| Website + Infrastructure | 2,500+ | 76 | ongoing |
These aren’t hello-world demos. They’re playable games with pathfinding, collision detection, UI systems, save/load, and enough polish that I’d let someone else try them.
December 2nd. I sat down to build an idle clicker game using an AI coding assistant.
The first thing that struck me was how naturally it responded to direction. Within an hour, I realized the complexity ceiling was much higher than anything I’d used before. The toys were fun to play with - and they felt prematurely polished.
By the end of day one, I had 10,000 lines in a single file. Pure vibe coding, just seeing how far we could push it. Then the context window filled up and I couldn’t send the whole project anymore.
That’s when the real work started - and it wasn’t coding. It was context management.
If you haven’t hit the wall yet, here’s what I mean: AI coding assistants have a context window - a limit on how much information they can hold at once. When your project fits inside that window, everything feels magical. The AI remembers what you said, understands how things connect, makes changes that actually work.
When your project outgrows the window, the magic breaks. The AI starts forgetting things. It makes changes that conflict with code it can no longer see. It confidently breaks stuff it fixed yesterday.
So you have to get strategic. What files does the AI actually need to see for this task? What context can you leave out? How do you structure your code so each piece is self-contained enough to work on independently?
This is the skill that matters. Not prompting. Not “talking to the AI the right way.” It’s understanding what information the AI needs, and organizing your project so that information is accessible when it’s needed.
When I started modularizing - extracting systems into their own files, refactoring the mess I’d created - something clicked. And when those modules got documented, things clicked again. The documentation became part of the context. It reinforced the language we used to talk about the code.
The AI navigated the growing codebase gracefully. It kept track of where things lived, how they connected, maintained consistency across dozens of files. Because I’d structured things so it could.
But it still couldn’t make decisions for me.
On day three, I wanted pathfinding for the RTS. I knew A* well enough to explain it, but wasn’t sure we’d get there. The AI suggested flow fields instead - a more sophisticated algorithm I didn’t know.
I agreed. That was a mistake.
Something was wrong with how units moved. I kept asking for pathfinding fixes, and the AI kept patching things. But nothing improved. After too many iterations, I realized the bug wasn’t in pathfinding at all. It was collision detection. I just couldn’t see it because I was debugging an algorithm I didn’t understand.
The lesson, if you’re trying this yourself: don’t let the AI pick algorithms you can’t debug.
I scrapped the flow field and asked for simple A* on tile coordinates. Worked immediately.
Less than I expected, honestly. But there were patterns worth knowing about.
Lua has a 60-local-variable limit per function. The AI kept adding variables without tracking the count, and functions would silently break. I’d notice behavior diverging from what I asked for, dig in, and find the real cause. Sometimes the AI had worked around the limit by duplicating code instead of refactoring.
Every large project went through at least one major refactor. Loose disciplines accumulated until they couldn’t be ignored anymore. If you look at the commit logs, you can see exactly when things got cleaned up.
The pattern: build fast, hit walls, refactor, build fast again.
If you’re wondering whether you could do something like this, here’s the part that might actually help you.
Everything changed once I figured out the project management layer. The structure is simple: Issue → PR → Release. Standard agile, but streamlined for one person working with an AI.
In one 45-minute sprint planning session, we generated around 30 issues for the strategy game. That’s several days of work, queued up and ready to go.
The rhythm: pick an issue, let the AI work, monitor progress, request changes, test builds, decide what’s next. The AI could work autonomously for 20-40 minutes at a stretch. Sometimes I’d be testing a previous build while it worked on the next feature.
What surprised me was how rarely I needed line-by-line instruction. Most conversations happened at the function level:
“Do you have a function that handles X?”
“Can you write a pure function that takes X and returns Y?”
Those well-defined interfaces became anchor points for the whole codebase. Places where both of us understood exactly what was supposed to happen.
I should be honest about where I’m coming from: 10 years as a professional software engineer. Another 30 years of hobby game development. I’ve shipped an indie game on Steam– built the old fashioned way.
But I still think most people can learn to work this way.
Maybe not a full RTS in three days. But definitely more than the Python scripts and build configs you see passed around as examples of “AI coding.”
The skill isn’t coding. It’s knowing what to ask for, recognizing when something isn’t working, and having the judgment to scrap an approach before you’ve wasted too much time on it.
Those are learnable skills. You probably have more of them than you think.
I don’t know what six months of this looks like.
I don’t know what happens at 100,000 lines. Or 200,000. I don’t know where the ceiling is, or if there is one.
What I’m starting to believe is that with the right level of modularity, you can connect anything. Build systems that scale further than feels reasonable.
But I haven’t proven that yet. I’m still finding out.
More games. More tools. Shipping faster.
If you want to follow along as I figure this out: