Big Idea

The argument in one line.

The next abstraction in agentic AI is not better prompts but loops and scheduled routines that send prompts on your behalf — so Claude runs workflows without you in the room.

Who This Is For

Read if. Skip if.

READ IF YOU ARE…

You use Claude Code daily and want to reduce how much you manually kick off repetitive tasks.
You want to understand how Claude Code's Routines feature works and how local and cloud schedules actually differ.
You have a workflow — like turning a YouTube video into a newsletter draft — that you want running automatically every morning.
You are curious why the creator of Claude Code says he no longer prompts it himself.

SKIP IF…

You are looking for a deep dive into Hermes, OpenClaw, or multi-agent orchestration — this is an overview, not a masterclass.
You are not yet using Claude Code; this assumes you know the tool and are ready to automate it.

TL;DR

The full version, fast.

Boris Shurney, the creator of Claude Code, said publicly that he no longer prompts Claude directly — he writes loops that prompt Claude for him. This video unpacks what that means across three tiers: an in-session /loop command that dies when the window closes, local desktop routines that run on cron as long as your computer is on, and cloud routines currently in research preview with real constraints (15 daily runs max, no local file or tool access). Four elements make a routine durable: a clear trigger with a stop condition, a separate skill file you refine over time, explicit tool declarations, and a precise output definition. For most users today, Tier 2 is the practical answer; Tier 3 is where things are headed once the tooling matures.

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:47

01 · Cold open — Boris quote

Hook: Claude Code creator stopped prompting manually; writes loops instead. Clip from Acquired Unplugged interview.

00:50 – 01:42

02 · Peter Steinberger tweet + three tiers intro

Peter's viral tweet (6.3M views) sets up the three-tier framework.

01:42 – 03:31

03 · Tier 1: /loop in-session

Demo of /loop command. Explains schedule-wakeup under the hood and session-close limitation.

03:31 – 04:19

04 · Tier 1 real use case: SyncThing check

Every-15-minute loop to verify Hermes file-sync connection during prototyping.

04:19 – 05:59

05 · Tier 2: Local desktop routines

Routines panel walkthrough. YouTube-to-Substack automation running daily at 8AM.

05:59 – 08:21

06 · Four elements of a strong routine

Trigger, Skill, Tools, Output — each explained with the YouTube-to-newsletter example.

08:21 – 10:42

07 · Tier 3: Cloud routines

15 daily runs cap on Max plan, no local file/tool access, must be configured manually from the UI.

10:42 – 12:09

08 · Cloud routine workarounds

GitHub push as partial fix; Hermes/OpenClaw on VPS as the real workaround for tool-dependent automations.

12:09 – 14:18

09 · Summary + token budget reality check

Tier 2 is the practical answer today. Peter Steinberger spent $1.3M in tokens in 30 days. Token cost scales with autonomy.

Atomic Insights

Lines worth screenshotting.

Boris Shurney no longer prompts Claude manually — he writes loops that prompt Claude for him and calls this the next wave of abstraction.
Peter Steinberger's tweet that you should design loops instead of prompting agents got 6.3 million views in days.
/loop in Claude Code uses a schedule-wakeup tool internally — it is not a persistent process but Claude sending itself a prompt on a timer.
In-session loops die when the Claude Code window closes; use local or cloud routines for anything mission-critical.
Separating your skill file from your routine means you refine output quality over time without ever touching the scheduling logic.
Cloud routines in Claude Code are capped at 15 daily runs on the Max plan and cannot access local files, local tools, or local skills.
If your automation needs yt-dlp or any local binary, cloud routines cannot run it — you need the YouTube API or a VPS.
Peter Steinberger spent $1.3 million in tokens in 30 days because loops run continuously across hundreds of parallel agents.
A VPS running Hermes or OpenClaw is currently a better cloud routine than Anthropic's own cloud routines for tool-heavy workflows.
The practical answer for most users today is Tier 2 local routines with a clear trigger, versioned skill, defined tools, and explicit output.

Takeaway

Three tiers that decide how autonomous your Claude workflows can get.

WHAT TO LEARN

The shift from prompting Claude to writing loops that prompt Claude for you is real and teachable — but each tier of automation comes with a different durability ceiling and a different set of constraints.

/loop is the fastest way to test recurring automation logic, but it evaporates the moment you close the Claude Code window — treat it as a prototyping tool, not a production system.
Local desktop routines are the practical sweet spot today: durable, observable, and capable of using any tool installed on your machine, as long as your computer stays on.
A routine is only as good as its skill file — keeping the skill separate from the schedule means you can improve the output daily without ever touching the trigger or cron configuration.
Cloud routines cannot access your local files, local tools, or local skills — if your workflow depends on yt-dlp, a local binary, or a file on your drive, cloud routines will silently fail or fall back to local.
The realistic cloud workaround today is running your agent on a VPS rather than Anthropic's infrastructure, which remains in research preview with hard daily run caps.
Autonomous loops that run continuously at scale cost serious money — apply these techniques selectively to workflows with measurable ROI.

Glossary

Terms worth knowing.

/loop: A built-in Claude Code slash command that runs a prompt on a repeating interval using a schedule-wakeup mechanism; the loop terminates when the session window closes or after seven days.
Local routine: A Claude Code scheduled workflow that runs on your computer on a cron-like schedule; it only fires when the machine is awake and the desktop app is open.
Cloud routine: A Claude Code scheduled workflow that runs on Anthropic's infrastructure, enabling automation even when your machine is off; currently in research preview with significant tool and file-access restrictions.
Skill file: A standalone instruction document that tells Claude how to execute a specific task; kept separate from routines so it can be refined independently without touching the schedule.
SyncThing: An open-source tool that syncs files between devices or agent platforms in real time, without a central server.
yt-dlp: A command-line tool for downloading video and audio from YouTube and other platforms, often used to extract transcripts for downstream automation.
Hermes Agents: A VPS-based autonomous agent platform that can run 24/7 in the cloud, used here as an alternative to Anthropic's cloud routines for tool-heavy workflows.
OpenClaw: A coding agent platform created by Peter Steinberger that, when run on a VPS, serves as an always-on alternative to Claude Code cloud routines.

Resources

Things they pointed at.

00:00channelBoris Shurney

00:18channelAcquired Unplugged (WorkOS)

01:09linkPeter Steinberger (@steipete) tweet ↗

01:09productOpenClaw

03:31toolSyncThing ↗

04:19productHermes Agents

08:21toolyt-dlp ↗

04:19productRoboNuggets Agentic AI Masterclass

Quotables

Lines you could clip.

00:18

“I don't prompt Claude anymore. I have loops that are running. They're the ones that are prompting Claude and kinda figuring out what to do. My job is to write loops.”

Boris Shurney saying this directly — tight, declarative, paradigm-shifting in 2 sentences→ TikTok hook↗ Tweet quote

01:09

“Here's your monthly reminder that you shouldn't be prompting coding agents anymore. You should be designing loops that prompt your agents.”

Peter Steinberger tweet shown on screen — standalone pull-quote with no setup needed→ IG reel cold open↗ Tweet quote

13:51

“In the past thirty days, he spent like $1,300,000 worth of tokens.”

Shocking dollar figure with zero context needed→ TikTok hook↗ 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.

metaphoranalogy

Stop prompting Claude. Instead, build agent loops that make Claude prompt itself. This is coming straight from Boris Shurney, the creator of Claude code.

Because in a couple of interviews over the past few days, he mentioned that he has basically stopped prompting Claude manually, but instead he's now engineering loops to fully take advantage of Claude code's automated capabilities.

At that point, I was running, you know, maybe five, ten quads in parallel and my coding was prompting Claude to to write code. Now it's actually leveled up, I think, again to the next wave of abstraction where I don't prompt Claude anymore. I have loops that are running.

They're the ones that are prompting Claude and kinda figuring out what to do. My job is to write loops. And the this is this kinda next transition that I think we're gonna see in the next few months.

So today, I'll teach you exactly what that means, how you can start building workloads that run without you, and how you can unlock the remaining 90% of your AI agent systems. Let's dive into it.

So Paul Over X, this clip of Boris' journey was going around where basically he said that he doesn't really prompt Claude anymore. He writes loops and loops do the work. And it's not just Boris, by the way.

So Peter Steinberger, the creator of OpenClaw, also tweeted this out, which already has 6,000,000 views where he basically said that you shouldn't be prompting coding agents anymore, but what you should be designing are loops that prompt your agents. So you can tell that for the most advanced users like Peter and Boris, this may be where things are headed.

Where instead of constantly having to prompt our agents ourselves, we are moving into a space where we are actually building systems that make these agents more autonomous. Now there's obviously a lot to unpack there including the cost of the tokens that these sort of loops would require. And also there's a question of how exactly you can design well crafted loops that will let your cloud or other AI agents run these workflows on your behalf without you having to prompt it every time.

And so I actually think it's good to unpack this so that even if you're a complete beginner or even if you're a non developer, you can take advantage of these looping systems and actually build it into your own workflows. And the way it's done with today's agentic platforms, you can sort of boil it down to three tiers. And the first and most basic among them is this loop command, which you can do in Cloud Code.

And to use this loop command, it's really simple because if you type in slash loop, you can see that there's a built in command within Cloud Code where it tells you that the way it works is if you invoke this command, the prompt that follows it will be run on a regular interval. And just to give a simple example, what I'm asking Cloud Code to do here is that every sixty seconds, I want it to count and increment by five until it reaches 50.

So obviously, that is not particularly useful, but that gives you an idea of how loop works. Because under the hood, what it really does is use the schedule wake up tool so that every sixty seconds depending on the interval that you set, it just wakes itself up and sends itself a prompt until either it reaches a certain goal that you set or if you didn't set a certain goal at all, then it will just continue doing that up until you close the session or up until seven days pass.

And there you can see after that sixty seconds, it now incremented it to 10 and it will do so up until it loops, until it finishes any goal that we set. Now, although this very first year of using slash loop is quite foundational because it gives you a sense of how these self running workflows can work later on, which I'll go through in a bit, you can see that they're not always the most useful.

And the reason why that is is because if this session or this window is closed or archived, this whole loop will actually stop. And so where is this tier one of looping actually useful? Well, it's actually useful if you're just testing out automations that you will harden or make more robust later on.

To give one example, when I was setting up my connection between my Cloud Code operating system and workspace with my Hermes agents, I basically wanted to make sure that that connection is live and running throughout the day in order to just check that the files between those two agents are actually syncing well. And so while I was prototyping this, basically, I set a simple loop where every fifteen minutes, I wanted to check that my SyncThing connection and SyncThing is this tool that basically syncs your files between any agent platform that you want.

And I just kept this running for a while in order to check that connection is still alive. And so here you can see that it is basically looping every fifteen minutes in order to check that for us. Which, by the way, if you wanted to dive deeper into the AgenTic space and actually learn how to master Cloud Code as well as Hermes and to have them work together, then you can check out the AgenTic AI masterclass, which all of the community members in RoboNuggets have access to.

And here, we provide you with a lot of foundations in order to not just master Cloud Code, but any AI agent tool that comes up in the future. And you'll also get access to the Hermes agent masterclass, which gets you up and running with these twenty four seven agents and how you can operate them effectively with tools like Cloud Code.

In fact, this connection between Cloud Code and my Hermes agent so that they are sharing the same brain and same files, I go through all of that in that master class. So see that below if in case that's for you. So now if these loops only live in your session, how do we now actually make them more robust so that they live even if we close our session?

Well, that now takes us into tier two of these self running workflows where you can schedule these tasks and these loops on your desktop. And in Cloud Code to set up these desktop based workflows, they're basically all housed under routines here on the left. So you can see if I go to routines here, you can find all your scheduled workflows in here, and you can also see them in a nice calendar view.

Now the one that we are talking about in tier two is this local routine, which basically means that it is running on your local device or your computer. So as long as your computer is awake, then this routine will also run on this scheduled time. So if I just open this one, just to give an example, you can see this routine and its instructions here is a pretty detailed one.

But basically, what it does in a nutshell is really simple. It just checks our YouTube channel if there's any new video that is uploaded. And if there is, it just grabs the transcript of that video and converts it into a Substack article based on our tone of voice.

Now, this runs every day at 8AM. But from here, you actually have the option to run it manually. And the great thing about local routines is that you actually have a bit of observability here.

So if I go to the history, you can see that under the hood, what this really does is just opens up a new Cloud Code session, give that instructions that we have in the routines setup detail file, and a Cloud Code basically sends a prompt to itself with all of that instruction. And so there's nothing really technical or fancy about it.

Basically, you have a prompt, it sort of preloads that prompt, and then on a specific schedule, it runs that prompt for you. And from here, you can see that when this routine runs, it basically gives us a draft, which we can now review here. And if I approve this, this now goes into the Substack drafts ready for sending.

Now to make a routine, you can actually just click on new routine here. Click on local, and you can type out all your instructions as well as descriptions in here. And obviously, you can also set the schedule as you wish from within this nice UI.

However, with these authentic platforms, I actually advise you not to do it this way because the easier method to do it is to just tell Cloud Code to set up a daily routine for you. What is essential though is that you make sure that these four elements are included in your routine so that this automated workflow can be as strong as it can get.

So if you take a look at this prompt, which basically builds that YouTube to Substack automation that we were viewing earlier, you can see I have four elements in here. The first one is going to be the trigger. And essentially, this is your instructions on every when it should run.

So right now, says every day at 8AM, check my YouTube channel for a video posted in the last twenty four hours. If there's nothing new, stop and do nothing. Now the second component, which is the skill, is really important.

So you can see here what I said is that when there is a new video, use the master newsletter skill to turn it into a substack newsletter draft from that video. And in case you're new, a skill is basically just a set of instructions. So you can see here this master newsletter skill just provides instructions on Cloud Code on how to draft that HTML file that we were viewing earlier.

And the reason why this is important to be separated from your routines is because you actually want to continuously refine this skill based on the outputs that you want. So let's say for this specific example, every time that I get an output from that routine that I just set, I actually provide feedback to Cloud Code where, for instance, the draft that it created, for example, is a bit too AI or is not really my tone of voice, then I just provide feedback to it continuously so that every day that it runs, it actually gets to improve, and it just rolls all of those improvements into this skill instead of touching the routines.

The third element that you should include or give an idea to are the tools that you use. So at least for this specific automation, I know that I wanted to use the YTDLP tool, which is installed in my device, to pull the video's transcript.

And this can be wide ranging, by the way. Let's say if you have an email automation, then you want to provide guidance to Cloud Code that you want to connect, let's say, your Gmail or your Outlook, which in case you're not sure, you can always work with Cloud Code in order to figure out all of those connections. And the fourth element is the output.

So you just need to be quite clear with Cloud Code on what is sort of the definition of done when this workflow runs by itself. So you can see here that for this routine, I just ask it to save the finished newsletter as an HTML file in this particular path, which is also documented in the master newsletter skill so that the next time that I'm in my desktop, I can just open it from my side and review it before sending it through.

And you can see based on that prompt, it did all the hard work to set it up for us, which is the one that we now have here in routines. Now there is one glaring limitation when it comes to local routines though, and it is this, that local routines only run when your computer is awake. And so that brings us to the third tier of self running workflows, which are workflows or routines that are set up in the cloud.

And the way that you set up these routines in Cloud Code is pretty similar to local routines. The only difference is when you set up a new routine here at the top right, instead of choosing local, you can choose the remote option. And from this page, you can give it a name, you can give it the instructions, which is basically going to be the prompt that Cloud Code will send itself every time it runs, and you can also select a trigger, which for most cases, a scheduled trigger is the one that is most applicable.

But if you're a bit more advanced, then you can also trigger these things via GitHub events or API calls. Now even though this third tier is where I think these sort of self running workflows will end up being in the coming months, Right now, at least with Entropic's setup of these cloud routines, it is actually still in research preview.

And so there's a couple of limitations that you need to understand before you set up cloud routines. The first one is that you actually have a limited number of remote daily runs. And so here you can see I'm on the max plan, but I only get up to 15 daily runs that I can trigger remotely.

Another limitation is that unlike local routines, if you try to invoke Cloud Code via just natural language to set up the Cloud Routine for you, it will actually default to setting it up via a local scheduled task. So you can see here that with this prompt where I ask it to set up this cloud routine for me, it confirmed that it is live.

But in the end, if I go back to my routines in here, all it really did is reset up that automation that happens locally, which is obviously not what we want. And so upon digging upon this further, the only way for you to set up Cloud Routines right now is for you to actually manually fill up this remote routines from this screen.

Lastly, I think the most important limitation when it comes to using these remote routines is that it has a strict requirement that every dependency that your automation needs, like the skill that you're using or any tools that you want to use as part of that automation, also needs to be in Entropic Cloud. So you can see here when I tried setting up this routine myself, Cloud Code basically told me that this particular routine can't run-in the cloud because since it runs on Anthropic's own infrastructure, basically their own computers which are running twenty four seven, yes, it can run even when my own personal machine, my personal device is off.

But since it doesn't have access to my files, then it also doesn't have access to that master newsletter skill that I make and keep updated. And more importantly, since that environment with Entropics infrastructure doesn't really have YTDLP, which is this piece of software which is useful when it comes to transcribing and downloading YouTube videos, then that is also not automatable via Cloud Routines.

Now you can sort of work around this by, number one, uploading your skills over at GitHub, which you can give Cloud Code access to, and it'll be able to work on any repository that you wish and also use that skill for you. But apart from that, if you need custom tools or software that you need to invoke as part of your automation like this y t d l p toolkit, then right now, cloud routines have that severe limitation which disallows you from using them as effectively as local cronts, which make them in my opinion right now a bit less effective versus just setting up these local schedule automations.

And so you can see here just to be able to set up a cloud routine for us, we'll need to do several steps where we need to push the work into a GitHub repo and we'll need to use YouTube's API instead of the local YT DLP. And this is also why tools like Hermes Agents or OpenClaw are quite useful in this case because with those platforms, since you are running them, let's say, on a virtual private server, which I have on my own setup, then since those are running twenty four seven on the cloud, then I can just provide this same prompt to Hermes, for example, and it will set up that cron, basically, that scheduled task in order to automate this for me.

So in a nutshell, even though tier three having these routines and this self running workflows running in the cloud would be the future and is definitely going to be worked on more by Anthropic in the coming weeks to months. At the moment, it is still in research preview. And so for most use cases, I think having routines, basically automations and loops running on tier two would be a good way to do it.

As long as each workflow has these components where you're very clear on the trigger, you have a skill that you always improved every time it runs, you have clarity on the tools that you want your agent to be using, and you also have the visibility of the output that you want it to provide to you, then you'll be able to start automating things and just let Claude run these workflows even without you having to prompt it.

As a final note, even though this may be the feature of Agentic work, it's also good to just remember that these advanced users like Peter Steinberger and Boris Shurney have one clear advantage that none of us have, and it's that these guys have infinite token budgets. If So you look at Peter's tweet here from, like, a few weeks ago, you can see that in the past thirty days, he spent, like, $1,300,000 worth of tokens.

And that's a crazy amount that was spent precisely because Peter has a lot of loops and a lot of scheduled tasks that are running in the background for multiple agents, probably hundreds of agents to do his work. However, if you don't have that sort of token budgets, I think learning at least these techniques and applying them whenever it makes sense can still 10 x your productivity with using these agentic platforms.

So there, hope that was useful. And as always, thanks for watching until the end, and I'll see you all next time. Thank you.

The Hook

The bait, then the rug-pull.

The man who built Claude Code says he no longer uses it the way you do. Boris Shurney stopped typing prompts weeks ago — now he writes loops, and the loops do the prompting. This video is the clearest explanation yet of what that actually looks like in practice.

Frameworks

Named ideas worth stealing.

01:42list

Three Tiers of Self-Running Workflows

Tier 1: /loop (in your session)
Tier 2: Local routine (on your desktop)
Tier 3: Cloud routine (in the cloud)

Escalating levels of automation durability — Tier 1 dies with the session, Tier 2 dies with the machine, Tier 3 runs 24/7 but has significant current limitations.

Steal forAny explainer about AI automation maturity levels

06:59list