Claude Code is no longer just a tool you open when you need help. With scheduled tasks and routines, it can now run automatically on a schedule, from an API call, or in response to GitHub events — even when your computer is off.
Combined with skills, this turns Claude Code from an on-demand assistant into an automated member of your development team.
Quick Answer: Claude Code scheduled tasks allow automated code operations on Anthropic's cloud without user intervention, triggered by schedules, events, or API calls, and enhanced by specialized skills for tasks like automated code review or nightly test coverage checks.
What scheduled tasks are
A scheduled task is a Claude Code session that runs on Anthropic's cloud infrastructure without your machine being involved. You define:
- A prompt (what Claude should do)
- A repo (which codebase to work on)
- A schedule (when it should run)
- Connectors (what services it needs access to)
Claude clones the repo, runs the task, creates a session you can inspect, and can even open a pull request with its changes.
This runs on Anthropic's infrastructure, not yours. Your laptop can be off. You can be asleep.
What routines add
Routines extend scheduled tasks with three trigger types:
Schedule-based. Run every morning at 9 AM, every Monday, every hour. Classic cron-style automation.
Event-based. Trigger on GitHub webhooks — new PR opened, issue created, branch pushed. Claude responds to events in real-time.
API-triggered. Call an API endpoint from your own code to trigger a routine. Integrate Claude Code into your existing automation pipelines.
Why skills make routines powerful
A routine without skills is a generic Claude Code session running a prompt. A routine with skills is an expert running a specialized workflow.
Automated code review on every PR
Routine trigger: GitHub webhook — new pull request opened.
Skill: A code review skill that checks for security vulnerabilities, logic errors, performance issues, and style violations. The skill knows your team's conventions — which patterns to flag, which to approve, what severity levels mean in your context.
Result: Every PR gets a thorough review within minutes of opening. The review follows your team's actual standards, not generic suggestions. Claude posts its findings as PR comments.
Without the skill, Claude does a generic review. With the skill, it checks the things your team actually cares about.
Nightly test coverage checks
Routine trigger: Schedule — every night at midnight.
Skill: A testing skill that detects your framework, matches your assertion patterns, and identifies untested functions.
Result: Every morning you have a PR adding tests for any new code that was committed without coverage. The tests match your existing test suite's style.
Weekly dependency audits
Routine trigger: Schedule — every Monday morning.
Skill: A security skill that checks dependencies for known vulnerabilities, outdated packages, and license issues.
Result: A weekly report or PR that updates vulnerable dependencies before they become a problem.
Documentation sync after merges
Routine trigger: GitHub webhook — push to main branch.
Skill: A documentation skill that knows your README format, your API doc structure, and your changelog conventions.
Result: Documentation stays in sync with code automatically. README installation steps update when dependencies change. API docs update when endpoints change. Changelog entries appear for every meaningful merge.
CI failure diagnosis
Routine trigger: GitHub webhook — check run failed.
Skill: A DevOps skill that understands your CI pipeline, common failure patterns, and environment configuration.
Result: When CI fails, Claude analyzes the failure, identifies the root cause, and either opens a fix PR or posts a diagnosis comment. Your team wakes up to solutions, not red builds.
Setting up a routine with skills
Step 1: Install the right skills
Make sure your skills are in the project's .claude/skills/ directory (not personal skills in ~/.claude/skills/). Routines run on Anthropic's cloud, so they only access project-level skills committed to the repo.
mkdir -p .claude/skills/our-code-review/
# Copy or create SKILL.md
git add .claude/skills/
git commit -m "Add code review skill for automated routines"
git push
Step 2: Create the routine
From Claude Code CLI:
/schedule
Or from the web interface or desktop app, create a new routine with:
- Prompt: "Review all open PRs for security issues and post findings as comments"
- Repo: your-org/your-repo
- Trigger: GitHub webhook — pull_request opened
- Connectors: GitHub (for posting comments)
Step 3: Verify
After the first trigger, inspect the routine's session to see what Claude did. Check the review quality. Adjust the skill instructions if needed. Each run starts from a fresh clone, so skill changes you push to the repo are picked up on the next run.
Skills to pair with routines
The most valuable routine skills are the ones covering tasks you currently do manually on a schedule:
| Task | Skill type | Trigger |
|---|---|---|
| PR review | Code review | PR opened |
| Test coverage | Testing | Nightly |
| Dependency audit | Security | Weekly |
| Docs sync | Documentation | Push to main |
| CI diagnosis | DevOps | Check run failed |
| Release notes | Git automation | Tag created |
Browse skills across all these categories at Agensi.
Skills delivered via MCP for routines
With Agensi's one-liner curl installer, your routines can fetch the latest version of a skill at runtime instead of requiring it in the repo. This means:
- Skills update without pushing to the repo (just re-run the curl command)
- New skills are available to routines the moment they publish
- Your agent picks the best skill for each task automatically