Claude Lazy Starter

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.

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.

Window ends
You start
12 am6 am12 pm6 pm12 am

With Lazy Starter

A Hi at 3:07 am starts the window, and a fresh one follows at 8:07.

Hi sent
Fresh window
12 am6 am12 pm6 pm12 am
  • Asleep
  • Idle and wasted
  • Started for you
  • A full window
Same night, same plan. Starting the window while you sleep moves your next fresh window four hours earlier into the day.
On your ownWith Lazy Starter

When the next window starts

After your limit resets

Whenever you send your first messageWithin an hour of the last one ending

Waiting when you wake

At 7:00 am

Nothing running yetAbout an hour left on a running window

Your next fresh window

A full five hours

Starts when you begin, ends at noonOpens at 8:07 am, right after the first

Effort

Each day

Remember to start itNone

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.

Paste into Claude Code
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.

Wake up to time already waiting

A few minutes of setup, then it runs every hour on its own, free, in your own GitHub account.