Claude Code Routines Explained: Automate Without Cron Jobs

Until now, automating your development workflow with Claude Code meant managing your own cron jobs, building your own infrastructure, and wiring together MCP servers yourself.

Routines in Claude Code, launched in research preview on April 14, 2026, removes all of that overhead. You write a prompt, connect a repo, set a trigger, and Claude Code runs the automation on Anthropic's cloud infrastructure with no dependency on your laptop being open.

‍

Key Takeaways

• A Routine is a Claude Code automation you configure once and run repeatedly: On a schedule, via an API call, or in response to a GitHub event. Your machine does not need to be on.
• Three trigger types ship today: Scheduled (hourly, nightly, weekly), API (any HTTP POST to a dedicated endpoint), and Webhook (GitHub repository events like PR opened or merged).
• Routines run on Claude Code's web infrastructure: The same cloud environment as claude.ai/code sessions. No local machine dependency, no cron job to maintain.
• Daily run limits apply by plan: Pro gets 5 routines/day, Max gets 15/day, and Team and Enterprise get 25/day. Extra routines beyond limits are available via extra usage billing.
• Routines ship pre-wired to your repos and connectors: You do not need to configure MCP servers separately for each automation. The tooling your Claude Code session already uses is available to your routines.
• Currently in research preview: Available today for Pro, Max, Team, and Enterprise users with Claude Code on the web enabled. Behaviour may be refined before general availability.

‍

Claude for Small Business

Claude for SMBs Founders

Most people open Claude and start typing. That works for one-off questions. It doesn't work for running a business. Do this once — this weekend.

Free Claude course for SMBs

‍

‍

What Problem Does Routines Solve?

Developers have already been using Claude Code to automate parts of the software development cycle: nightly triage, morning PR reviews, CI failure checks.

But until Routines, every one of those automations required the developer to manage the underlying infrastructure themselves. Cron jobs, cloud containers, MCP server configuration, and execution logging all had to be built and maintained before a single automated task could run.

• The barrier was never the AI logic: The blocker was always the plumbing around it. Most teams gave up on recurring automations not because Claude Code could not handle the task, but because setting up the infrastructure to run it reliably was a separate project.
• The most valuable automations were the hardest to build: Always-on tasks, overnight runs, and event-triggered responses required the most infrastructure. The ones that would save the most time cost the most to set up.
• Routines removes the overhead entirely: You define the automation once. Anthropic's infrastructure runs it. No servers to provision, no cron jobs to debug, no MCP configuration to duplicate across every new automation you want to add.

‍

What Is a Routine, Exactly?

A Routine is a Claude Code automation defined by three things: a prompt (what Claude should do), a repo (the codebase it works in), and connectors (the external tools it can access, such as GitHub, Linear, Slack, or Datadog). These are configured once and reused across every run.

Once configured, the Routine runs on a trigger. Claude opens a fresh session on Anthropic's cloud infrastructure for each run, executes the automation, and produces outputs (comments, PRs, summaries, Slack messages) without the developer needing to be present.

• Interactive sessions vs Routines: Interactive sessions are supervised. The developer watches, steers, and approves at each step. Routines are unsupervised by default. They run, complete, and surface results for review afterward.
• Usage billing: Routines draw down subscription token limits the same way interactive sessions do. A Routine running a long session on a large codebase consumes the same token budget as an equivalent interactive session, plus it counts against your daily run limit.
• Where to create them: From claude.ai/code in the web interface, or by typing /schedule in the CLI. Both routes create Routines on Claude Code's cloud infrastructure.

The distinction from a normal Claude Code session is not capability. It is presence. A Routine runs the same Claude Code you already use, on the same infrastructure, without requiring you to be there.

‍

The Three Types of Routines: Scheduled, API, and Webhook

Each trigger type maps to a different category of development workflow. Understanding which type fits your situation is the fastest path from "interesting feature" to "configured and running."

Scheduled Routines

A Scheduled Routine runs on a cadence: hourly, nightly, or weekly. You give Claude Code a prompt and a schedule. It runs at that time whether your machine is on or not.

Anthropic's official launch example:

"Every night at 2am: pull the top bug from Linear, attempt a fix, and open a draft PR."

• Nightly backlog triage: Label and assign new issues from GitHub Issues or Linear, then post a morning summary to the team's Slack channel. Zero developer time required on the day.
• Weekly docs drift scan: Flag documentation referencing APIs or interfaces changed in recent merged PRs, and open draft update PRs for the relevant pages before they fall further out of date.
• Morning PR review digest: Summarise open PRs by age, reviewer status, and merge readiness, posted to Slack before standup so the team walks in informed.

If you are already using /schedule in the Claude Code CLI, those tasks are now Scheduled Routines. The existing command creates a Routine under the hood. Nothing breaks.

‍

API Routines

An API Routine is triggered by an HTTP POST to a dedicated endpoint. Every Routine gets its own endpoint and authentication token. POST a message, get back a session URL. Any system that can make an HTTP request can trigger it, with no webhook configuration required.

Anthropic's official launch example:

"Read the alert payload, find the owning service, and post a triage summary to #oncall with a proposed first step."

• Deploy verification pipeline: Your CD system posts after each deployment. Claude runs smoke checks against the live build, scans error logs for regressions, and posts a go/no-go signal to the release Slack channel before the on-call engineer checks in.
• Alert triage integration: Point Datadog or PagerDuty at the Routine endpoint. Claude pulls the trace, correlates it with recent deployments and code changes, and has a draft fix ready before on-call opens the page.
• Feedback resolution: A docs feedback widget or internal reporting dashboard posts the report. Claude opens a session against the relevant repo with the issue in context, drafts the fix, and opens a PR for review.

The API trigger is the most flexible of the three. Any system with HTTP capabilities can wire into it without requiring GitHub access or a scheduler configuration.

‍

Webhook Routines (GitHub)

A Webhook Routine subscribes to GitHub repository events. You define filters (which events, which repos, which branches) and a prompt. Claude opens one session per matching event and continues feeding updates from that event, including follow-up comments and CI failures, to the same session.

Anthropic's official launch example:

"Please flag PRs that touch the /auth-provider module. Any changes to this module need to be summarized and posted to #auth-changes."

• Cross-language SDK sync: Every PR merged to a Python SDK triggers a Routine that ports the equivalent change to a parallel Go SDK and opens a matching PR, keeping SDK pairs in sync without manual effort.
• Bespoke pre-review checklist: On every PR opened, the Routine runs the team's own security and performance checklist and leaves inline comments before any human reviewer looks at the code. Reviewers receive PRs that have already been screened.
• Auth module change tracking: Any PR touching a sensitive module triggers a structured summary posted to the relevant Slack channel, so the owning team never misses a change to their code.

Anthropic has stated it plans to expand Webhook Routines to additional event sources beyond GitHub in the future. The timeline has not been confirmed.

‍

How Is Routines Different From /schedule and /loop?

Existing Claude Code users will recognise overlap with features they already use. The relationship is straightforward, but worth stating clearly.

/schedule in the CLI now creates a Scheduled Routine. It is the same feature under a unified name.

• No migration required: If you were already using /schedule, your existing tasks are now Routines automatically. The command continues to work and creates Scheduled Routines going forward. Nothing breaks and nothing needs to be reconfigured.
• /loop is a different concept: /loop is a long-running session pattern for keeping Claude Code active in the foreground on a single task. Routines are discrete, triggered, cloud-hosted automations. A /loop session runs while you are working at your machine. A Routine runs whether or not you are there.
• What Routines adds that neither had: API and Webhook trigger types. Previously, repeatable Claude Code tasks required a cron-like cadence or manual initiation. Routines can now be triggered programmatically by any system (CD pipeline, alerting tool, internal dashboard) or automatically by GitHub events, with no developer action required to start them.

The advancement is not in the AI capability. It is in the trigger infrastructure. Claude Code could already do all of these tasks in an interactive session. Routines is what makes those tasks run without you.

‍

What Are Teams Already Using Routines For?

Anthropic published early adopter patterns alongside the launch. These are the workflows where Routines delivers the clearest immediate value.

The common thread across all of them is recurring tasks that currently consume developer attention not because they require judgment, but because someone has to remember to run them.

• Nightly issue triage: New issues come in overnight. A Scheduled Routine labels them, assigns them by type, and posts a prioritised morning digest to Slack. The team starts the day informed rather than triaging from scratch.
• Docs drift detection: A weekly Routine scans merged PRs for API and interface changes, identifies documentation that references changed code, and opens draft update PRs. Documentation stays current without a manual audit cycle.
• Deploy verification: Every CD pipeline trigger fires the Routine endpoint. Claude checks the deployed build, scans logs for regressions, and posts a structured go/no-go to the release channel before the on-call engineer reviews.
• Alert pre-triage: Datadog or PagerDuty points at the API endpoint. By the time on-call opens the alert, Claude has correlated it with recent deployments, identified the probable owning service, and drafted a first-response step.
• SDK pair synchronisation: A PR merged to one SDK automatically triggers a Routine that ports the change to a parallel SDK in another language and opens a matching PR. Cross-language SDK pairs stay in sync without a dedicated maintenance task.
• Pre-review code screening: On every PR opened, a Webhook Routine runs the team's own checklist and posts inline comments. Human reviewers start from a pre-screened PR rather than a blank slate.

‍

What Are the Plan Limits for Routines?

Routines access requires Claude Code on the web to be enabled. The Free plan does not include Claude Code access, so Routines are not available on Free.

Daily run limits vary by plan and are separate from the subscription token limits that also apply.

• Pro plan: 5 routines per day
• Max plan: 15 routines per day
• Team and Enterprise plans: 25 routines per day
• Extra usage: All plan tiers can run additional Routines beyond their daily limit via Anthropic's extra usage billing. Standard API token rates apply with no hard cap beyond the extra usage setting you configure.

The daily run limit and the token limit are independent. A Routine can fail to start because the daily run limit is exhausted, or it can stop mid-run because the session consumed the remaining token budget.

For teams relying on specific Routines firing at specific times, it is worth planning the daily run order and monitoring token consumption.

Creating Routines is available from claude.ai/code in the web interface or via the /schedule command in the CLI.

‍

How Does a Routine Access Your Repos and Tools?

The connectivity model is the most important thing to understand before setting up a Routine that writes code, opens PRs, or posts to Slack.

Each Routine is configured with specific repository access and runs in isolation on Anthropic's cloud infrastructure for each trigger.

• Repo access: Each Routine references one or more repos. Claude opens a session with read and write access to those repos through the same permissions as your connected Claude Code environment, covering reading code, writing changes, and opening PRs.
• Connectors: Routines ship pre-connected to any connectors you have already configured in your Claude Code environment, including GitHub, Linear, Slack, Datadog, and others. You do not configure MCP server access separately for each Routine. The tooling your sessions already use is automatically available.
• Session isolation: Each Routine run opens a fresh session. Sessions are isolated from each other and from your local machine. Outputs (PRs, Slack messages, comments) are produced through the connected tool APIs.
• API Routine security: Each API Routine gets its own dedicated endpoint and authentication token. Only requests with the correct token trigger the Routine. Tokens are managed through the Claude Code web interface.

The practical implication: if you have GitHub and Slack connected to your Claude Code environment, a new Routine you create can use both from the moment you configure it, without additional setup.

‍

Who Should Use Routines and Who Should Wait?

Routines launched today as a research preview. The feature is usable and available now, but behaviour may be refined before general availability. That distinction matters for how you use it.

The right approach is to start with low-stakes automations, validate the run behaviour, and expand to more critical workflows once the feature stabilises.

• Use Routines now if: You are already using Claude Code daily and you have recurring tasks you currently run manually or via separate infrastructure. Nightly triage, PR review, CI monitoring, and docs drift detection are all well-suited to start with.
• Strong fit for: Development teams managing cross-repo workflows, teams running CI/CD pipelines who want AI-assisted deploy verification, and on-call engineers who want pre-triaged alerts rather than raw incident data.
• Proceed cautiously if: Your team has strict data governance requirements or needs Zero Data Retention. Routines run on Anthropic's cloud infrastructure and are subject to standard data retention policy. ZDR-required environments should not use Routines at this time.
• Do not build critical pipelines yet: Research preview means Anthropic may adjust behaviour, limits, or pricing before general availability. Teams should not build mission-critical, non-reviewable production pipelines on a research preview feature without monitoring for changes actively.

The research preview status is not a reason to ignore Routines. It is a reason to experiment deliberately rather than automate blindly.

‍

Conclusion

Routines is the feature that turns Claude Code from a tool you run into a system that runs for you.

Scheduled automations, event-driven responses, and API-triggered workflows are now first-class Claude Code features, not DIY infrastructure problems.

For developers who already use Claude Code daily, Routines converts the most time-consuming recurring tasks into set-and-review automations with minimal configuration overhead.

‍

Claude for Small Business

Claude for SMBs Founders

Most people open Claude and start typing. That works for one-off questions. It doesn't work for running a business. Do this once — this weekend.

Free Claude course for SMBs

‍

‍

Want Help Building Scalable Apps with Claude Code?

At LowCode Agency, we are a strategic product team, not a dev shop. We help development teams design, configure, and deploy Claude Code Routines across scheduling, API integration, and GitHub automation workflows, from first configuration to production-ready automation.

• Routine architecture design: We map your recurring development tasks, identify which trigger type fits each one, and design the prompt and connector configuration before you write a single line of setup.
• API Routine integration: We wire your existing CD pipelines, alerting tools, and internal dashboards to API Routine endpoints so automations fire from your existing systems without manual intervention.
• GitHub Webhook configuration: We design Webhook Routines for your PR review, merge tracking, and cross-repo sync workflows, including the filter logic that ensures Claude only fires on the events that matter.
• Scheduled automation setup: We configure nightly triage, weekly docs drift, and morning digest Routines with the prompt engineering that produces outputs your team can act on immediately.
• Usage and limits planning: We design your Routine set to stay within plan limits, prioritise the most critical automations, and set up extra usage billing where needed so nothing critical stops mid-run.
• Testing and calibration: We run your Routines against real repo data, review the output quality, and refine the prompts and connector configuration before any automation touches your production environment.
• Full product team: Strategy, design, development, and QA from a single team invested in your automation working reliably, not just getting configured.

We have built 350+ products for clients including Coca-Cola, American Express, and Medtronic. We are an Anthropic Claude Partner Network member and work with Claude Code and the broader Claude toolset as a core part of how we deliver for clients.

If you want help getting Routines configured correctly and running in your development workflow from day one, let's scope it together.