One engineer burned $1.3 million worth of tokens in a single month running AI agent loops.
Not a typo. $1.3 million in 30 days, and half of tech Twitter looked at that and said "I want to do that too."
Greg Isenberg just sat down with Ross Mike (Professor Ross Mike on YouTube) on the Startup Ideas podcast to answer the question every founder is quietly Googling right now: what is an AI agent loop, and should I be using one?
Ross's answer is the most honest take I've heard on this. Short version: loops are real, loops are the future, and if you build one today to ship your SaaS, you're going to torch your token budget and get a product you didn't ask for.
Here's the full breakdown, with the one loop Ross actually uses every day (this part is gold).
What an AI agent loop actually is
Ross opened with $3 stick figure diagrams (his words, and honestly they worked).
The way you and I build with AI right now is called human in the loop:
→ You prompt the agent ("build me a landing page")
→ The agent generates a result
→ You look at the result, test it, and prompt again
You're the checkpoint. The agent builds, but you direct, govern, and approve every step. Landing page first, then auth, then the backend. One piece at a time.
An agentic loop removes you from that cycle.
You write one big spec file (a PRD.md, a task list, whatever), fire it off once, and then the agent checks its own work. Result feeds back into the agent. Agent keeps building. You come back hours later to a "finished" product.
That's the thing Boris and Peter at Anthropic have been talking about. They say they don't write prompts anymore, they build loops.
Sounds like the future. And it might be. But Ross's whole argument is about who can afford to live in that future today.
Why Ross says most founders shouldn't touch loops yet
Ross's analogy is the best explanation of the problem I've seen.
Imagine you and I are building a startup. We hire a very smart developer, hand them a spec, and tell them: build the whole thing. Don't call us. Don't ask questions. Just ship it.
That developer is going to make hundreds of assumptions. How the product looks. How it feels. Architecture decisions. Edge cases your spec never mentioned (and your spec ALWAYS misses something).
They come back with a finished product. And it's not what you wanted.
That's an agentic loop. Except the developer also bills you per token.
Ross runs a dev agency, so he sees this daily with actual humans: "We try all the time to get all the thoughts out of someone's head. There's always something. How much more do you think an AI agent is going to understand you if we as humans have hard times understanding each other?"
Two problems, in his words:
→ Loops burn tokens like crazy. Ross was blunt: if you're on a $20/month plan, or even the $100 plan, don't even think about it. This is $200/month plan territory minimum. And the people evangelizing loops (Boris, Peter) have effectively unlimited token budgets. Peter's own tweet showed $1.3M of token burn in one month. If I had unlimited tokens I'd build loops all day too.
→ Your plan document is never as good as you think. You cannot contextualize every detail of a product you can't fully visualize yet into one markdown file. Things change mid-build. One day liquid glass UI is cool, the next day you want it different. The loop doesn't know that. It just keeps going.
Greg's analogy: it's full self-driving from Miami to Charleston. You pressed go. You see a cute diner off the highway and want a fried chicken sandwich? Too bad. The train has left the station.
/goal, /loop, Ralph loops: all the same thing
If you've seen /goal trending, or /loop on Cursor, or the Ralph Wiggum loops from a few months back, Ross's take: they're all the same construct with different names.
You type the command, attach a markdown file, and tell the agent "build this entire thing, don't stop until you're done, don't make mistakes."
They're great for exactly one thing: experiments where you don't care about the details.
Ross's example: he was giving a talk and wanted an Among Us simulator for AI models. A benchmark to test which models are good at lying (one impostor, everyone guesses). He didn't care how it looked. He fired off a loop and it was done in about an hour and a half.
A bunch of details came out wrong. Didn't matter. He didn't care about the details. That's the point.
The problem starts when you care. When it's your actual product, with paying customers and a vision that lives in your head. Ross put it in one line I keep thinking about:
"AI can replicate sauce. It can't create sauce."
The one loop Ross actually uses (steal this)
This is where the episode flips, because Ross isn't anti-loop. He runs one every day. It's his code review process, and it works because the feedback is fixed and measurable.
Here's the setup:
→ Ross builds in Cursor, pushes code to GitHub
→ Greptile (a code review agent, similar to CodeRabbit) automatically reviews every push
→ Every review gets a score out of 5
→ Ross's rule: nothing ships to production under 4/5
When a push scores a 3/5, he types one command in Cursor: Grep loop. It's a skill that tells the agent: read the Greptile review on GitHub, fix everything it flagged, push again, wait for the new review.
New push triggers a new review. Still 3/5? Loop continues. Hits 4/5? It keeps going for 5/5. The loop stops when it scores a perfect 5 or after 5 turns, whichever comes first.
Why does this loop work when the "build my whole app" loop fails? Because the feedback loop is closed and the goal is binary. There's a scoring engine. There's a definition of done. The agent isn't guessing what Ross wants; it's chasing a number.
Even this loop breaks, though. Ross said anytime he pushes more than 1,000 lines of code, he can almost never get a 5/5. Too much code for the reviewing agent to fully contextualize. So he keeps every push under 1K lines, or tells Cursor to split the work into multiple PRs.
That constraint alone is worth the whole episode. Loops don't remove engineering discipline. They demand more of it.
Where loops make sense (and where they don't)
Greg's framework at the end tied it together: loops work where the output is binary. Did the job get done or not, with no creativity required.
Good fits today:
→ Code review (score-based, defined done state)
→ Programmatic SEO (you have a formula, you want 300 pages that all follow it)
→ Throwaway experiments (Ross's Among Us benchmark: fast, cheap on attention, details don't matter)
Bad fits today:
→ Building your actual product
→ Anything where the vision lives in your head and evolves as you see the work
→ Anything on a $20/month token budget
I run AI agents across my own business (content, clipping, outreach), and this maps exactly to what I've seen. The automations that work are narrow, with a measurable definition of done. The "go build the whole thing" prompts produce confident garbage. If you're automating parts of your business right now, this guide to business automations makes the same point from the operations side: constrain the task, define done, then let it run.
Both Greg and Ross agree on the ending, by the way. Fully autonomous loops WILL work eventually. Ross said "100%." Just not as of the recording (June 9, 2026). Right now, in his words: "Human in the loop is the best loop."
If you want to go deeper on setting up your stack for this stuff, I broke down Greg's AI-native masterclass here. And his Codex Sites playbook is basically a loop done right for content.
FAQ
What is an AI agent loop?
An AI agent loop (or agentic loop) is a setup where an AI agent checks its own output and keeps working without a human approving each step. You give it a goal or spec once, and the result feeds back into the agent automatically until the task is done. It's the opposite of human in the loop, where you review and re-prompt after every generation.
Are AI agent loops worth it for founders?
For building your product: not yet. Loops burn large amounts of tokens (one Anthropic engineer's usage hit $1.3M in a month) and make assumptions your spec never covered. They work today for narrow tasks with binary outcomes: code review with a scoring agent, programmatic SEO at scale, and throwaway prototypes where details don't matter.
What's the difference between /goal, /loop, and Ralph loops?
Nothing meaningful. They're the same construct with different names across tools: a command that tells the agent to keep working from a spec file until the job is done, without stopping to ask you. Ross Mike's take is they're all great for experiments and dangerous for real products.
How does Ross Mike's code review loop work?
He pushes code to GitHub, where Greptile automatically reviews it and scores it out of 5. Nothing ships under 4/5. A "Grep loop" skill in Cursor reads the review, fixes the flagged issues, pushes again, and repeats until it hits 5/5 or 5 turns. It breaks past 1,000 lines of code per push, so he keeps PRs small.
The founders actually shipping with AI
Every week on the Profitable Founder Podcast I talk to bootstrapped founders making $100K to $10M a year, and more and more of those conversations are about exactly this: which AI workflows are real and which are token bonfires.
Real numbers and real stacks, from people who pay for their own tokens.
