
Claude Lazy Starter, for Claude Pro and Max
Claude Lazy Starter keeps a Claude usage window running while you sleep, so the time you already pay for is waiting when you sit down, with a fresh window right behind it.
Claude Pro and Max plans meter usage in five hour windows. A window only begins when you send your first message, so the clock sits idle whenever you do. Sleep through a reset and those hours are simply gone.
The trick. Lazy Starter sends one short message, a plain Hi, soon after each window ends. The next window starts on its own in the middle of the night. By the time you wake, the clock has run most of it down but you have not. You spend what is left, and the moment it ends a brand new five hour window opens.
Official tools only. The message goes through Claude Code, the command line tool from Anthropic, signed in with your own subscription. Claude Code and the Claude apps share one usage window, so a Hi from Claude Code starts your window everywhere. No browser automation and no scraped sessions.
Runs while your laptop sleeps. A scheduled GitHub Actions workflow sends the Hi once an hour from GitHub’s servers. It costs nothing, needs no server of your own, and your token stays in your own repository as an encrypted secret.
How it works
Take one ordinary night. You use up your window late in the evening, and it ends at 3:00 am while you sleep. On your own, the next window waits for you to start it. With Lazy Starter, it is already running by the time you wake up.
Claude time unlocked
0 hours
11:00 pm. Deep in a project, he hits his usage limit.
Usage
0%
One night with Lazy Starter, drawn in code. Drag the bar to scrub through the hours.
On your own
The window sits idle until you start it at 7:00 am.
With Lazy Starter
A Hi at 3:07 am starts the window, and a fresh one follows at 8:07.
- Asleep
- Idle and wasted
- Started for you
- A full window
| On your own | With Lazy Starter | |
|---|---|---|
When the next window starts After your limit resets | Whenever you send your first message | Within an hour of the last one ending |
Waiting when you wake At 7:00 am | Nothing running yet | About an hour left on a running window |
Your next fresh window A full five hours | Starts when you begin, ends at noon | Opens at 8:07 am, right after the first |
Effort Each day | Remember to start it | None |
A night, hour by hour. The workflow runs at seven minutes past every hour. If a window is already running, the Hi just uses a sliver of it and nothing resets. If your window has ended, it starts the next one.
- 11:00 pm
- You hit your limit and go to sleep.
- 3:00 am
- Your window ends. Nothing is running.
- 3:07 am
- The hourly run sends Hi. A new window starts and runs until 8:07 am.
- 7:00 am
- You wake up with an hour left on that window.
- 8:07 am
- That window ends. Your next message starts a full five hour window.
Set it up
You need a Claude Pro or Max plan and Claude Code. Open Claude Code in any folder, paste the prompt below, and follow along. Claude checks your computer and installs the GitHub CLI if it is missing, walks you through signing in to GitHub, creates a private repository, adds the workflow, and runs it once to check. The two sign ins happen in your own browser, and you save your token yourself, so it never passes through the chat.
Set up Claude Lazy Starter for me. It keeps my Claude usage window running by sending a tiny "Hi" through Claude Code once an hour from GitHub Actions, so a fresh five hour window starts even while I sleep.
Work through these steps one at a time. Tell me what you are doing, check each step really worked before moving on, and fix anything that is missing instead of stopping. Whenever I need to type something myself, give me the exact command to copy and wait until I say it is done.
1. Check my computer. Find out my operating system. Check that the GitHub CLI (gh) is installed with gh --version. If it is missing, install it for me: on macOS use brew install gh (if Homebrew itself is missing, give me the official Homebrew install command to run in my own terminal, because it needs my password); on Windows use winget install --id GitHub.cli; on Linux follow the official instructions at cli.github.com. Then confirm gh --version works.
2. Sign me in to GitHub. Run gh auth status. If I am not signed in, or the token does not include the workflow scope, ask me to run this in a separate terminal window and finish the sign in in my browser:
gh auth login --hostname github.com --git-protocol https --web --scopes workflow
(If I am already signed in but only the workflow scope is missing, ask me to run gh auth refresh --hostname github.com --scopes workflow instead.) If I do not have a GitHub account, tell me to create a free one at github.com/signup first. When I am done, run gh auth status again and find my username with gh api user --jq .login.
3. Create a private GitHub repository named claude-lazy-starter-runner in my account with gh repo create claude-lazy-starter-runner --private --add-readme. Repository names ignore capital letters, so first check with gh repo view MY_USERNAME/claude-lazy-starter-runner. If a repository with that name already exists, only reuse it if it is private and was made for this; otherwise never touch it and pick a new name like claude-lazy-starter-runner-2. Never put the workflow or the token in a public repository.
4. Add the file .github/workflows/lazy-start.yml to that repository with exactly the content below. Upload it with the GitHub API (gh api, the repository contents endpoint, base64 encoded content) so git is not needed. If the file already exists, update it. Then confirm it shows up with gh workflow list --repo MY_USERNAME/claude-lazy-starter-runner.
```yaml
# Keeps a Claude usage window always running, even while your computer sleeps.
#
# Every hour it sends one tiny message through the official Claude Code CLI on
# your subscription. Claude Pro and Max share one five hour window across
# claude.ai and Claude Code, so if the window has ended this starts a fresh one,
# and if a window is already running the ping simply uses a sliver of it.
#
# Setup, once:
# 1. On your computer run: claude setup-token
# 2. Add the printed token as a repository secret named CLAUDE_CODE_OAUTH_TOKEN
# (Settings, Secrets and variables, Actions, New repository secret).
# 3. Optional repository variables: LAZY_MESSAGE (default "Hi") and
# LAZY_MODEL (default "haiku").
name: Lazy start
on:
schedule:
# Minute 7 of every hour. GitHub may run scheduled jobs a few minutes late.
- cron: "7 * * * *"
workflow_dispatch:
concurrency:
group: lazy-start
cancel-in-progress: false
jobs:
ping:
runs-on: ubuntu-latest
timeout-minutes: 5
steps:
- name: Check the token is configured
env:
CLAUDE_CODE_OAUTH_TOKEN: ${{ secrets.CLAUDE_CODE_OAUTH_TOKEN }}
run: |
if [ -z "$CLAUDE_CODE_OAUTH_TOKEN" ]; then
echo "::error::Add the CLAUDE_CODE_OAUTH_TOKEN secret (run: claude setup-token)."
exit 1
fi
- uses: actions/setup-node@v4
with:
node-version: 22
- name: Install Claude Code
run: npm install -g @anthropic-ai/claude-code
- name: Start the window
env:
CLAUDE_CODE_OAUTH_TOKEN: ${{ secrets.CLAUDE_CODE_OAUTH_TOKEN }}
LAZY_MESSAGE: ${{ vars.LAZY_MESSAGE || 'Hi' }}
LAZY_MODEL: ${{ vars.LAZY_MODEL || 'haiku' }}
run: |
set +e
out=$(claude -p "$LAZY_MESSAGE" --model "$LAZY_MODEL" --tools "" \
--no-session-persistence --output-format json 2>&1)
code=$?
echo "$out" | head -c 2000
echo
if [ $code -ne 0 ] || echo "$out" | grep -q '"is_error":true'; then
if echo "$out" | grep -qiE 'usage limit|rate limit|limit reached'; then
echo "Window still exhausted; the next hourly run will start it."
exit 0
fi
echo "::error::Claude Code could not send the message. If the token expired, run claude setup-token again and update the secret."
exit 1
fi
echo "Sent \"$LAZY_MESSAGE\". A usage window is running."
```
5. Create my Claude token. Ask me to run claude setup-token in a separate terminal window and finish the sign in in my browser with the Claude account that has my Pro or Max plan. It prints a long token. Do not ask me to paste the token into this chat.
6. Save the token in GitHub. Give me this exact command with my real username filled in, ask me to run it in that same terminal, and paste the token when it asks:
gh secret set CLAUDE_CODE_OAUTH_TOKEN --repo MY_USERNAME/claude-lazy-starter-runner
If pasting into the terminal does not work, have me add it on the GitHub website instead at https://github.com/MY_USERNAME/claude-lazy-starter-runner/settings/secrets/actions/new with the name CLAUDE_CODE_OAUTH_TOKEN. The token is long and wraps over several lines, so remind me to copy all of it. When I am done, check it with gh secret list --repo MY_USERNAME/claude-lazy-starter-runner (it only shows the name, never the value).
7. Test it. Start the workflow once with gh workflow run lazy-start.yml --repo MY_USERNAME/claude-lazy-starter-runner, wait a few seconds, find the run with gh run list, follow it with gh run watch, and tell me whether it succeeded. If it failed, read the logs with gh run view --log-failed, explain the problem in plain words (a 401 OAuth access token is invalid error means the token was copied incompletely, so have me create a new one and save it again), help me fix it, and run it again until it passes.
8. Finish by giving me the repository link and the Actions page link, and confirm it will now run every hour on its own. Tell me how to check it worked: the next morning, Settings then Usage on claude.ai should show my window resetting early in the day.That is all. From then on it runs every hour by itself. The prompt includes the full workflow, so you can read exactly what will run before you paste it.
Questions
What does Claude Lazy Starter actually do?
Once an hour it sends a short Hi to Claude on your behalf. If your usage window has ended, that starts the next one. Because a window only begins once you send something, starting it early means the five hour clock runs during hours you were not going to use anyway.
Why would I want my window to start while I sleep?
A usage window lasts a fixed length once it opens. If it refreshes at eight in the morning but you do not start until noon, those four hours are lost. Starting the window at refresh time shifts that time back toward your working day.
Does this use the Claude API?
No. It sends one short message through Claude Code, the official Claude command line tool, signed in with your own subscription. Claude Code and the Claude app share the same usage window, so that one line starts your window everywhere. Nothing else is sent and your work never leaves your account.
Where is my token kept?
Only in your own GitHub repository, as an encrypted Actions secret. This site never sees it, and there is no shared server holding anyone's account. Each person runs the workflow in their own private repository.
Does the hourly message use up my limit?
Barely. Each run sends a single Hi on Haiku, the smallest model, which is a tiny slice of a window. If a window is already running the message simply uses a sliver of it; nothing resets.
Why every hour instead of the exact moment?
The workflow cannot see when your window ends, so it checks in every hour. That means a fresh window starts at most about an hour after the last one ends, while keeping the number of messages low.
Can I change the message or turn it off?
Yes. Set the LAZY_MESSAGE and LAZY_MODEL repository variables to change what is sent, or disable the Lazy start workflow from the Actions tab to pause it at any time.
Who makes Claude Lazy Starter?
Claude Lazy Starter is built by The Atom (theatom.lk). It is an independent project, not made by or affiliated with Anthropic. It only uses Claude Code, the official command line tool, with your own subscription.