Why I’m Building A Game With Only a $20 AI Subscription

Today is Day 4 of this project.

I’m building a solitaire-style card game inspired by Disney Solitaire — but with one major constraint:

Every line of code is written by AI.
Specifically, Claude Code… on a $20/month plan.

That means:
I hit rate limits.
Almost every day.
And I expected that going in.

This isn’t a speedrun. It’s an experiment in:

• how far AI can go
• how clearly I can communicate
• and how much structure matters when the AI is doing the typing

What I’ve Done So Far

Day 1

I started by asking ChatGPT to analyze Disney Solitaire from a game design perspective:

• what rules it breaks
• what feels unfair
• how monetization warps difficulty
• and why some levels are effectively unsolvable

I took that analysis and used it to guide Claude in generating a design document (claude.md).

From a blank Godot project, Claude:

• built a basic UI
• created card meshes
• generated face card graphics
• implemented the core ±1 solitaire rules
• added a highlight system showing playable cards

I also hit a lot of problems:

• cards spawning at the wrong orientation
• undo breaking and being re-implemented
• cards thinking they were blocked when they weren’t
• Claude stacking cards backward
• nodes disappearing in the editor
• Claude ignoring my rule that nothing should be generated at runtime

All of that came down to one thing:
I wasn’t explaining the system clearly enough yet.

Day 2

I discovered the active card and deck were using different meshes and materials.

Claude had quietly decided to:
programmatically recolor things at runtime
instead of using the scenes I had defined.

So I changed my strategy:

• separate scenes for each card type
• explicit materials for front and back
• a main game scene
• each level as its own scene
• board and deck as children

Then I built a tiny example scene myself (took about 30 minutes) and used it as a visual reference for Claude to understand:
how cards should layer
and how covering rules should work

This game allows multiple cards to partially cover one card
(4 cards can each block ¼ of a card)

That led to:

• a full refactor
• a bug where everything was playable
• more prompt tuning
• more orientation fixes
• overlapping cards
• undo breaking again
• wild cards added
• streak bonus logic added

By the end of Day 2:
The core rules worked
and Claude generated a plan for a level-building plugin.

Day 3

Claude reviewed all the design docs and started implementing the plugin.

I hit:

• inferred variable errors
• disappearing debug output
• layer counters not resetting
• state tracking bugs

I interrupted and corrected Claude multiple times:
“No, don’t discard the layer data — track all placed cards.”

Eventually:

• cards could be placed visually
• layers worked
• I added an editor preview indicator
• placement logic stabilized

At this point:
The rules are mostly done.
The plugin works.
Levels can be built visually.

There’s no background yet.
No animations.
Just cards floating on an invisible board.

But the system is real.

Day 4 (Today)

Today I:

• improved the plugin
• built Level 1 and Level 80 from Disney Solitaire in Godot using the plugin
• modified the tool to build Level 2 more easily
• added arc placement for patterns (S-shapes, circles, half arcs)

Then I ran into a warning that I was at 80% of my weekly rate limits. If I hit that today, I have to go 3 more days before it resets.

My goal next:
Build a few more levels (5, 10, 20) from Disney Solitaire, while matching the cards on the board and recording what's available in the decks for each level.
Then have Claude analyze them to design a system that:

• chooses suits and ranks for the board and deck
• controls difficulty
• manages wild cards
• adjusts streak rewards
• and scales challenge gradually

I’ll be recording:

• the game
• the boards
• the decks
• and the patterns used

That way, even if I hit the limit, I'll at least be able to build a few levels using this system that I have Claude build.

The Rate Limits Are Part of the Process

I hit my usage limit every day.

Not because I’m reckless — but because:
I’m using a normal subscription
and doing real work with it.

When the limit hits, I can’t code.

So I:

• clean
• cook
• walk
• think
• plan
• write
• redesign systems in my head

Yesterday I had 2.5 hours waiting for reset:
I washed dishes
made biscuits and gravy
and realized this project itself could become the product.

That pause is where:

• the plugin idea came from
• the difficulty system idea formed
• the subscription concept clicked

AI builds fast.
But thinking still takes time.

What This Project Really Is

This is not just:
“watch me make a game”

It’s:
watch me learn how to talk to AI clearly enough that it can build what I mean

The skill here isn’t typing prompts.

It’s:

• defining systems
• correcting mistakes
• narrowing scope
• making rules explicit
• steering instead of retrying
• designing inside constraints

That’s what I’m documenting.

And that’s what I’m turning into a subscription.