From Impossible to Done in Three Months: Building a Game with LLMs

The Original Idea

One day, I had a simple question: Could Copilot just write a game for me?

I knew the honest answer was no—at least not through a single massive requirements dump. Games have too much nuance, and UI is where most LLMs stumble. But what if I approached it differently?

I started researching game engines that LLMs had actually seen in their training data. Godot kept coming up as approachable and well-documented. I decided to test it: could I ask Claude to help me build a simple grid-based system without touching the editor?

Turns out, Claude was trained on enough Godot documentation to do exactly that. More importantly, it got better with each request.

And that's how Glyph Gambit was born.

The Failure That Led to Success

This wasn't my first rodeo with game development. A few years prior, I'd attempted to build this same game idea (chess + Dark Souls + roguelike) in GameMaker. I'm a professional software engineer with nearly a decade of experience, so the GML scripting language was natural enough. The problem wasn't the language—it was coordination.

I couldn't figure out how to connect the dots between my scripts and the editor work. Copy-pasting chunks of code went only so far. Without better tooling (or AI assistance), it felt hopeless. The project died.

At the time, Copilot integration with agent models either didn't exist or wasn't mature enough. LLMs were good, but not this good.

The Stack That Changed Everything

Fast forward two years. My toolkit had evolved:

• VSCode with Copilot extension
• Claude agent models (with terminal access, workspace viewing, file editing)
• Linux OS for frictionless dependency installation
• A growing intuition for how to talk to AI

Each month, the results got better. The models got smarter. The workflow tightened. By the time I decided to resurrect Glyph Gambit, the timing felt right.

The Key to Three-Month Success: Iterative Prompting + Tight Testing

Here's what doesn't work: handing an LLM a 50-page requirements document and expecting perfection.

Here's what does: tight iteration cycles with human validation at every step.

The Battle: UI Hell

The first real challenge was UI. I never opened the Godot editor—a constraint I'd set for myself—but this meant fighting with generated UI code constantly.

• "Why is this text cut off?"
• "Why won't my controller select these buttons?"
• "Why do you have no idea what I'm trying to accomplish?"

The turning point came when I realized specificity matters more than directness.

❌ "The text is getting cut off, please fix it"
✅ "The text is getting cut off on the right side on smaller screens like the Steam Deck. The text needs to respect screen boundaries."

With context, Claude could actually solve the problem instead of guessing.

In retrospect, doing some UI design in the editor first, then having LLMs code against that design, might have saved time. But iterating around it worked—just required patience.

Model Selection: Haiku Did 90% of the Work

Most of Glyph Gambit was built with Claude Haiku 4.5. Why? It's fast, cheap, and surprisingly capable. It nailed what I wanted ~90% of the time on the first try.

The other 10%? Refined prompts, developer intuition, and occasionally switching models.

Important caveat: These models train on older data. For cutting-edge information, you need to ask them to search the web—though this can be spotty with Copilot agents. For latest Godot semantics or framework changes, ChatGPT works better because it automatically knows when to look things up.

The lesson: know your tool's limitations and switch when needed.

Asset Generation: Consistency Through Reference

Asset generation was tedious until I found a pattern that worked.

Using ChatGPT + DALL-E:

1. Be explicit about technical specs. "PNG with transparent background" > vague descriptions
2. Provide reference images. When ChatGPT botches an edit, feed it the original again. It works better with visual context
3. Use style guides. Include multiple previously generated assets in the request so it understands the visual direction
4. Accept imperfection on specs. ChatGPT struggles with exact resolution requirements but excels at transparency and consistency

Pro tip: consistency across assets matters more than pixel-perfect resolution. Give it guardrails and it'll stay in lane.

The Workflow That Actually Shipped a Game

This is the process that worked:

1. Scope small. One feature at a time, not ten
2. Prompt, test, commit. After every change, push to GitHub (your safety net)
3. Be specific when it fails. "It's broken" → why is it broken? What did you expect?
4. Use logs as debugging aids. If Claude can't figure it out, ask it to add debug logging. Run it again. Iterate
5. Repeat until done. It's exponentially faster than manual coding

The result: a fully functional game in three months with:

• Complex grid logic
• AI opponents with adaptive difficulty
• Animation systems
• Full controller support
• Polished asset integration

The Real Lesson

You can't skip human judgment. You can't dump everything on the LLM and walk away. But with a disciplined workflow, specific communication, and tight testing loops, LLMs can compress what would be months of solo development into weeks.

The game isn't written by AI. It's written by a human using AI as a force multiplier.

The difference matters.

Interested in the Game?

If this workflow and approach interests you, we'd love your support! Glyph Gambit is coming December 8th. If you enjoy roguelites, chess mechanics, and the challenge of Dark Souls-inspired gameplay, consider wishlisting it on Steam. Your support means everything to indie devs building with AI.

Wishlist Glyph Gambit on Steam

TL;DR

• LLMs can't build games in one shot, but they excel at iterative, scoped development
• Specificity beats vagueness every time
• Small, testable chunks compound into complex systems
• Version control is your safety net—commit frequently
• Know when to switch models (Haiku for speed, ChatGPT for cutting-edge info)
• Asset consistency > perfection
• An engineer's intuition still matters—use it

Glyph Gambit proved you don't need to pick between speed and quality. With the right workflow, you get both.