Back to Lab

Claude Code Routines Run Your Automations in the Cloud

Running automations used to mean keeping a terminal open, babysitting cron jobs, or spinning up infrastructure just to repeat a task. Anthropic shipped something on April 14 that removes all of that friction. Claude Code Routines let you package a prompt, connect it to your repos, and run it on Anthropic's cloud infrastructure on a schedule or trigger. Your laptop can be closed. The work still gets done.

What a Routine Actually Is

A routine is a saved Claude Code configuration. It bundles three things: a prompt that defines the task, one or more repositories that provide context, and a set of connectors that give Claude access to external systems. You define it once. It runs automatically.

Think of it as a Claude Code session that you can replay without being present. The key difference from a manual session is that routines execute on Anthropic's servers, not your local machine. No terminal window required. No SSH session to maintain. No Docker container to manage.

This matters more than it sounds. Every developer has that list of things they run weekly but never automate properly. Checking CI output for flaky test patterns. Scanning dependency updates for breaking changes. Reviewing overnight alerts and triaging them by severity. These tasks are perfect for routines because they are repetitive, context-dependent, and too nuanced for a static script.

How Routines Differ From Agents

Anthropic now offers both Managed Agents and Routines, and the distinction matters. Managed Agents are long-running, persistent, and stateful. They maintain context across sessions and can handle complex multi-step workflows that evolve over time.

Routines are the opposite. They are short-lived and event-driven. A routine fires, executes its task, produces output, and shuts down. There is no persistent state between runs. Each execution starts fresh with the same prompt and connectors, but adapts its behavior based on what it finds in your repos and connected systems at that moment.

This design is intentional. Most automation tasks do not need memory between runs. A CI verification routine does not need to remember last week's build failures. It needs to look at today's output and flag what is wrong right now. The stateless model keeps routines fast, cheap, and predictable.

Setting Up Your First Routine

The setup flow lives inside Claude Code. You define the prompt that describes what the routine should do, connect the repos it needs access to, and configure any connectors for external services like GitHub, Slack, or your CI/CD pipeline.

Here is what a deployment verification routine might look like as a configuration:

name: Post-Deploy Verification
prompt: |
  Check the latest CI/CD output for the main branch.
  Scan for any errors, warnings, or test failures.
  If issues are found, create a summary with severity levels
  and suggest immediate fixes.
repositories:
  - my-org/production-api
connectors:
  - github
  - slack
schedule: "on-deploy"

Once configured, you choose when it runs. Options include scheduled intervals (like cron, but managed by Anthropic), webhook triggers from external systems, or manual execution when you want to run it on demand.

The real power is in the connectors. A routine with GitHub access can read pull requests, check CI status, and review code changes. Add Slack and it can post summaries to channels. Add your monitoring stack and it can correlate deploy events with error spikes.

Practical Use Cases

Anthropic highlighted two flagship use cases, but the real value is broader than their examples suggest.

CI/CD Verification. After every deploy, a routine scans CI output for errors, warnings, and test failures. Unlike a simple grep for "FAILED", Claude understands context. It can identify that a warning about a deprecated API call is more urgent than a flaky timeout, and it can explain why.

Alert Triage. Overnight alerts pile up. A routine can read them, cross-reference with recent commits, and produce a prioritized summary. Instead of starting your morning scrolling through 47 PagerDuty notifications, you get a ranked list with probable causes attached.

Dependency Auditing. Run a weekly routine that checks for outdated dependencies, security advisories, and breaking changes in upcoming major versions. Claude reads changelogs better than any static tool because it understands what "breaking" actually means for your specific codebase.

PR Review Prep. Before your team's review session, a routine can scan open PRs, summarize changes, flag potential issues, and check for consistent coding patterns. Not a replacement for human review, but a head start.

Documentation Drift. Code changes but docs do not. A routine that compares recent commits against documentation files can flag where the two have diverged.

Pricing and Plan Limits

Routines are available to all paid Claude Code subscribers. The daily execution limits scale with your plan:

| Plan | Runs per Day |

|------|-------------|

| Pro | 5 |

| Max | 15 |

| Team | 25 |

| Enterprise | 25 |

Overages incur additional charges, though Anthropic has not published specific overage rates yet. For most solo developers on Pro, 5 daily routines cover the essentials. If you need more, Max at 15 per day handles even aggressive automation setups.

The model must be web-enabled, which means routines use Anthropic's hosted infrastructure and are subject to the same usage policies as the standard Claude API.

Why This Matters for Solo Developers

If you run a one-person operation, routines close a real gap. Before this, automating Claude Code meant keeping a machine running, maintaining scripts, and handling authentication refreshes. Now you define the task once and it runs whether you are at your desk or not.

I see this as the difference between "I use AI to code faster" and "I have AI systems working while I sleep." That is a meaningful shift for anyone building products alone.

The 5-per-day limit on Pro might sound restrictive, but most solo workflows need at most 2 or 3 daily automations. A morning alert triage, a post-deploy check, and a weekly dependency scan cover the high-value territory.

The Desktop Redesign Connection

Routines launched alongside a redesigned Claude Code desktop application. The new desktop app includes an integrated terminal, faster diff viewer, in-app file editor, and expanded preview area. Multi-session support lets you run concurrent development tasks without juggling windows.

The timing is not a coincidence. Routines handle the automated work. The desktop redesign improves the interactive work. Together, they position Claude Code as a complete development environment rather than a CLI tool you open occasionally.

How Routines Compare to Existing Solutions

The obvious comparison is GitHub Actions, GitLab CI, or any scheduled pipeline runner. Those tools execute static scripts. They run the same commands every time regardless of context. If your CI output has a new warning pattern, you need to update the script to catch it.

Routines are fundamentally different because Claude reads and interprets on every run. A routine checking CI output does not look for hardcoded error strings. It reads the full output, understands what happened, and decides what matters. When a new warning category appears, it catches it without any configuration change.

The other comparison is to running Claude Code locally via cron. That works, but requires your machine to stay online, burns local compute, and creates a single point of failure tied to your hardware. Routines move that execution to Anthropic's infrastructure. Your machine's uptime no longer determines whether your automations run.

For teams that already have robust CI/CD pipelines, routines add a reasoning layer on top. They do not replace your pipeline. They watch it, interpret the output, and surface what humans need to see.

Limitations to Watch

Routines are in research preview, which means the feature is subject to change. A few things to consider before building critical workflows around them:

The stateless model means you cannot build routines that learn from previous runs. If you need that, Managed Agents are the right tool. Routines also depend on Anthropic's cloud availability. If their infrastructure has issues, your automations do not run.

Connector support is currently limited to a handful of integrations. Custom API connectors are not available yet, which restricts what external systems routines can interact with. This will likely expand, but today you work with what is available.

There is also no local fallback. If you hit your daily limit or Anthropic's service is down, you cannot redirect routine tasks to a local Claude Code session automatically. Plan for manual execution of critical tasks during outages.

Finally, routines consume the same token budgets as regular Claude Code usage. A routine that processes large repositories or long CI logs can use significant tokens per run. Monitor your usage during the first week to avoid surprises on your bill.

Getting Started

If you already use Claude Code, routines are available now inside the application. Look for the routines configuration in the settings panel. Start with something low-risk, like a daily summary of open issues or a post-deploy check. Once you trust the output, expand to more critical workflows.

My recommendation: pick the one task you do manually every morning that takes 10 minutes and could run before you open your laptop. Make that your first routine. For most developers, it is some form of "what happened overnight." Alerts, failed builds, new issues, dependency updates.

The best routine is one that replaces a task you currently do manually every day but never bothered to automate because the setup cost was too high. That cost just dropped to near zero. Five routines per day on Pro is enough to cover the highest-value automations. Start there and see what your mornings look like after a week.

Back to all articles