Claude Code Cloud Sessions: Claiming the $100/$250 Credit

Introduction: The Agent Shouldn't Stop When the Laptop Lid Closes#

Anyone who has run Claude Code on a real codebase knows the awkward pattern. You hand it a meaty task — upgrade a package across a monorepo, write the missing feature tests for a module, chase down a flaky queue job — and then you're tethered to the machine. Close the lid, lose Wi-Fi on the commute, or let the laptop sleep, and the session stalls. The agent is capable of working unattended for a long stretch; your hardware is the bottleneck.

On September 23, 2026, Anthropic moved Claude Code cloud sessions out of research preview and made them generally available. A cloud session is Claude Code running on Anthropic-hosted infrastructure instead of your own machine, so the work continues whether or not your computer is on. To get people to actually try it, Anthropic attached a sweetener: existing subscribers get a one-time credit of $100 on Pro and $250 on Max, usable only for cloud sessions.

The credit is the headline, but it's the less interesting part. The more important shift is that remote, unattended agent execution is now a stable, supported surface rather than a preview feature — which means it's worth building into how you work. This post covers what cloud sessions actually are, how to claim the credit before it lapses, how I'd set up an environment for a Laravel repo, and the fine print that the announcement skips over.

Technical Deep-Dive: What a Cloud Session Actually Is#

A VM per session, a branch per task#

Each cloud session runs inside a sandboxed virtual machine that Anthropic manages. It clones your repository from GitHub, works on its own branch, and pushes changes back so you review them as a normal diff or pull request. That's why a connected GitHub account is mandatory — the repo copy and the branch are the unit of work.

Anthropic documents approximate resource ceilings per session (subject to change):

That's comfortable for a typical PHP, Node, or Python web app with its test suite. It's not the place for a multi-gigabyte ML training job or a huge monorepo build that already struggles on a 32 GB workstation.

Cloud environments: network, secrets, and setup scripts#

Every session runs in a cloud environment, which you configure once and reuse. An environment controls four things:

1. Network access level — the default "Trusted" level lets sessions reach package registries and an allowlist of common domains, and nothing else. You can tighten it or add custom domains.
2. Environment variables — injected into the running session.
3. Stored API credentials (Pro and Max) — secrets the session can use without the model seeing their raw values.
4. A setup script — a Bash script that runs as root on Ubuntu 24.04 before Claude starts. Its resulting filesystem is cached and reused, so installs happen once rather than on every session.

The same environments apply wherever you start a session: the browser at claude.ai/code, the Code tab in the mobile app, the desktop app, or the terminal.

How GitHub access is handled#

A reasonable worry (and one that came up a lot in the reaction threads) is handing an AI agent your GitHub credentials. Anthropic's design routes GitHub operations through a proxy, so your token isn't placed inside the container. The built-in GitHub tools can read issues, list PRs, fetch diffs, and post comments without extra setup. If you need gh commands beyond that — gh workflow run, gh release — you install gh in the setup script and provide a scoped GH_TOKEN yourself. My advice: if you do that, use a fine-grained token limited to the specific repositories, not a classic token with org-wide scope.

Step-by-Step: Claiming the Credit and Running Your First Session#

Step 1: Confirm eligibility#

The offer targets existing Pro and Max subscribers, one credit per account. Pro gets $100, Max gets $250. It's a promotional balance, not a change to your plan price.

Step 2: Claim before the deadline#

You can claim from the link in Claude Code on the web (the popup there walks you through it) or from the CLI:

# Inside an interactive Claude Code session
/claim-credit

Per the in-product terms, the credit must be claimed by 11:59 PM PT on October 7, 2026, and it expires at 11:59 PM PT on November 4, 2026. Claiming and spending are two separate clocks — claim now even if you won't use it this week.

Step 3: Connect GitHub and create an environment#

If you already use the GitHub CLI locally, you can skip the browser onboarding entirely:

gh auth login        # if you aren't authenticated already
claude               # start Claude Code, then run:
/web-setup           # links your gh token and creates a default cloud environment

For a first project, the default environment is fine. For anything real, you'll want a setup script.

Step 4: Write a setup script for your stack#

Here's the shape of what I'd use for a Laravel application. The goal is that a fresh session can run php artisan test immediately without Claude spending its first ten minutes (and your credit) installing a toolchain.

#!/bin/bash
# Cloud environment setup script — runs once as root on Ubuntu 24.04,
# then the filesystem is cached for subsequent sessions.
set -euo pipefail

apt-get update -y

# PHP 8.3 is Ubuntu 24.04's default; add the extensions Laravel expects
apt-get install -y \
  php8.3-cli php8.3-mbstring php8.3-xml php8.3-curl \
  php8.3-sqlite3 php8.3-mysql php8.3-redis php8.3-zip php8.3-bcmath php8.3-intl \
  unzip composer

# Optional: gh for commands the built-in GitHub tools don't cover
apt-get install -y gh

php -v
composer --version

Two design choices worth calling out. First, the setup script installs tools, not project dependencies — composer install belongs in the session (or a SessionStart hook), because it depends on the branch's composer.lock, which can change per task. Second, I test against SQLite in memory in cloud sessions. It avoids provisioning MySQL inside the VM and keeps the feedback loop fast:

<!-- phpunit.xml -->
<php>
    <env name="APP_ENV" value="testing"/>
    <env name="DB_CONNECTION" value="sqlite"/>
    <env name="DB_DATABASE" value=":memory:"/>
    <env name="QUEUE_CONNECTION" value="sync"/>
    <env name="CACHE_STORE" value="array"/>
</php>

If your suite genuinely needs MySQL or Redis, Docker is available in cloud sessions and docker compose up works — just add docker compose pull to the setup script so the images are cached rather than downloaded every session.

Step 5: Tell Claude how the project works#

A CLAUDE.md at the repo root does more for cloud sessions than local ones, because you won't be there to answer "how do I run the tests?":

# CLAUDE.md
## Setup
- Run `composer install --no-interaction` at the start of every session.
- Copy `.env.example` to `.env` and run `php artisan key:generate`.

## Verification
- Tests: `php artisan test --parallel`
- Static analysis: `./vendor/bin/phpstan analyse`
- Every change must pass both before you open a PR.

## Conventions
- Multi-tenant: every tenant-owned model uses the `BelongsToTenant` trait.
- Never edit existing migrations; create new ones.

Step 6: Start the session#

Start from claude.ai/code, the mobile app's Code tab, the desktop app, or the terminal:

claude --cloud

The credit applies automatically once a cloud session starts — there's no code to enter.

Pitfalls to Avoid#

The credit doesn't cover everything cloud-adjacent. It's for cloud sessions only. The in-product terms say it doesn't apply to Projects or Routines, even though routines also run in cloud environments.

Watch your Usage Credit and spend controls. Anthropic's general promotional-credit terms note that participating may enable Usage Credit on your account. Before you let a session run overnight, check your usage settings and set a spending limit you're comfortable with. Once the promo balance runs out or expires, cloud sessions fall back to your plan's regular usage — they don't stop, so you need to know what "falling back" means for your bill.

The credit is separate from your normal limits — use that deliberately. Anthropic has framed it as a way to keep working in the cloud when you hit a limit locally. That's genuinely useful near a weekly cap, but it also makes it easy to burn $100 on low-value tasks. Point it at work you've been deferring, not work you'd have done anyway.

Environment variables aren't visible to the setup script. Variables from the environment settings panel are injected when the session runs, not when the setup script executes. A setup step like mytool auth "$MYTOOL_API_KEY" will silently get an empty string. Authenticate tools at session time instead.

Mid-session installs don't persist. If Claude installs a package during a session, the next session won't have it. Anything you need repeatedly goes in the setup script.

Zero Data Retention orgs are excluded. If your organization has ZDR enabled, /web-setup and cloud session features aren't available.

Don't give it a task you can't verify. A cloud session produces a branch. If your repo has no tests, no linter, and no CI, you'll get a large diff you have to review by eye — which cancels most of the time you saved.

What I'd Actually Spend the Credit On#

The best candidates are tasks that are long, well-specified, and cheap to verify:

Poor candidates are anything requiring judgment calls you haven't written down: ambiguous product decisions, billing logic without tests, or architecture changes where the "right" answer lives in your head.

Key Takeaways#

• Cloud sessions are now a stable feature, not a preview. Claude Code can keep working on Anthropic's VMs while your laptop is closed.
• Claim the credit by October 7, 2026 (11:59 PM PT) via the web popup or /claim-credit. It expires November 4, and it's $100 on Pro, $250 on Max, one per account.
• GitHub is required, and GitHub operations go through a proxy so your token doesn't live in the container.
• Invest ten minutes in an environment: a cached setup script for your toolchain, a CLAUDE.md with verification commands, and a fast test configuration.
• Check spend controls first. When the credit runs out, sessions fall back to regular usage — know what that costs before you leave one running overnight.
• Spend it on verifiable work. Tests, upgrades, and static-analysis cleanup return the most value per dollar because you can trust the result without re-reading every line.