What are Agentic Loops?

In one sentence

While agentic loops offer a futuristic vision of autonomous AI development, they currently function as a "slot machine" that burns excessive tokens and fails to capture the nuanced creative vision required to build a successful startup.

Why read this (and who it's for)

This summary is for founders, developers, and AI enthusiasts who are being flooded with hype about "agentic loops." It solves the confusion of whether you should let an agent run autonomously or keep yourself in the loop. After reading this, you will be able to distinguish between high-value autonomous tasks (like code review) and low-value "hallucination" traps (like building a full app via a single spec file).

The big idea

The central thesis distinguishes between two modes of AI interaction: Human-in-the-loop and Agentic Loops. In the standard human-in-the-loop model, you prompt an agent, it generates a result, and you review, test, and iterate. You are the governor; the agent is the laborer.

In contrast, an Agentic Loop is a system where the human fires off a spec (like a prd.md file) and the agent iterates internally—generating results, feeding them back into itself as feedback, and continuing until a goal is met. The author argues that this "autonomous" approach is currently a catastrophe for product building because no document can capture every nuance of a human's vision. When an agent is given the floor to make assumptions on those missing details, it will almost always get them wrong, leading to a finished product that doesn't align with your actual goals while burning a fortune in tokens.

Key ideas

Human-in-the-loop

What it is — A workflow where the human directs, governs, and allows things to happen. You prompt the AI, view the result, test it, and then provide the next instruction. Why it matters — It ensures that the product remains aligned with your vision because you are providing constant feedback at every iteration rather than just at the very end. In the book — The author describes this as the standard way we currently work: "You are communicating with an AI agent... and then a result is generated... usually what you and I will do is we will view this result, we will test this result, and we will keep on iterating."

Agentic Loops

What it is — A system where the human provides a task list (a spec) once, and the agent checks its own results, generates new iterations, and feeds those back into itself autonomously. Why it matters — It removes the human from the iterative process, which can lead to "hallucinated" product decisions and massive token costs. In the book — The author contrasts this with the human-in-the-loop model: "Instead of a human being in the loop, the human is in the loop one time... But then the rest of the time, it's the agent checking."

The Assumption Trap

What it is — The reality that no PRD (Product Requirements Document) or spec file can ever contain every detail, edge case, or evolving trend of a product. Why it matters — Because agents must make assumptions to fill in those gaps. If the agent makes those assumptions alone, they will likely diverge from your actual vision. In the book — The author uses an analogy of hiring a developer: "You tell this developer, this is the app we want to build... And the developer goes on and builds the entire thing without consulting us... Those assumptions might not be aligned with our product vision."

Token Burn vs. Research

What it is — The economic reality of running large loops. High-budget researchers can burn millions in tokens for experimentation, but most users cannot afford this. Why it matters — If you don't have "money to burn," trying to run complex agentic loops on a standard subscription plan is unproductive and will quickly deplete your usage. In the book — The author cites a specific example of a researcher who "burnt 1.3 million dollars worth of tokens" in one month, noting that while this is great for research, it isn't productive for most users.

Binary vs. Creative Tasks

What it is — The distinction between tasks with a fixed feedback loop (binary) and tasks requiring nuanced creativity (non-binary). Why it matters — Loops work when the goal is "either they did the job or they didn't." They fail when the goal requires subjective creative choices. In the book — The author suggests loops are great for SEO (generating 300 identical pages) or code review, but not for building a startup where you need to show the app to people for feedback halfway through.

Closed-off Feedback Engines

What it is — A specific type of loop that works because it has a fixed, defined feedback engine and a clear goal. Why it matters — This is the only place loops currently make sense: where the "success" criteria are clearly quantifiable (like a score). In the book — The author describes his own "grep loop" for code review as a "very closed off, very goal oriented loop."

Frameworks & tools

The "Grep Loop" for Code Review

Use this model to implement an agentic loop that actually works by constraining the feedback loop.

1. Setup: Connect your source control (GitHub) to a code review agent (e.g., Greptile, CodeRabbit, or Macroscope).
2. Define the Rule: Establish a "success" threshold (e.g., a score of 4 out of 5).
3. Initiate the Loop: Use a tool like Cursor and a command (like grep loop) to tell the agent: "Read the review, understand it, and get that score to a five out of five."
4. Automated Iteration: The agent reads the feedback $\rightarrow$ makes changes $\rightarrow$ pushes to GitHub $\rightarrow$ waits for a new review.
5. Termination: The loop continues until the score is met or a maximum number of turns (e.g., 5) is reached.

Memorable examples & stories

The Developer Analogy: You hire a smart developer, give them a spec, and they build the whole thing without consulting you. Because the spec wasn't perfect, they made assumptions that weren't aligned with your vision. Lesson: Agents making autonomous assumptions on an app will lead to a product you don't actually want.

The "Among Us" Simulator: The author built a simulator for AI models to see which were good at lying. He didn't care about the details, just that it worked. Because he didn't care about the nitty-gritty, the agentic loop (slash goal) succeeded in an hour. Lesson: Agentic loops are great for low-stakes experiments where you don't care about the specific details.

The $1.3 Million Token Burn: A reference to a researcher who spent over a million dollars on tokens in a single month. Lesson: High-level agentic research requires "money to burn," which most startup founders do not have.

Key quotes

"AI can replicate sauce, it can't create sauce." Why it matters: Highlights that loops can only repeat existing patterns; they cannot innovate on a product vision.

"Human-in-the-loop is the best loop." Why it matters: The most reliable way to ensure an AI tool stays aligned with human intent.

"It's going to burn a lot of money... if you don't have money to burn, that you are not to do it." Why it matters: A warning against the "hype" of autonomous loops for those on standard subscription plans.

How to apply it

This week

• Audit your tasks: List everything you want to build this month. Label each task as "Binary" (fixed rules) or "Creative" (nuanced vision).
• Identify Loop Opportunities: For every "Binary" task (e.g., generating 50 SEO descriptions, checking for specific bugs), try a slash goal style loop.
• Maintain Human Control: For any "Creative" task (e.g., designing the landing page flow), explicitly forbid autonomous loops. Stay in the loop.

Ongoing

• The "Score" Principle: When using loops, always provide a quantifiable success metric (like a score out of 5) so the agent knows when to stop.
• Chunking: If you use a loop for code review, ensure no push exceeds 1,000 lines of code, as agents struggle to contextualize larger chunks.

Common pitfalls

• The "Perfect Spec" Fallacy: Believing that your prd.md file is complete enough for an agent to build a whole app without you. It isn't.
• Token Exhaustion: Trying to run complex loops on a $20 or $100 monthly plan; these will burn through your usage instantly.
• The "Slot Machine" Trap: Expecting a loop to produce a perfect startup product in one go, only to find it made a thousand wrong assumptions along the way.

Connects to

• CodeRabbit / Greptile: Tools that provide the "fixed feedback engine" necessary for successful loops.
• Cursor: The primary harness used to execute these loops via specific commands like slash goal.

If you remember only three things

• Agentic loops are currently best suited for binary, constrained tasks (like code review or SEO) where success is easily measured.
• For building a startup, Human-in-the-loop is superior because it prevents the agent from making "hallucinated" assumptions about your product vision.
• Running large loops on an app level will burn excessive tokens and likely result in a product that doesn't match your actual needs.

Internalize it

• Reflection questions

  • Which parts of my current project are "binary" (fixed rules) and could benefit from an agentic loop?
  • In what ways has an AI agent made a "wrong assumption" on my product vision recently because I let it run too autonomously?
  • Do I have the token budget to experiment with large loops, or should I stick to human-in-the-loop for everything meaningful?

• Flashcards Q: What is the difference between Human-in-the-loop and Agentic Loops? A: Human-in-the-loop involves a human reviewing/iterating after every result; Agentic Loops involve the agent iterating internally based on its own feedback. Q: Why do agentic loops often fail when building an app? A: Because no spec file can capture every detail, and agents make incorrect assumptions to fill in those gaps. Q: What is a "binary" task suitable for a loop? A: A task with a fixed feedback engine where success is black or white (e.g., code review or generating 300 identical SEO pages). Q: What is the "Assumption Trap"? A: The reality that agents will make autonomous decisions on product nuances not specified in a PRD, leading to a misaligned product. Q: Why should most users avoid large agentic loops? A: They burn a lot of tokens and are often unproductive for nuanced creative work.

Fidelity note

Confidence is high. The summary captures the author's passionate distinction between "research" (high-budget loops) and "startup building" (human-in-the-loop). I have included the specific "Grep Loop" framework as it was the only concrete use case provided for a successful loop.