{"id":7626,"date":"2026-10-25T16:13:25","date_gmt":"2026-10-25T16:13:25","guid":{"rendered":"https:\/\/jonjones.ai\/uncategorized\/claude-code-loop\/"},"modified":"2026-10-25T16:13:25","modified_gmt":"2026-10-25T16:13:25","slug":"claude-code-loop","status":"publish","type":"post","link":"https:\/\/jonjones.ai\/zh\/%e4%ba%ba%e5%b7%a5%e6%99%ba%e6%85%a7\/claude-code-loop\/","title":{"rendered":"Claude Code \u5faa\u74b0\u6307\u5357\uff1a\/loop\u3001\/goal \u548c 1800 \u591a\u6b21\u7121\u4eba\u503c\u5b88\u904b\u884c\u80cc\u5f8c\u7684 Cron \u5faa\u74b0 (2026)"},"content":{"rendered":"

\u985e\u578b \/loop 5m check the deploy<\/code> and Claude Code will keep checking your deploy every five minutes until you tell it to stop. That’s the Claude Code loop<\/strong> most people mean, and it’s a great tool. It also stops working when you close your laptop, and it deletes itself after seven days.<\/p>\n\n

I run ten businesses on unattended Claude Code agents, and this container alone has written more than 1,800 run logs since June 12, 2026. None of those runs used \/\u74b0\u5f62<\/code>. That’s not because \/\u74b0\u5f62<\/code> is bad. It’s because it was built for a different job.<\/p>\n\n

This Claude Code loop guide covers both jobs. You’ll get the three kinds of loop in Claude Code, exactly how \/\u74b0\u5f62<\/code> behaves (intervals, self-pacing, loop.md<\/code>, the jitter, the 7-day expiry), how it compares to \/goal<\/code>, Stop hooks and the bash-style “Ralph” loop, and the cron loop that runs my fleet. All the numbers come from the official docs as of October 2026 or from my own logs, and I’ll tell you which is which.<\/p>\n\n

What a Claude Code Loop Actually Is (There Are Three)<\/h2>\n
\"claude<\/figure>\n

Most articles in this search treat “loop” as one idea. There are really three loops in Claude Code, stacked inside each other. Most confusion comes from mixing them up.<\/p>\n\n

Loop 1: the agent loop (inside one turn)<\/h3>\n

Every Claude Code turn is already a loop. Claude reads your prompt, calls a tool, reads the result, and decides what to do next. It keeps going until it thinks the task is done. You get this for free. You never type anything to turn it on.<\/p>\n\n

Loop 2: the session loop (between turns)<\/h3>\n

This is where \/\u74b0\u5f62<\/code> \u548c \/goal<\/code> live. They keep one open session<\/em> going after a turn would normally hand control back to you. \/\u74b0\u5f62<\/code> starts the next turn when a time interval passes. \/goal<\/code> starts it when a separate evaluator decides your condition isn’t met yet.<\/p>\n\n

Loop 3: the outer loop (between sessions)<\/h3>\n

This one starts a brand-new<\/em> Claude Code session on a schedule, does one job, and exits. Cron plus \u514b\u52de\u5fb7-p<\/code>, Anthropic’s cloud scheduled tasks, Desktop scheduled tasks and GitHub Actions all live here. My fleet lives here too. It’s the top rung of the autonomy ladder I laid out in what an AI coding agent actually is<\/a>.<\/p>\n\n

\n\n
Loop<\/th>What starts the next pass<\/th>Survives closing the terminal?<\/th>\u6700\u9069\u5408<\/th><\/tr><\/thead>\n
Agent loop<\/td>The last tool result<\/td>n\/a (one turn)<\/td>Every task, automatically<\/td><\/tr>\n
\/\u74b0\u5f62<\/code><\/td>A time interval, fixed or chosen by Claude<\/td>\u4e0d<\/td>Polling while you work<\/td><\/tr>\n
\/goal<\/code><\/td>The previous turn finishing, if the condition isn’t met<\/td>No (restored on resume)<\/td>Grinding toward a checkable end state<\/td><\/tr>\n
Outer loop (cron, cloud, Desktop, CI)<\/td>A clock or an event<\/td>\u662f\u7684<\/td>Unattended recurring work<\/td><\/tr>\n<\/tbody><\/table><\/figure>\n\n

Pick your Claude Code loop by asking one question: does a human have this session open?<\/strong> If yes, use a session loop. If the work has to happen at 3am while you sleep, you need the outer loop. Running a session loop for that is like leaving a terminal open and hoping.<\/p>\n\n

How \/loop Works: Fixed Intervals, Self-Pacing, and loop.md<\/h2>\n
\"A<\/figure>\n

\/\u74b0\u5f62<\/code> is a bundled skill<\/a>. Both arguments are optional, and what you give it decides how it behaves.<\/p>\n\n

\n\n
You type<\/th>What happens<\/th><\/tr><\/thead>\n
\/loop 5m check the deploy<\/code><\/td>Your prompt runs on a fixed schedule (converted to cron)<\/td><\/tr>\n
\/loop check the deploy<\/code><\/td>Self-paced: Claude picks a delay between 1 minute and 1 hour after each pass<\/td><\/tr>\n
\/\u74b0\u5f62<\/code> \u6216\u8005 \/loop 15m<\/code><\/td>Runs your loop.md<\/code> if you have one, otherwise the built-in maintenance prompt<\/td><\/tr>\n<\/tbody><\/table><\/figure>\n\n

Fixed interval<\/h3>\n

Give it an interval and Claude turns it into a cron expression, schedules it, and confirms the job ID. Units are s<\/code>, m<\/code>, h<\/code> \u548c d<\/code>. The interval can come first (30m<\/code>) or last (“every 2 hours”). Seconds round up to a full minute, because cron can’t schedule anything finer than one minute. Intervals that don’t divide cleanly, like 7m<\/code> \u6216\u8005 90m<\/code>, get rounded to the nearest one that does, and Claude tells you which one it picked.<\/p>\n\n

Self-paced<\/h3>\n

Leave the interval out and Claude chooses the gap each time, based on what it saw. It waits less while a build is finishing and longer when nothing is happening. It prints the delay and the reason at the end of every pass, so you can see its thinking. A self-paced loop can also end itself once the work is done. Under the hood, Claude calls its ScheduleWakeup<\/code> tool with stop: true<\/code>. If a pass ends without either scheduling the next one or stopping, Claude Code sets one backup wakeup about 20 minutes later. If that pass doesn’t schedule anything either, the loop ends.<\/p>\n\n

Bare \/loop and loop.md<\/h3>\n

A bare \/\u74b0\u5f62<\/code> runs a built-in maintenance prompt. It finishes unfinished work, looks after the current branch’s PR (review comments, failed CI, merge conflicts), then does cleanup like bug hunts. It won’t start new projects. Risky steps like pushing or deleting only go ahead if the conversation already approved them.<\/p>\n

To use your own default prompt, create .claude\/loop.md<\/code> \uff08\u6295\u5f71\u5100 ~\/.claude\/loop.md<\/code> (user). The project file wins if both exist. Write it like you’re typing the prompt. Changes take effect on the next pass, so you can adjust it while the loop runs. Anything past 25,000 bytes gets cut off.<\/p>\n\n

You can also loop a skill: \/loop 20m \/review-pr 1234<\/code>. There’s a catch, though. A scheduled run only executes skills Claude is allowed to call on its own<\/em>. Built-in commands like \/model<\/code>, skills marked disable-model-invocation: true<\/code>, and MCP prompts arrive as plain text instead of running. If your looped skill “does nothing”, check that first.<\/p>\n\n

Stopping it<\/h3>\n

This one catches people out. A self-paced<\/strong> loop stops when you press Esc<\/code> while it’s waiting. A fixed-interval<\/strong> loop ignores Esc<\/code> \u548c Ctrl+C<\/code>. You have to ask Claude to cancel it (“cancel the deploy check loop”), or it runs until the seven-day expiry. The tools underneath are CronCreate<\/code>, CronList<\/code> \u548c CronDelete<\/code>. Each task gets an 8-character ID, and one session can hold up to 50.<\/p>\n\n

The Fine Print: Jitter, the 7-Day Expiry, and What Happens When You Close the Lid<\/h2>\n
\"An<\/figure>\n

Most of the top-ranking guides for this term skip these limits. Every one of them matters if you’re tempted to treat \/\u74b0\u5f62<\/code> as a scheduler.<\/p>\n\n

\n\n
\u884c\u70ba<\/th>What the docs say (Oct 2026)<\/th>\u9019\u5c0d\u4f60\u610f\u5473\u8457\u4ec0\u9ebc<\/th><\/tr><\/thead>\n
Session must be open<\/td>Tasks only fire while Claude Code is running and idle<\/td>Close the terminal and the loop stops. A background session can carry it.<\/td><\/tr>\n
Busy session<\/td>A due prompt waits until the current turn ends<\/td>Your “every 5 minutes” can slip while Claude is mid-task<\/td><\/tr>\n
Missed runs<\/td>No catch-up: fires once when idle, not once per missed interval<\/td>Don’t use it for anything that has to count runs<\/td><\/tr>\n
Jitter (recurring)<\/td>Runs late by up to half the gap, capped at 30 minutes. Hourly or daily runs start 0\u201330 min late.<\/td>A “9am” daily check might run at 9:27<\/td><\/tr>\n
Jitter (every 5 min)<\/td>*\/5<\/code> runs 4m45s after the previous run<\/td>Fast polls stay tight (they beat the 5-minute prompt cache)<\/td><\/tr>\n
One-shot on :00 or :30<\/td>Can run up to 90 seconds early<\/td>Schedule reminders at odd minutes like 3 9 * * *<\/code><\/td><\/tr>\n
Expiry<\/td>Recurring tasks fire one last time and delete themselves 7 days after creation<\/td>A weekly-forever job isn’t possible here<\/td><\/tr>\n
Resume<\/td>Cron tasks are restored on --resume<\/code>; a self-paced \/\u74b0\u5f62<\/code> is not<\/td>Re-run \/\u74b0\u5f62<\/code> after a restart<\/td><\/tr>\n
\u7d42\u6b62\u958b\u95dc<\/td>CLAUDE_CODE_DISABLE_CRON=1<\/code> disables the scheduler and \/\u74b0\u5f62<\/code><\/td>Useful in shared or CI environments<\/td><\/tr>\n<\/tbody><\/table><\/figure>\n\n

Times use your local timezone<\/strong>, not UTC. The docs’ own comparison table sets the floor at one minute for \/\u74b0\u5f62<\/code>, one hour for cloud scheduled tasks, and one minute for Desktop tasks when Claude sets them (one hour in the form).<\/p>\n\n

The seven-day expiry is a feature, not a bug. It’s there so a loop you forgot about can’t burn tokens for a month. If that limit annoys you, your job needs the outer loop.<\/p><\/blockquote>\n\n

Here’s the expiry against my own calendar. This container has been running for 137 days. A \/\u74b0\u5f62<\/code> doing the same work would have expired and needed recreating about 19 times, and only while a terminal was open the whole time.<\/p>\n\n