My AI Bottleneck Wasn't Tokens. It Was Finishing.

For a long time, I assumed my limits with AI coding were about token windows, model reasoning, or prompt technique. Then I audited my actual usage across Claude Code, Codex, and Gemini CLI on two machines.

The audit revealed over seventy open threads in a single month. Most of them were either effectively done and simply never closed, or quietly stalled waiting for decisions. The bottleneck was not token limits or model intelligence. It was finishing: deciding what was worth completing, reviewing, shipping, and closing the loop.

Here is what building a personal flow board for my AI threads taught me about turning generative speed into business impact, and why the flow coaching has to come from you.

Some of it is. A lot of it isn’t. And for a while I couldn’t tell you which was which.

I run several AI coding agents across a desktop and a laptop. On any given week I’m starting threads constantly: a skill here, an automation there, a research dive, a quick fix. It feels productive. The tools are fast and the screen is always busy. But busy isn’t the same as done, and for months I had no honest way to tell the two apart.

Here’s the uncomfortable thing AI did to my work: it made starting almost free. A year ago, starting a piece of work carried friction, and that friction quietly rationed how much I took on. Now I can open a thread and have real momentum in thirty seconds, so I do, again and again, far more often than the old friction would ever have allowed.

What AI did not make free is finishing. Deciding something is actually worth doing, reviewing it, shipping it, learning from it, closing the loop: that part still costs what it always did: judgment, attention, follow-through. So the bottleneck moved. It’s not in the typing anymore; it’s in everything around the typing. And when starting is free and finishing isn’t, you don’t get more impact: you get a pile of half-finished threads. That’s my real AI bottleneck. Not tokens, though yes, I run out of those too. The constraint is threads I started and never carried to an outcome.

This is what I mean by AI activity theater: the gap between how much AI activity we generate and how much impact actually lands. The theater isn’t fake work. It’s real work that never reaches an outcome, which from the business’s point of view is almost the same thing.

Flow has a first principle: you can’t manage what you can’t see. A bottleneck stays a bottleneck precisely because it’s invisible: work piles up somewhere and nobody is looking at the pile.

My AI threads were exactly that invisible pile: scattered across three tools and two machines, with no shared view, so I genuinely did not know how many open threads I had. So I did the obvious thing and started one more thread, this time to build the thing that would show me all the others.

Over a couple of evenings, working with my AI agents, I built a personal kanban board for my AI work:

• It scans the native session history of all three harnesses, on both machines, and pulls every meaningful thread into one registry.
• It classifies where each thread stands (intake, specifying, planning, implementing, review, done) and flags the ones that are blocked or aging.
• It renames threads from activity to outcome. “Create a skill for resharing posts” becomes “A streamlined way to reshare curated links so more of my POV gets out there.” That reframing alone changes the conversation.
• It suggests the next step for each open thread (a concrete, paste-ready prompt to move it toward done) and surfaces the threads that are already shipped and just never got closed.
• It has work-item aging built in. Of course it does.

The numbers it showed me on day one were the real product. More than seventy threads opened in a single month, about thirty of them effectively done (shipped, decided, finished) and simply never closed. Several others were genuinely abandoned, and items sitting in intake had been there a median of two weeks. The one that stung most: of seventy-plus sessions, exactly one used “plan mode,” the deliberate stop-and-think-before-acting step. The discipline I’d have assumed I had, I wasn’t actually practicing, and the data said so plainly.

Most of my cognitive load wasn’t from unfinished work. It was from ambiguity. A thread that’s actually done but never marked done costs you almost as much as one still in progress, because every time it crosses your mind, you have to re-decide what it is. Naming and closing things isn’t bureaucracy. It’s how you stop paying rent on them.

Reframing from activity to outcome is a filter, not just a label. When a thread is named by its activity (“build X”) finishing it always sounds worthwhile. When it’s named by its intended outcome, some threads quietly answer their own question: that outcome doesn’t actually matter enough. Stop starting, start finishing… also means stop keeping.

And the one I keep thinking about. My AI agent built me a kanban board that, at first, didn’t follow flow principles at all. No left-to-right value stream. “Blocked” treated as a column instead of a condition. No real policies. This is an agent with access to years of my writing about flow and kanban, and it still didn’t apply any of it, until I explicitly coached it to. Left-to-right flow. Blocked as a flag on the card, not a place. Aging thresholds. A real definition of workflow.

The lesson isn’t “AI is dumb.” The lesson is that AI gives you enormous leverage on activity, and almost none on judgment: unless you deliberately bring the judgment and teach it. It will happily help you do the wrong thing faster, or build the right thing in the wrong shape. The flow coaching has to come from somewhere. If it doesn’t come from you, it doesn’t happen.

For your own work: do the audit. Honestly: how many AI threads have you started this month, and how many reached an outcome? If you don’t know, that not-knowing is the finding. Make the pile visible first. Then bring the boring, durable flow discipline you’d give any team: limit how much you start, finish before you start more, and be willing to kill the threads that an outcome-framed name reveals you don’t actually care about.

For your teams and your organization: this same dynamic is about to play out at scale. AI lets everyone on your team start more: more prototypes, more analyses, more drafts, more automations. If you don’t build the system that pulls all that activity toward outcomes, you don’t get a more productive organization. You get activity theater with a bigger cast.

So the questions I’d sit with:

• Where is your AI activity getting stuck on the way to impact, and would anyone notice if it did?
• Who is the flow coach in your corner: the one helping you and your teams stop starting and start finishing?
• And how are you training your AI itself to notice bottlenecks (human or AI) instead of just generating more activity?

My board didn’t fix my discipline. It made my bottleneck impossible to ignore, and it hands me a next step every time I look at it. That turned out to be most of the battle.

The 3-Step AI Thread Audit

1. Shipped / Done: Finished work that was never marked closed -> Close immediately.
2. Waiting on Decision: Stuck on an ambiguous outcome -> Decide: advance or delete.
3. Abandoned / Stale: No longer worth the cognitive rent -> Kill deliberately.

Prompt for Auditing Open AI Threads

Inspect my recent AI threads and sessions.

For each active thread:
1. Reframe its title from activity ("build X") to intended business outcome ("enable Y so that Z").
2. Determine its actual state: Shipped/Done, Blocked on Decision, or Stale.
3. Suggest the single smallest next prompt to either finish it or kill it.

Do not suggest starting new work until in-flight threads are resolved.

Your AI probably isn’t out of tokens. Ask whether it’s out of flow.