What Is the Claude Code /loop Command? Usage, Polling, and Scheduling Compared

"Tell me when the build finishes." "If CI goes red, fix it." "Watch the deploy every 5 minutes." What if you could hand these stay-glued chores entirely to AI? The /loop command added to Claude Code in 2026 does exactly that. It runs a prompt or slash command repeatedly on an interval you set — or one the AI decides for itself — a "watcher" and "repeater" within your session.

Here's the bottom line. /loop fills the gap between "I want to check right now" and "I want it automated 24/7." Type /loop 5m check the deploy status and it runs automatically every five minutes. Omit the interval and Claude looks at the situation and picks the best wait time itself (self-pacing). This article explains, for beginners, the four ways to use it, how self-pacing works, practical recipes, how to stop it and what to watch out for, and how it differs from related features (Desktop tasks, cloud Routines). Note that /loop is a new feature whose behavior may change, so check the official docs for the latest (this article reflects 2026 information).

* The /loop behavior in this article is based on the Claude Code official docs (as of 2026). As a new feature it may change by version. Check `claude --version` and the official docs for the latest before use.

1. What is /loop? — in one sentence

/loop is a built-in Claude Code feature that "runs a prompt or slash command repeatedly on an interval." Technically it's a "session-scoped task scheduler," and under the hood it uses cron (a time scheduler).

In everyday terms, /loop is "a thoughtful assistant you can ask to go check on things every five minutes." While you work on something else, the AI periodically checks in the background and responds when something changes. And if you omit the interval, the AI gauges the timing itself — "things are moving, so one minute; it's quiet now, so thirty". That's the decisive difference from plain cron. The "decides and acts on its own" nature of an underlying AI agent is exactly what pays off here.

2. Four ways to use it (interval × prompt)

The basic form is /loop [interval] [prompt]. Both interval and prompt are optional, and what you pass changes the behavior. There are four combinations.

Intervals are written as a number + a unit (s=seconds, m=minutes, h=hours, d=days). The minimum is one minute, and seconds are rounded up to match cron's granularity. You can also write it in natural language, like every 2 hours. And crucially — you can pass a slash command instead of a prompt. For example, this loops the review of a specific PR every 20 minutes:

# Example of looping a slash command
/loop 20m /review-pr 1234

# Example of specifying the interval in natural language
/loop check the test results every 30m

In other words, you can automate "the command you used to type by hand" just by adding an interval. If you care about AI coding cost, the knack is to avoid pointless loops and run them only when needed.

3. The power of self-pacing (AI picks the interval)

Of the four usages, the one that lifts /loop above "plain cron" is self-pacing (auto-judged intervals). Omit the interval and Claude, after each run, decides for itself "when should I come back next?"

This is where it shines. Ask, in self-pacing mode, "watch until the tests pass," and it checks at short intervals while tests run, increases the frequency as the finish nears, and stops the loop and reports once they pass — behaving much like a human watcher. With a fixed interval you get "it keeps running pointlessly though it's already done" or, conversely, "the interval is too long and it misses things"; self-pacing avoids that. Personally, I'd use self-pacing for monitoring that doesn't need an exact time, and a fixed interval for things where time matters, like a scheduled report.

4. Practical recipes

Concrete examples beat abstractions. Here's where /loop genuinely helps, in ready-to-use form.

The point is to target "work a person used to check periodically." Especially jobs that repeat "wait → check → respond," like CI and deploys, are /loop's home turf. Routine monitoring like a PR status check, looped, frees you from staying glued.

5. Stopping it, and cautions

For all its convenience, /loop has constraints that come from "running within a session." Not knowing them leads to "huh, it's not running?"

• Stop with Esc: press Esc while it waits for the next run, and the pending wakeup is cleared and the loop stops. In self-pacing, Claude may also stop on its own when it judges the task "done."
• Runs only while the session is open: /loop is tied to that session (conversation). Starting a new conversation clears the tasks. Closing the terminal stops it too (resume within 7 days with `claude --resume`).
• Fixed intervals last up to 7 days: they keep running until you stop them or 7 days pass.
• Up to 50 tasks per session: you can't register more.
• Fires between turns (responses): it doesn't interrupt mid-action; it fires at the gap between turns. When things are busy it can drift a bit (there's also intentional jitter to avoid hammering the API). Times are in your local timezone.

Honestly, the biggest pitfall is forgetting that "it stops when you close the session." /loop isn't suited to running 24/7 unattended. For that, use a different feature, covered next.

6. Choosing among three scheduling features

Claude Code actually has three layers of scheduling. /loop handles the "within a session" one. They're easy to confuse, so let's sort them out.

* Feature names and specs are as of 2026. They may change by version or availability, so check the official source.

The choice is simple. Just want to watch a bit during work? /loop. Want it to continue after you close the session? Desktop tasks. Want it to run unattended even with your PC closed? Cloud Routines. Is it "monitoring as an extension of what I'm doing," or "running even when I'm not here"? That single question decides it. If you run AI agents seriously, understanding these three layers pays off.

7. Customization (loop.md) and disabling

Finally, two more advanced touches.

• Make the "default behavior" your own with loop.md: the default action for a prompt-less /loop can be replaced by writing your own Markdown in `.claude/loop.md` (project-level) or `~/.claude/loop.md` (user-level). For instance, you can make "your watching routine" the default — like "check the release/next PR; if CI is red, push a minimal fix; if green, report in one line." Edits take effect on the next run.
• Disable it entirely: to stop the scheduler itself, set the environment variable CLAUDE_CODE_DISABLE_CRON=1.

loop.md follows the same idea as guidance files like CLAUDE.md. Write down once "what you want done periodically," and your personal watching loop runs without you typing a prompt every time.

Summary

Here's Claude Code's /loop, sorted out.

• What /loop is: a session-scoped scheduler that runs a prompt/slash command repeatedly on an interval you set (or the AI sets).
• Four usages: fixed interval / self-pacing / interval-only (maintenance) / both omitted (auto-maintenance).
• Self-pacing is the key: it varies the interval by activity and auto-stops when done. The difference from plain cron.
• Practical use is monitoring: CI/deploy watching, PR babysitting, build checks, reminders.
• Constraints: within a session only, up to 50 tasks, fixed intervals last 7 days, stop with Esc.
• Choosing: /loop during work, Desktop tasks for resident, cloud Routines for unattended.

In the end, what /loop changes is the "time axis" of work you can hand to AI. Until now you could only ask for jobs that finish in a single conversation; /loop makes it possible, for the first time, to hand AI "continuing work — wait, look again, respond." While you focus on something else, the loop keeps quietly turning. Get your stay-glued time back from the AI.

FAQ