Can't Come Up With Enough Work to Keep YourAI Agent Busy? Here Is How I Fixed It.

Models got so good at understanding problems and executing that work that took hours now finishes in 10 to 15 minutes, making the human operator the bottleneck. I fixed that bottleneck by upgrading my autonomous task loop (goal-loop) with an upfront 5-question interview (grill-me) and four practices from my two-week session audit, AI agency founder Nick Saraev, and Anthropic's engineering team.

Why I became the bottleneck for my own AI agents

As soon as I step away from my desk to grab water, my coding agent has already finished the task and is sitting idle waiting on me. The AI is no longer my bottleneck. I am.

To see why I was spending so much of my day babysitting prompts, I audited two weeks of my Claude Code logs (1,402 sessions and 4,367 prompts from October 10 to October 24, 2026). Across those two weeks, 74% of my regular chat prompts (3,221 of 4,367) finished in under 5 minutes, and 92% (4,033 of 4,367) finished in under 15 minutes. My typical active run was 90 seconds before the agent stopped to ask what to do next. Whenever I gave a one-line prompt without a clear finish line or a self-test, I became the router between every small step.

How my autonomous task loop ran for 12 hours across 20 projects

Yesterday I used my autonomous task loop (goal-loop) to break that bottleneck. With 12 hours before my weekly model usage reset, I pointed goal-loop at my second brain (OpenBrain) and my past sessions to scan my projects in flight, pick the 5 highest-impact tasks, build and verify them, and repeat for 12 hours.

It finished 14 waves (70 verified goal-loop runs across 20 projects, closing or advancing 158 tracked tasks) while I worked on other things. In a separate 4-hour goal-loop run yesterday, I pointed the agent at my home-repair app (moHelp) and our local contractor directory (Greenville Home Pros) to fix bugs, improve mobile layouts across 169 pages, and ship bookable contractor claims (passing 77 tests on moHelp and 53 tests on Greenville Home Pros).

Across my two-week audit, switching from one-off chat prompts to goal-loop jumped median active work from 90 seconds to 26.4 minutes per task - a 17x increase - with single loops running nearly 3 hours (175.7 minutes) and chained waves running up to 12 hours.

Why my old goal-loop still stopped early 42% of the time

Coding agents now include a goal mode that loops until a check passes, but my two-week audit exposed a flaw in how my old goal-loop started. Because it started coding right away from a short prompt with an 8-pass cap (30 to 60 minutes), whenever my intent was fuzzy, 42% of my old goal-loop runs (20 of 48) still stopped early to ask me questions, and 19% (9 of 48) stalled at the 8-pass cap.

Today I watched a video by AI agency founder Nick Saraev ("What I'd Learn Instead of Prompt Engineering in 2027?") and reviewed Anthropic's engineering reports and Rob Shocks's breakdown of Claude Code's review loop. Nick calls this shift "role engineering" - managing an AI agent like a staff member rather than a search bar. Today I upgraded goal-loop by wiring in an upfront interview skill (grill-me) before the agent touches a file, and combined it with four practices from my audit, Nick's video, and Anthropic's team:

Four changes I wired into my agent loop today

Step 1: I have the agent interview me before it starts

Instead of guessing from a one-line prompt, my upgraded goal-loop runs a 5-question interview (grill-me) upfront before writing any code. It checks OpenBrain first so it never asks me a question my notes already answer, and then interviews me in one round to lock in five things:

1. My full outcome horizon: The entire chain of work I want finished, verified, and cleaned up.
2. A pass-or-fail test: The exact check the computer will run after every pass.
3. One finished reference example: A past file or run the agent must match in quality.
4. Hard boundaries: Which files, live services, or outbound messages are off-limits.
5. A multi-hour budget and pass cap: How many hours and passes (up to 30 passes across 2 to 8 hours) the loop can run on its own.

Clarifying my real intention, boundaries, and finish line upfront takes 2 minutes at my desk, and lets the agent work for hours without checking in.

Step 2: I lock a pass-or-fail test and one finished example

I do it once. In my two-week audit, 82% of my regular chat prompts (3,559 of 4,367) included no pass-or-fail check the computer could run on its own, and 99.8% (4,358 of 4,367) did not point to a finished example.

In his video, Nick points to Claude Code creator Boris Cherny at Anthropic, who had an agent rewrite the Claude desktop app over two weeks by launching both versions, taking screenshots, and comparing them pixel by pixel until they matched. Nick applies the same rule to tasks like getting a homepage to load in under 2 seconds on an iPhone display, and completes a new job once himself as the reference example. I now hand my loop one finished example I did myself and a test suite (such as our 138 unit tests on goal-loop) that the computer checks after every pass.

Step 3: I connect shared memory so it finds its own context

An autonomous agent cannot run for hours if it stops every 10 minutes to ask where a file lives or what I decided last week. Nick keeps a 50,000-record business memory of his emails, video transcripts, prior AI sessions, and project logs so his agents look up context on their own.

I connect my second brain (OpenBrain) to goal-loop the same way, including ingesting Nick's 13,964-character transcript and Rob Shocks's 19,619-character transcript today. Because goal-loop reads my past decisions and active projects from OpenBrain first, it answers its own context questions instead of stopping to ask me.

Step 4: I turn fixes into a checklist, and cap the loop

Nick runs a new job 5 to 10 times, compiles every correction he made across those runs, and tells the agent to update its own checklist so the mistake does not repeat. At the same time, an uncapped loop carries real cost and drift risks:

• Runaway token spend: Nick burned $2,500 in tokens in a single day running autonomous Claude sessions, so I route routine checks to smaller, cheaper models.
• Overnight review loops: In Anthropic's test of Claude Code's automated review loop, one pull request ran through 50 rounds of AI review overnight (with 59% of flagged items pointing to old code) before round caps were added.
• Shortcut drift without strict tests: Anthropic researcher Nicholas Carlini ran 16 parallel Claude agents across 2,000 sessions over two weeks ($20,000 in usage) to build a 100,000-line C compiler, showing that without strict tests and anti-regression checks, agents take shortcuts just to make a check pass.

To keep multi-hour runs safe, my upgraded goal-loop caps runs at 30 passes and verifies that existing tests do not regress.

Shifting from prompting every step to clarifying my goal upfront

• Clarify my intention before the loop starts: Wiring a 5-question upfront interview (grill-me) into my autonomous loop (goal-loop) fixed the fuzzy prompts that caused 42% of my old loops to stop early.
• Give the computer the test and the quality bar: Handing the loop one finished example I did myself and a pass-or-fail test jumped my typical run 17x (from 90 seconds in regular chat to 26.4 minutes per task, and up to 12 hours across chained waves).
• Connect shared memory and enforce a hard cap: Pairing OpenBrain with a 30-pass cap keeps agents working across in-flight projects for hours without burning $2,500 in a day or spinning through 50 rounds overnight.

When models can execute hours of work in 15 minutes, my job shifts from prompting every step to clarifying my goal upfront.

If your AI agent could work on its own for days, what problem would you give it?