Claude Code got a significant update on April 14. The headline feature is Routines — a way to define an AI task once and have it run automatically on a schedule, triggered by an API call, or fired by a GitHub event. It runs on Anthropic's infrastructure, so your machine doesn't need to be online.
This is in research preview right now, but the core capability is live for Pro, Max, Team, and Enterprise subscribers. Here's what it actually is and where it fits.
What a Routine actually is
A Routine is three things packaged together: a prompt, one or more connected repositories, and a set of connectors (integrations like GitHub or Slack). You configure it once. After that, it runs whenever its trigger fires.
The key part: Routines run on Anthropic's cloud infrastructure. This matters because previous Claude Code automation required your session to be active. With Routines, you can have tasks run at 3am, on a webhook, or on a GitHub event — none of which require you or your machine to be involved.
You create a Routine from claude.ai/code or by typing /schedule in the Claude Code CLI.
The three trigger types
Scheduled
The most straightforward. Pick a cadence — hourly, daily, weekdays, weekly — or write a custom cron expression if you need something more specific. The Routine runs at the interval you set.
Good for:
- Nightly repository health checks
- Weekly documentation drift detection (flags API docs that no longer match the actual code)
- Daily backlog triage that posts a summary to Slack before standup
API
Every Routine gets its own endpoint and auth token. Hit the endpoint and the Routine runs. That's it.
This opens up a lot: you can trigger Claude Code tasks from any tool that can make an HTTP request — Zapier, n8n, Make, your own application, a webhook from another service. The AI task becomes a callable service rather than something you have to manually kick off.
GitHub
Install the Claude GitHub App and a Routine can fire automatically on repository events — a pull request opened, a push to a branch, an issue created. Claude Code then runs your prompt against the relevant context.
Practical examples: when a PR is opened, run a code review routine and post findings as a comment. When a push hits main, run a deploy verification pass. When an issue is labelled "bug", run a triage routine that tries to reproduce the problem and surfaces relevant code.
One note: the GitHub App installation is a separate step from the /web-setup command. The web setup grants repository access for cloning but doesn't install the webhook handler. You need both for GitHub triggers to work.
What people are actually using it for
A few patterns that have emerged in the research preview:
Deploy verification. A Routine runs after CI completes, scans the output for error patterns, and posts a structured report. Replaces the manual "check the build" step that someone has to remember to do.
Nightly backlog triage. Summarises new GitHub issues from the last 24 hours, categorises them, and posts the digest to a Slack channel before the team starts the day. Something that used to require a dedicated tool or manual effort becomes a five-minute Routine setup.
Documentation drift detection. On a weekly schedule, Claude scans the codebase and flags places where the documented API behaviour no longer matches the implementation. The kind of maintenance task that almost never happens because no one has time — now it happens automatically.
Cross-language porting. When a Python SDK PR is merged, a GitHub-triggered Routine drafts the equivalent changes for a Go SDK and opens a draft PR. Not production-ready without review, but dramatically reduces the manual effort of keeping language SDKs in sync.
The limits
Daily run limits apply per plan tier:
- Pro: 5 runs/day
- Max: 15 runs/day
- Team / Enterprise: 25 runs/day
These limits are across all your Routines combined, not per Routine. If you have five daily scheduled tasks and you're on Pro, that's your full allocation used by morning. The limits are likely to evolve as the research preview matures.
Routines are currently in research preview, which means rough edges, potential changes to the API, and limited support. Worth using and building on, but don't put mission-critical unattended automation on it yet without a fallback.
How this fits with existing automation tools
The honest comparison: Routines are doing something adjacent to what n8n, Zapier, or Make do for workflow automation — but with Claude Code as the execution engine. The difference is the nature of the tasks.
Traditional automation tools excel at structured, deterministic workflows: if this happens, do that, transform this data, post to that endpoint. They're great at connecting APIs and moving data between services.
Routines are better suited for tasks that require judgement — reading code and understanding whether something looks right, synthesising a document into a meaningful summary, triaging issues by understanding their nature rather than their labels. Tasks where you'd otherwise need a human or a carefully fine-tuned model.
They're not competing. A well-architected automation might use n8n to handle the orchestration and data routing, with a Claude Code Routine handling the parts that require reading and reasoning.
Getting started
The path in:
- Open claude.ai/code or the Claude Code desktop app
- Navigate to Routines in the sidebar
- Create a new Routine — give it a name, connect a repository, write your prompt
- Set your trigger (schedule, API, or GitHub)
- For GitHub triggers: install the Claude GitHub App separately when prompted
For schedule triggers, /schedule in the CLI also works and lets you set custom cron expressions directly.
Start with something low-stakes — a weekly summary of open issues, a daily health check on a non-critical repo. Get a feel for how Routines behave before wiring them into anything load-bearing.
The underlying capability — AI tasks that run unattended, reliably, without requiring your session to be active — is genuinely useful. The research preview framing is honest: it's not polished yet. But the shape of what it enables is clear, and it's worth understanding now rather than later.
Sources: