Big Idea

The argument in one line.

Designing loops that prompt Claude is the natural successor to typing prompts yourself — it moves your role from being the engine to being the architect, with exit conditions as the only thing you have to get right.

Who This Is For

Read if. Skip if.

READ IF YOU ARE…

You use Claude Code daily and still find yourself watching it work, then typing the next prompt by hand after each step.
You want Claude to handle complete feature cycles — implement, code review, build, browser verify, PR, merge — without touching the keyboard.
You run recurring tasks (issue cleanup, content scraping, carousel generation) that could run on a schedule instead of on demand.
You are comfortable with Claude Code slash commands and GitHub and want to move to agent-level autonomy.

SKIP IF…

You have never opened Claude Code — this assumes basic familiarity with its slash commands.
You prefer conceptual introductions; this is almost entirely live screen demo.

TL;DR

The full version, fast.

Prompting Claude Code one step at a time is the old workflow; designing loops that do the prompting is the new abstraction. A polling loop runs on a cron, watches for new work, and clears it automatically — the video demos a 2-minute issue-watcher that reads a GitHub issue, implements a fix, verifies the HTML, merges the PR, and closes the issue without a single typed prompt. A dynamic run is a one-shot pipeline that chains three inner loops — code review until zero findings, build/lint until green, Chrome verify until all spec items pass — then commits and merges when all gates are clear.

Free for members

Chat with this breakdown — free.

Sign in and you get 23 free chat messages on us — ask for the hook, quote a framework, find the exact transcript moment, generate a markdown action plan. Bring your own key when you want unlimited.

Create a free account →

Chapters

Where the time goes.

00:00 – 00:36

01 · Cold open — authority hook

Boris Cherny clip and Steinberg tweet establish the loop thesis.

00:36 – 02:01

02 · Real-world loop examples

Instagram reel scraper rewrites transcripts in brand voice every 2 minutes; carousel builder ships 5 passes with no direction.

02:01 – 02:48

03 · What is a loop?

Diagram contrasts old prompting model (you are the engine) with loop model (loop prompts Claude, Claude works, loop checks, repeats).

02:48 – 04:43

04 · Two types: polling vs. dynamic

Polling loop runs on a clock forever; dynamic run is one unit of work with nested inner loops (code review, build, chrome verify).

04:43 – 08:54

05 · Polling loop demo — GitHub issues

Live demo: /loop command, 2-min cron, footer mailto issue created, Claude finds it, implements fix, verifies HTML, merges PR, closes issue autonomously.

08:54 – 09:35

06 · Polling vs. dynamic bridge

Clarifies that a dynamic run is technically not a loop but an advanced workflow: 3 inner loops inside 1 outer pass.

09:35 – 13:08

07 · Dynamic run demo — landing page

Full spec-to-ship: Next.js Lamora landing page. Code review loop zero findings, build/lint loop green, Chrome verify loop screenshots 5 sections. All gates clear, commits and merges.

13:08 – 14:05

08 · Wrap + CTA

Recap of the full dynamic run workflow, comparison to manual prompting, subscribe ask.

Atomic Insights

Lines worth screenshotting.

The loop prompts Claude so you do not have to — your role shifts from writing prompts to writing the harness that issues them.
A polling loop never finishes; a dynamic run finishes exactly once when its exit condition is proven true.
The exit condition is the most important line you write — without it the loop has no way to know it is done.
Writing done-when conditions like 'the HTML contains a mailto link' converts a vague task into a machine-verifiable gate.
Nested loops are just a pipeline: code-review loop, then build/lint loop, then chrome-verify loop, each running until its own exit is green.
A dynamic run is technically not a loop — it is an advanced workflow that uses inner loops as quality gates and runs exactly once.
Playwright MCP is avoided in favor of Vercel agent-browser because it uses less context and fewer tokens.
A polling loop plus Claude Code is a fully autonomous issue-resolution system — no human involvement after the harness is written.
The compounding effort lives in the harness, not in repeated manual prompts — write the loop once, benefit every iteration.
Claude Code's /loop slash command is the entry point that wires a natural-language spec into an actual cron or single-run harness.

Takeaway

Let the loop do the prompting.

WHAT TO LEARN

The bottleneck in most Claude Code sessions is not Claude — it is the human typing the next prompt; loops eliminate that bottleneck by encoding the whole workflow once.

A polling loop is a cron job for Claude: write it once, define what new work looks like, and it clears the queue every interval without you watching.
A dynamic run is a spec-to-merged-PR pipeline: the only input you write is the feature spec and the exit conditions for each quality gate.
Exit conditions are the most important text you write — done when route returns 200 is what turns an open-ended request into a machine-verifiable fact.
Nested inner loops (code review, build/lint, browser verify) each run until their own gate is green before handing off to the next stage.
Choosing the right browser tool matters: agent-browser uses fewer tokens than Playwright MCP for the same visual verification job, which keeps the loop from hitting context limits on long runs.
The first loop you write reveals what conditions you actually care about — most people discover they have never articulated a real done-when statement before.

Glossary

Terms worth knowing.

Polling loop: A Claude Code harness that runs on a clock schedule, never terminates on its own, and repeatedly checks for new work to process — analogous to a cron job that watches a queue.
Dynamic run: A one-shot Claude Code pipeline given a spec and an exit condition; it runs all necessary inner loops and stops automatically when every condition is met, without repeating.
Exit condition: A verifiable fact that tells the loop it is done, such as the route returns 200 or the HTML contains a mailto link — the absence of this is what makes most ad-hoc prompting sessions open-ended.
Inner loop: A sub-loop inside a larger dynamic run that repeats until a specific gate is green, e.g., the code-review loop that re-reviews until zero findings.
/code-review skill: A Claude Code slash command that audits the current diff for bugs and issues, returning a finding count the outer loop uses as its exit check.
Agent-browser: A Vercel-built browser automation tool used here as a more token-efficient alternative to Playwright MCP for visual verification of rendered pages.

Resources

Things they pointed at.

00:00channelBoris Cherny — Acquired Unplugged talk

00:16linkPeter Steinberg (@stelpete) tweet on designing loops ↗

04:43toolClaude Code /loop slash command

02:30toolClaude Code /code-review skill

12:27toolVercel agent-browser

12:27toolPlaywright MCP

Quotables

Lines you could clip.

00:00

“The creator of Claude Code says that he does not prompt Claude anymore. Instead, he uses loops.”

Authority-backed pattern interrupt, no setup needed→ TikTok hook↗ Tweet quote

02:16

“The loop prompts Claude now. You wrote the loop. Your job moved up a level: from typing prompts to designing the loop.”

Clean conceptual reframe in two sentences→ IG reel cold open↗ Tweet quote

08:22

“I have just designed the loop once and then it will automatically find those issues and fix them without my involvement whatsoever.”

Payoff moment — live demo just finished, stakes were real→ Newsletter pull-quote↗ Tweet quote

The Script

Word for word.

Read-along

Don't just watch it. Burn it in.

See every word as it's spoken — crank it to 2× and still catch all of it. The same dual-channel trick behind Amazon's Kindle + Audible.

analogystory

00:00The creator of Claude code says that he does not prompt Claude anymore. Instead, he uses loops that are running and prompting Claude to figure out what to do next. So you're not writing prompts anymore.

00:10You are writing loops that write prompts to ClotCode. In a similar fashion, Peyton Steinberg, the creator of OpenClock also says that you shouldn't be prompting coding agents anymore.

00:20Instead, you should be designing loops that prompts your agent or ClotCode. So let's understand how you can set up loops and stop prompting your cloud code session in each and every single step. To give you an example, here is my loop that will automatically read issues every five minute in my GitHub, create a branch to fix that issue, make sure that the work is done, commit, and create a PR all pull request, merge to main, and automatically close the issue on its own without you having to prompt even once by designing loop or writing loop yourself.

00:49So let me show you what are loops, how you can get started, and build yourself one. But before we move forward, let me show different example of loops for different use case and circumstances so that you will understand better and apply to your workflow. Here is my Instagram reel scraper that will find top trending Instagram reels in last twenty four hours and you can see the different outlier score and it will automatically rewrite that transcript in my brand voice.

01:13So let me open one example. Here is the original script that we have script and here is the new original script written in my own voice. So it is running every single two minutes and finding me viral Instagram wheels in my niche.

01:26Another example can be building the entire Carousel system end to end without my involvement whatsoever. So these are the five passes and as you can see there are no overlapping, there are no overflowing.

01:37In my Instagram carousel series without me even have to give a direction, topic ideas, content angle, it will figure out everything on its own and make sure that all of these files are verified successfully and every single text block sits inside the safe zone. Nothing is overlapping.

01:53There is no extra noise and is automatically registered inside my directory with git commits. So coming back to what are loops is basically your way of telling cloud, hey, I'm not going to prompt you anymore. Instead, I'm going to design loops that will prompt you.

02:07It will give you a set of task. Hey, this is what you have to done, and we have the end goal or desirable results. And in between, the loop will be automatically running to make sure that we are moving from our problem to solution.

02:18In a nutshell, your job is now not to prompt anymore. Instead, you have to design loops. So let me give you two concrete examples of loops.

02:25First, we have polling loops, which basically means that every five minutes, every two minutes, you have to run this loop. And second is dynamic loops, which is here you have this final end goal that you have to reach and figure out all the ways you need to do. So here we have our dynamic loop where we will just give it a spec or a feature request.

02:43Let's say we want to build a landing page for my website and then it will implement, then it will automatically run code reviews. So if you know inside our Cloud Code, we have this feature of code review that will automatically find all the existing bugs and errors and fix them.

03:02And until all of these errors are solved, it will not move ahead to the next step in the flow. So here we have one loop inside our code review, then another loop is built lean. If the exit is green, then and then only it will move to the next step, which is verify inside our Chrome browser.

03:18It can be either by using agent browser, Playwright MCP, or cloud in Chrome. So it will open the browser, make sure that all the UI UX is working properly. Sorry.

03:27Not UX, but all the UIs are placed perfectly. And until the spec or feature request that we have set out is proven, it will merge the PR and send you a done Slack message. But without using loops, you have to prompt in each and every single step until the whole process is done.

03:42For instance, you have to watch all the implementation phase and make sure that everything is working great. Then you will move to the code review process where you will find errors or bugs, then you have to prompt again to make sure that all of them are gone. Same goes for the build plus linked errors, then you have to watch it manually do the Chrome browser, then you have to create PR, merge them, and then finally this one unit of work will be completed by you have to manually involve in every single prompt or in every single phase.

04:09But by using loop, you step out of the process and give your agents the autonomy it deserves. Another example can be polling loops. Let's say you want to run it every single hour, every five minutes, ten minutes, whatever scheduled ground job that you want to run on.

04:23For example, we have this loop that will run every two minute to find any open issues. If yes, then it will read the issue, fix it, open PR or pull request, merge it, and close the issue on its own. So before you have to check the issues for yourself, fix each one of them yourself individually in all of these steps.

04:43But with loops, it will automatically clear them out and you haven't type anything. Now it's time to design loops in practice inside our Cloud Code session. So I will call loops by using slash and then simply type loop.

04:55We will create this loop example where every single two minute it will find for any new issues and fix them automatically. Awesome. I have defined the schedule cron job of two minutes.

05:04Obviously, can be twenty minutes, ten minutes, whatever you like. What it has to do is open d dub issues. If it find any, it will read them, implement the fix, run and build test until it is green, open a PR or pull request, merge it, and close the issue when done.

05:19But if there are no new issues, just say nothing new.

05:28Awesome. So it will set up the loop and the interval is two minutes.

05:34As you can see, is listing GitHub issues. Right now, are no issues. So it will say nothing new.

05:43Let's head back to our GitHub and create a new issue to see this in practice. For instance, this is my website and I can see there is no mail or email inside my footer. So the title of the issue will be add get in touch email link in our footer.

05:58Inside description, let's add our email address. Now this is the key part, which is the done condition or the final or stop condition. So when it will stop or consider it done?

06:07When it will find an mail to or email address inside link in the footer. Let's create this issue. Awesome.

06:15Issue created. Let's head back to our ClotCode session. After two minutes, it is listing GitHub issues again.

06:22And as you can see, it has find new issue. Let me find the footer. It has located the footer.

06:34I will add that get in touch to the footer row right now. Here you can see it is adding my mail. And now it is passing.

06:44And now it is testing built and linked. And now it is going through built and linked testes. And now it is going to built and linked until it is green.

06:54Awesome. So all of them have passed successfully and no errors. And that and that and the done state and the done or final state is the HTML contains the mail to link.

07:14So you can see it is pushing to so you can see it is pushing that to production.

07:30And the final or done state is solved HTML contains the mail to link. And as you can see inside our website, we have this get in touch button that will automatically open my email which is manthan lead gen man dot com.

07:45Awesome. So it has verified that the mail to link contains our email address. And now it will automatically push open PR merge and close the issue.

07:55Right now it is committing the change, pushing branch to remote, creating a pull request or PR, and now closing the issue.

08:03Awesome. Again, is running as the two minutes has finished and finding that if there are any new issues or not. And as you can see the result, nothing new anymore.

08:12So that's how you can create loops where you haven't involved in the process at all. You have just designed the loop or the hardness of your cloud code session that will run every single two minutes to find any open issues and if so it will read those issues, fix it, merge it and close this issue every single two minute.

08:30So that way as you saw I haven't even typed anything or prompt my cloud code session. I have just designed the loop once and then it will automatically find those issues and fix them without my involvement whatsoever. And as you can see, it ran once again.

08:43Please open GitHub issues and nothing new. Now let's stop this loop.

08:54Awesome. The loop is stopped and no more two minute issue check. But for the record, it is fixed or solved that footer mill tool link and now no more issue is remaining.

09:02What we did was we set up an polling loop that will run on a clock. It will never finish until we stopped it manually like we did and will watch for new work. But with dynamic loops, we just give it a goal or a task and then it will make sure that everything is going to completed and then it will run this loop once and stop once it is done.

09:21And that's where the complexity of nested loop or inner and outer loop comes in. So we have this inner loops of code review, built loop, and chrome verify loop.

09:31So these are three inner loops. Inside this one main outer loop that is just going to run once. So basically, you cannot even call this as a loop, but an advanced workflow.

09:40Now example of those type of loops can be, here is our loop that we have called, and we want to build a feature that is described in the specs below. So here is our specs which is to create a landing page for this company Lamora and this is the route or API navigation.

09:57These are the requirements, brand colors and what is the done or final condition is the route returns 200.

10:05Everything should be rendering perfectly, and the call to action should be download for free. So here is our loop prompt.

10:12So run this as one dynamic loop end to end, and don't stop me until you are done. First of all, create a branch, implement this feature for the spec, and then comes our nested loop.

10:23First loop is our code review. Once it is done building the feature, then run this code review command and fix every issue it finds and rereview until everything is done. So until there is zero finding, it will stop running inside this code review loop.

10:38Then it will go to the second loop, build plus next link, find any errors, and until everything is green, which means everything is passed, run this loop over and over again. And last but not least, our chrome verify loop, which is opening agent browser by Vercel or Playwright MCP. Screenshot every page and make sure that everything is done, probably true on a slide page.

10:59And when all of these loops are passed, make sure you commit open a PR, merge it, and pull main. Here it will start creating that loop which is going to be dynamic mode without any polling or intervals. It's a run one self paced built loop that will have all of these three features specs and this is the implementation part, then code review part and make sure that everything is fixed until it is clean.

11:21Then it will go to the next loop which is built and linked and make sure that everything is fixed until it is green and comes our third loop, which is verify in Chrome until everything is fixed and rendering successfully and then commit and screenshot. So it will start building the page.

11:40It's the NextJS app router page per folder. It has used the color schema, written the code for it, and now calling our code review skill.

11:52So it is right now inside our first inner loop which is of code review. And as you can see, it has find no errors inside our code. So no runtime correctness bug and then it will start with the second loop which is build plus lint.

12:08So it is linting the new page.

12:13And the good news is there were no typescript error and the route was returning perfectly 200. So it is compiled and it serves. So it will turn into the third verification stage, which is our chrome verify loop that will open in browser and fix everything in terms of UI.

12:29Right now, am using agent browser by Versal team and not Playwright MCP as it is much more context or token efficient. All of these five sections have rendered perfectly. It has screenshotted the landing page, read the browser agent usage, Read the screenshot.

12:51Awesome. Our loop has followed all of these things successfully and it has met the exit condition which is everything is green or good to go. And the final step of the loop is committing our verified landing page.

13:02Here is our loop entire workflow that has run end to end and exited on a clean pass. Here was our input, which was creating a marketing landing page, the implementation step, code review loop, lint and built loop, chrome verify loop, and the output is committed page and the screenshot proving it works.

13:23So by designing loops and giving your agent goals specific like this, you step out of yourself in this entire workflow and you are not prompting agents anymore. You are designing loops instead. Otherwise, what have done is you would have involved in this implementation process.

13:37You would have gone back and forth with prompting with code review process. Same goes for build, Chrome verify, creating a PR. Every of this step, you have done it manually and give all prompt cloud code each time.

13:49But with loop like this, you run this one unit of work end to end without you having to involve whatsoever. But if you want me to make more videos on how I use loop inside my workflows and applications, drop a like, leave a comment below, and subscribe for more.

14:03And I will see you in the next one.

The Hook

The bait, then the rug-pull.

Boris Cherny, the person who built Claude Code, no longer types prompts into it. He designs loops that do the prompting for him — and a viral tweet from Peter Steinberg carries the same message. Manthan Patel takes that premise and turns it into a 14-minute hands-on demo, showing exactly what a loop looks like, how to write one, and what happens when you let it run.

Frameworks