Yesterday, Anthropic shipped local scheduled tasks in Claude Code. Thariq’s announcement pulled 12K likes and 3.2M views. The feature is simple: /loop 5m check if the deployment finished. Cron for your AI agent.

Ten days ago, I wrote about Mitchell Hashimoto’s rule: always have an agent running. Not always coding. Sometimes just monitoring, researching, watching. /loop is the native primitive for exactly that workflow. The agent doesn’t need you watching it. It just needs a schedule and a prompt.

What /loop Does

/loop 5m check if the deployment is healthy
/loop 15m scan error logs and create PRs for fixable bugs
/loop 20m /review-pr 1234

Claude parses the interval, converts it to a cron expression, and fires the prompt repeatedly while your session stays open. Default interval is 10 minutes. Natural language works too: /loop check the build every 2 hours.

Under the hood, it’s three tools: CronCreate, CronList, CronDelete. You can also set one-time reminders: “remind me at 3pm to push the release branch.”

That last example is key. /loop 20m /review-pr 1234 runs another skill on a schedule. Any slash command becomes a recurring job. Scheduled prompts become orchestration.

Session-scoped

Tasks die when you close the terminal. No persistence across restarts. Auto-expire after 3 days. Max 50 per session. For durable scheduling, Claude Code Desktop offers persistent scheduled tasks. For unattended automation, use GitHub Actions with a schedule trigger.

Not Ralph Wiggum

If you’ve been following Ralph Wiggum, /loop looks familiar. Same lineage: Huntley’s bash loop became an official plugin, the playbook formalized the methodology, now the platform ships its own take. But they solve different problems.

  • Ralph Wiggum iterates toward completion. One task, many attempts, backpressure until convergence. “Migrate all tests from Jest to Vitest.” It’s a construction crew.
  • /loop polls on a schedule. Recurring checks, periodic monitoring, status awareness. “Check if the deploy is healthy every 5 minutes.” It’s a security camera.

Auto-monitoring pull requests with self-fixing capabilities. Generating morning Slack summaries.

— Boris Cherny, Claude Code creator

Boris’s examples reveal the intent. These aren’t deep autonomous work sessions. They’re recurring glances at state that might need attention.

Simpler and Native Wins

This is the third time I’ve documented this absorption cycle for the same feature family. Community builds a pattern. Anthropic absorbs it. The native version ships simpler.

Ralph Wiggum needs a plugin install, prompt engineering, iteration limits, completion promises, backpressure design. /loop needs one line. The native version ships with fewer moving parts because it can lean on internals the community can’t access.

That’s the recurring lesson from The Framework Trap and The External Scaffolding Era Is Ending. The platform didn’t absorb the whole Ralph Wiggum pattern. It factored out the “recurring execution” concern into its own primitive and shipped the minimal version. Ralph’s autonomous iteration model stays separate. Cleaner abstractions emerge when the platform has time to observe how the community actually uses the pattern.

The factoring matters

Ralph Wiggum combined two concerns: autonomous iteration and recurring execution. /loop separates them. The platform observed that most people using loops weren’t iterating toward completion. They were polling. So it shipped the primitive for polling.

What /loop Gets Right

  • Forgiving syntax. Leading interval, trailing interval, or omitted entirely. Low friction.
  • Composable. Any slash command or skill becomes a recurring job.
  • Jitter. Deterministic offsets prevent parallel sessions from hitting the API simultaneously. Small detail, production-quality thinking.
  • Three-day expiry. Forgotten cron jobs are a classic ops mistake. Auto-expiry is a safety net most cron implementations lack.

What It Doesn’t Solve

  • No persistence. Close the terminal, lose everything.
  • No catch-up. Missed intervals don’t queue. One fire when Claude becomes idle, regardless of how many were missed.
  • No backpressure. Ralph converges because failures feed back into the next iteration. /loop re-runs the same prompt blind. No mechanism to learn from previous runs.

Ralph Wiggum asks “are we done yet?” /loop asks “what’s happening now?” Different questions need different tools.

Where This Goes

Mitchell’s workflow points toward the answer. He always has an agent running: one coding, one planning, one researching. He interrupts the agent, not the other way around. /loop is the first native primitive that enables this without a bash while-loop in a spare terminal.

The interesting question: does /loop eventually absorb Ralph’s iteration model? Add a completion condition and it’s Ralph with better ergonomics. Add state persistence across firings and it’s the full playbook in a single command. Or maybe the factoring is right and monitoring and autonomous iteration are genuinely different concerns.

Either way, the pattern holds. Community builds it. Platform absorbs it. The simple version wins.

Cost awareness

/loop fires prompts on autopilot. A 5-minute loop running for 3 hours is 36 prompt executions. On a subscription plan, that accelerates your usage. On API billing, that’s real money. Start with longer intervals and tighten as needed.

Related Posts