Claude Code Routines: A Practical Guide (2026)

Claude Code Routines are saved Claude Code configurations that run on a schedule, respond to API calls, or trigger on GitHub events. They run on Anthropic’s cloud infrastructure so your laptop can stay closed. After several months automating Claude Code workflows with Nimbalyst’s local automations, this is a practical guide to what Claude Code Routines actually do, the limits worth knowing about, and where to layer in additional tooling.

Claude Code Routines: Quick Answer

• What is a Claude Code Routine? A saved Claude Code configuration with a prompt, one or more repos, and connectors, triggered on a schedule, on GitHub events, or via API.
• Where do Claude Code Routines run? On Anthropic’s cloud infrastructure, not your machine. Cloned repo per run, no access to local environment.
• How many runs per day do you get? Anthropic currently enforces per-account daily routine caps during the research preview, but the exact allowance is account- and plan-dependent and can change.
• Best Claude Code Routine examples: Nightly issue triage, weekly documentation drift detection, PR-triggered code review.
• Claude Code Routines vs Nimbalyst automations: Routines are best for repo-centric, cloud-native work. Nimbalyst automations are best for workspace-level work that needs your local environment, extensions, or non-code artifacts.

A practical guide to setting up Claude Code Routines, the workflows that actually pay off, and the current limits follows.

What Claude Code Routines Actually Are

A Claude Code Routine is a saved Claude Code configuration. You specify three things:

1. A prompt that tells Claude what to do
2. One or more repositories for context
3. Connectors for external services (Slack, Linear, etc.)

Once configured, a Claude Code Routine can be triggered three ways:

• Scheduled: Hourly, daily, weekdays, or weekly
• API: POST to a per-routine HTTP endpoint with a bearer token
• GitHub: Automatically on repository events (pull requests, releases, pushes)

Each routine run creates a full Claude Code cloud session. No permission prompts, no approval flows during execution. The session can run shell commands, use skills from the repo, and call any connectors you’ve included.

The Workflows That Make Sense

After automating similar patterns for months, I’ve found three categories where scheduled AI agent work consistently delivers value.

Backlog and Issue Triage

Every morning, new issues and bug reports pile up. A routine can scan new issues nightly, apply labels based on content analysis, estimate priority based on affected components, and post a summary to Slack or Linear.

The practical version of this: set up a nightly routine that reads new GitHub issues, cross-references them against your codebase to identify affected modules, and posts a structured triage summary. The AI doesn’t just categorize, it reads the code and makes informed assessments about severity.

I run a version of this daily with Nimbalyst’s automations. The difference between doing this manually and having it automated is substantial. You walk into your morning with a pre-triaged backlog instead of an unstructured list.

Documentation Drift Detection

Docs go stale. Everyone knows this, and nobody has time to systematically check. A weekly routine can scan merged PRs, identify docs that reference changed APIs or modified interfaces, and open update PRs for the affected documentation.

This is one of the most practical applications because the cost of not doing it is invisible until someone hits outdated instructions. A routine that checks this weekly catches drift before it becomes a support burden.

Deploy Verification and Smoke Testing

After a deploy, a routine can run smoke checks against the new build, scan error logs and monitoring dashboards for regressions, and post a go/no-go assessment to your release channel.

This works best when you give the routine access to your monitoring connectors. It’s not replacing your test suite. It’s adding an AI-powered review layer that reads logs and metrics with more context than a simple threshold check.

Where Routines Have Limits

The current research preview has real constraints worth understanding before you build workflows around them.

Usage Caps

Routines currently have a per-account daily run cap during the research preview, on top of your normal Claude Code usage limits. Anthropic surfaces your current consumption and remaining runs in the routines UI and settings, and those allowances can change as the preview evolves.

The practical takeaway is the same: use routines for unattended, high-value work like nightly or weekly jobs, not for dozens of low-value triggers per day unless your account allowance clearly supports it.

No Interactive Feedback Loop

Routines run autonomously. There’s no mid-run approval step, no “pause and ask the developer” capability. This means they’re best suited for tasks where the output is a report, a PR, or a message, not tasks where the AI needs human judgment mid-process.

For tasks that require back-and-forth collaboration, you still want an interactive session. Routines are for the work you’d otherwise forget to do or deprioritize because it’s repetitive.

Cloud-Only Execution

Routines run on Anthropic’s infrastructure, which means they clone your repo and work in that environment. If your workflow depends on local tooling, local environment variables, or services only accessible from your network, a routine won’t have access to those.

This is where a local automation tool adds value. Nimbalyst’s automations, for example, run on your machine with full access to your local environment, extensions, and workspace context. The two approaches complement each other: Routines for cloud-native tasks, local automations for environment-dependent work.

Setting Up Your First Routine

Visit claude.ai/code/routines or type /schedule in the Claude Code CLI.

Start with something low-risk and high-value. My recommendation: documentation drift detection on a weekly schedule. Write a prompt like:

Scan all pull requests merged in the past 7 days. For each PR, identify any documentation files (README, docs/, wiki) that reference modified functions, APIs, or configuration options. If the documentation is outdated relative to the code changes, open a PR with suggested updates.

Connect it to your repository, set a weekly schedule, and let it run. Review the first few outputs carefully to calibrate the prompt, then let it operate.

Where Nimbalyst Automations Fit In

Full disclosure: I build Nimbalyst, which also has an automations feature. The two approaches solve different problems, and most teams will use both once Routines is generally available. A quick breakdown of when to reach for which:

• Reach for Claude Code Routines when the work is repo-centric, runs on a schedule or GitHub event, and doesn’t need your local environment. Nightly issue triage, weekly doc drift, PR-triggered code review.
• Reach for Nimbalyst automations when the work spans your full workspace (not just code), needs access to local tooling or extensions, or involves non-engineering artifacts like mockups, diagrams, data models, or planning docs.
• Cadence: Routines are subject to Anthropic’s current per-account preview limits. Local automations have no such cap.
• Context: Routines get a clean cloned repo. Nimbalyst automations get the live workspace state, including open tabs, pending reviews, and extension data.
• Handoff: Routines output to GitHub, Slack, or API endpoints. Nimbalyst automations can output directly into your workspace, including opening artifacts for review.

Neither replaces the other. Routines covers the cloud-native automation layer cleanly. Nimbalyst covers workspace-level automation that includes non-code work.

Building a Layered Automation Strategy

Routines are one layer of a broader automation approach. The most productive setup I’ve found uses multiple layers:

Layer 1: Event-driven routines for immediate response tasks. GitHub triggers that run on new PRs (code review, label application, checklist verification).

Layer 2: Scheduled routines for periodic maintenance. Nightly triage, weekly doc checks, daily dependency scanning.

Layer 3: Local automations for environment-specific work. Tasks that need access to your local workspace, custom tooling, running dev server, or project-specific extensions.

Layer 4: Interactive sessions for complex, judgment-heavy work. Architecture decisions, feature implementation, debugging sessions where the AI needs your input.

Each layer handles different types of work. Trying to push everything through one approach, whether that’s fully automated routines or fully interactive sessions, leaves gaps.

What This Means for AI-Assisted Development

The release of Routines is part of a broader pattern. In the first two weeks of April alone, Cursor shipped an agent-first workspace (Cursor 3), Windsurf launched an Agent Command Center with cloud Devin integration (Windsurf 2.0), and Anthropic redesigned Claude Code’s desktop app around parallel sessions with Routines.

All three are converging on the same idea: AI coding is moving from “assistant that helps you write code” to “agents you orchestrate and manage.” The developer’s role is shifting toward architecture, review, and coordination.

Routines represent the automation edge of this shift. Instead of manually starting a Claude Code session every morning to triage issues, you configure it once and let it run. The time you save compounds. A 15-minute daily triage routine saves you roughly 60 hours per year. A weekly documentation check prevents the slow accumulation of tech debt that eventually costs days of developer time.

The practical takeaway: start with one routine for your most repetitive, well-defined task. Run it for two weeks. Calibrate the prompt based on results. Then add a second. Build your automation layer incrementally rather than trying to automate everything at once.

Frequently Asked Questions

What are Claude Code Routines?

Claude Code Routines are saved Claude Code configurations that run on Anthropic’s cloud infrastructure. Each routine bundles a prompt, one or more repositories, and connectors like Slack or Linear. Routines can run on a schedule, on GitHub events such as pull requests or releases, or in response to API calls. They are designed for repo-centric automation that does not need your local environment.

How do I set up a Claude Code Routine?

Visit claude.ai/code/routines or run /schedule in the Claude Code CLI. You specify the prompt, repository, connectors, and trigger (schedule, GitHub event, or API endpoint). The first routine to try is documentation drift detection on a weekly schedule. It is low risk, high value, and gives you a feel for how the runs behave before you build anything more ambitious.

How many Claude Code Routines can I run per day?

Daily run caps depend on your account and plan, and Anthropic can change them during the research preview. Check the routines UI or Claude usage settings for the current number on your account. The safe evergreen rule is to reserve routines for unattended jobs with clear value, not for noisy high-frequency triggers unless your allowance supports it.

What is the difference between Claude Code Routines and Claude Code Skills?

Claude Code Routines are scheduled or event-driven cloud runs of a full Claude Code session. Claude Code Skills are reusable instruction packs that any Claude Code session can call into. A routine wraps a prompt and a trigger. A skill wraps a piece of expertise that the agent can use inside any session, including inside a routine.

What are good examples of Claude Code Routines?

The three Claude Code Routine examples that consistently deliver value are nightly issue triage (read new issues, label them, post a triage summary), weekly documentation drift detection (scan merged PRs and open update PRs for stale docs), and post-deploy verification (smoke checks plus log review with a go or no-go report). Each one runs on a daily or weekly cadence and produces a concrete artifact.

When should I use Nimbalyst automations instead of Claude Code Routines?

Use Nimbalyst automations when the work spans your full workspace and not just code, needs access to local tooling or extensions, or involves non-code artifacts like mockups, diagrams, or data models. Use Claude Code Routines for repo-centric, cloud-native work where Anthropic’s cloud environment is sufficient. Most teams use both. Routines cover the cloud automation layer. Nimbalyst automations cover workspace-level automation around the rest.