February 2026. One sentence from a coworker woke up a development life that had been asleep for three years.

I was clueless about dev communities when a coworker casually dropped this on me:

"Have you tried Claude Code?"

The AI I'd only ever used in a browser was apparently coming inside my own machine. I tried it half-skeptical, and the result floored me. A development life I'd shelved for three years started turning again. Here's that timeline.

Part 1. It started with text files

A poker game I'd shelved for three years

About three years ago, I was building a poker game — an idea I'd only ever kept in my head — together with ChatGPT. The version back then was 3.5, "Prometheus" if I remember right. It was impressive, but development was slow. I moved to Claude, which had a reputation for being unmatched at coding, and kept going — until I hit a wall you just can't get past over a browser. So I shelved the project again.

Then my coworker told me about "Claude Code." The AI came inside my machine, and my development speed changed dramatically.

And in those early days, I managed everything in plain text.

last Axxx  addition number
last B001  bug number
c   client-side (suspected)
s   server-side (suspected)
cs/sc  both, or unsure which side

[bug pile]
B001, cs, after phase-7 betting ends, the hi-lo selection dialog never appears and it freezes

It may look crude, but it was my own management system.

Pain ①: "5 hours, weekly limit reached"

Claude's usage limit came fast. While hunting for an alternative, I found GitHub Copilot. Interestingly, it calls various models via premium requests. The Pro plan got me 300 of them.

Claude Pro $20 + Copilot Pro $10

Pain ②: "Premium requests used up"

300 ran out quickly too. While figuring out how to keep working on free models (back then GPT-4.1 and 5-mini were free), I remembered something I'd once glanced at without thinking — the AI generating md files. That trivial thing I'd ignored turned out to be the answer.

"Ah — I can leave it as a design doc."

While Claude and Copilot were still alive, I started building a design-doc factory that even free models could mass-produce.

# Control.gd function map (reference for whoever writes the work order)

**Purpose**: quickly check "what functions exist, what they do, where they're called"
**Target file**: client/.../Control/Control.gd

## A. Game-flow functions (in call order)
| Function | Line | Role | When called |
|----------|------|------|-------------|

Naturally, the design docs a free model spits out had their limits, so I ended up upgrading to Copilot Pro+.

Claude Pro $20 + Copilot Pro+ $40

Ahh… comfortable. Pro+ gives 1,500 requests. Design handed to Claude, work done with Copilot. Efficiency shot up.

Pain ③: Managing a "family" of workers in text

As workers multiplied, text management got unmanageable. So I introduced an "index." And instead of managing it myself, I gave the workers an instruction:

"Log it."

## current logged items
| ID | item | status | notes |
|----|------|--------|-------|

All I had to do was give instructions. No longer managing it myself — the workers managed it themselves. Much easier.

From the moment I learned about "Claude Code," it took just one or two months to go from text management to index delegation. I finished the game that way, built a homepage with my AI team, and launched in May. (👉 horriblegames.net — not a sketchy site, just a poker game demo.)

Pain ④: Indexes scattered everywhere

Then it hit me. The index files were scattered all over — and the bigger problem: AI is not consistent. No matter how many times I gave it the formatting rules, it wrote things however it pleased.

So I built an [index numbering tool] — register a command and it auto-fills the index. I used this right up until FlowGate was born.

But the numbering tool had limits too: I had to manage presets every time, and if they weren't registered right it threw errors or the AI couldn't use it properly. So — I decided to just turn it into a system.

And that's how FlowGate was born.

Part 2. The AI's lie

Using FlowGate doesn't mean the AI stops lying. It just means — how many times it lied gets left behind as evidence.

Frustration, and no evidence

Something I learned building the poker game: the backend does fine once you nail the data flow, but front-end / on-screen bugs? It genuinely can't fix them.

"That's not it — ugh, so frustrating."

I can't remember how many times I said that. Why? Because there was no evidence. Only the memory of having said it remains; what the AI actually changed, and why it still didn't work, is gone. All that's left is the memory of telling it "this isn't working, route around it, do it this way."

I built FlowGate, and I'm still frustrated

FlowGate being finished doesn't mean it fixes the bugs it couldn't before. But two interesting things appeared.

First, evidence remains.

You can confirm things in conversation as you go, but just like you forget today what you did yesterday, if nothing is left behind you can't know yesterday. But the evidence I leave through FlowGate stays. So a difference emerged:

• Before: "I have to solve this before moving on."
• Now: "I don't have to solve it today — I can solve it tomorrow."

FlowGate's action-bar SSE bug took three days. Before, I'd have had to leave a file somewhere to pick it up again; now I can just go "eh, I'll cut it here."

Second, I can see how many times it got rejected.

That SSE bug — 11 rejections on investigation, 13 on the work itself. Before, I'd just vent in chat; now I can count how many times I got angry… just kidding 😅 — it means I can now explicitly judge when to stop trying the same approach and switch to a different one.

Usually if the same method fails 2–3 times, try another; if a different method fails 4–6 times, try yet another… The SSE bug got caught by chance after exactly those counts, and as I recall it was a conditional-branch bug + a deploy issue working together. Either way, I can now directly count how many times I attempted a given task.

Conclusion

FlowGate doesn't stop the AI from lying. Instead:

• Evidence remains → I can defer work and still pick it back up
• Rejection counts are tracked → I can judge when to switch approaches
• And… I can even count how many times I got frustrated

From a single text file, to an index, to a numbering tool, and finally to a system. This is a four-month record of trying to close the gap between "the AI says it's done" and "it's actually done."

👉 FlowGate: github.com/horrible-gh/FlowGate