Two Default-Model Changes Haven't Reached Claude Code's Stable Channel Yet

Step 2: Call the two one-line endpoints

Each channel's current target can be read from the public download server with a single request.

curl -s https://downloads.claude.ai/claude-code-releases/stable
# -> 2.1.277
curl -s https://downloads.claude.ai/claude-code-releases/latest
# -> 2.1.284

The response is plain text: just the version number. I ran these two lines by hand and looked at the output before touching the script. That is a rule I keep for myself — never call an endpoint for the first time from inside a script. A parser written against a response shape you haven't seen can't tell the day it works from the day it breaks.

The npm registry agrees. Its dist-tags list stable and latest, and this morning they read 2.1.277 and 2.1.284. The registry also carries the publish timestamp of every version under time, which is what I borrow for the day count.

Step 3: Write the script

Here is the whole thing. No third-party packages. Release-note headlines from GitHub are attached when available, but the version gap is printed even when they aren't.

#!/usr/bin/env python3
"""claude_channel_gap.py
Counts the gap between the stable and latest channels in real, published
releases, and lists the changes that haven't reached stable yet.
Standard library only.
"""
import json
import re
import subprocess
import sys
import urllib.request
from datetime import datetime
 
CHANNEL_URL = "https://downloads.claude.ai/claude-code-releases/{}"   # stable / latest, one line each
NPM_URL = "https://registry.npmjs.org/@anthropic-ai/claude-code"       # borrowed for publish timestamps (time)
GH_URL = "https://api.github.com/repos/anthropics/claude-code/releases?per_page=30"
 
def fetch(url, timeout=15):
    # GitHub's API may return 403 without a User-Agent, so always send one
    req = urllib.request.Request(url, headers={"User-Agent": "claude-channel-gap/1.0"})
    with urllib.request.urlopen(req, timeout=timeout) as r:
        return r.read().decode("utf-8")
 
def vkey(v):
    # "2.1.284" -> (2, 1, 284). As strings, "2.1.99" would sort above "2.1.284"
    return tuple(int(x) for x in v.split("."))
 
def installed_version():
    # return None on machines without claude so the script still runs
    try:
        out = subprocess.run(["claude", "--version"], capture_output=True, text=True, timeout=10).stdout
        m = re.search(r"\d+\.\d+\.\d+", out)
        return m.group(0) if m else None
    except (FileNotFoundError, subprocess.TimeoutExpired):
        return None
 
def main():
    quiet = "--quiet" in sys.argv
    stable = fetch(CHANNEL_URL.format("stable")).strip()
    latest = fetch(CHANNEL_URL.format("latest")).strip()
 
    npm = json.loads(fetch(NPM_URL))
    times = npm["time"]
    # keep only real x.y.z versions (drops pre-releases such as 2.1.284-beta), ascending
    versions = sorted((v for v in npm["versions"] if re.fullmatch(r"\d+\.\d+\.\d+", v)), key=vkey)
    between = [v for v in versions if vkey(stable) < vkey(v) <= vkey(latest)]
 
    def published(v):
        return datetime.fromisoformat(times[v].replace("Z", "+00:00"))
    lag_days = (published(latest) - published(stable)).days
    arithmetic = vkey(latest)[2] - vkey(stable)[2]   # what subtraction says; can differ from the real count
 
    notes = {}
    try:
        for r in json.loads(fetch(GH_URL)):
            v = r["tag_name"].lstrip("v")
            body = r.get("body") or ""
            first = next((l[2:].strip() for l in body.splitlines() if l.startswith("- ")), "")
            notes[v] = first
    except Exception as e:   # hitting the 60/hour limit must not hide the version gap
        print(f"(release notes skipped: {e})", file=sys.stderr)
 
    me = installed_version()
    if quiet:
        mine = f" installed={me}" if me else ""
        print(f"stable={stable} latest={latest} gap={len(between)}rel/{lag_days}d{mine}")
        return
 
    print(f"stable  {stable}  ({times[stable][:10]})")
    print(f"latest  {latest}  ({times[latest][:10]})")
    print(f"gap     {len(between)} releases / {lag_days} days   (arithmetic says {arithmetic})")
    if me:
        behind = [v for v in versions if vkey(me) < vkey(v) <= vkey(latest)]
        print(f"installed {me}: {len(behind)} releases behind latest")
    print("not yet on stable:")
    for v in between:
        print(f"  {v}  {times[v][:10]}  {notes.get(v, '(release notes not published yet)')[:100]}")
 
if __name__ == "__main__":
    main()

Three decisions are worth explaining.

First, the list of versions comes from the npm registry's versions, not from the download server. The download server only tells you where each channel points right now. To know what happened in between, you need a place where every real version is lined up. That is also how I noticed 2.1.279 doesn't exist.

Second, vkey turns each version into a tuple before comparing. Compared as strings, 2.1.99 is greater than 2.1.284. The first time I tripped on this, the gap came out negative and I stared at it for a while.

Third, the GitHub release-note fetch is wrapped in try and never stops the run. Unauthenticated GitHub API calls are capped at 60 per hour, and it's easy to hit that when other tools share the same address. Headlines are garnish; the version gap is the meal. Writing that priority into the code is what keeps the morning line from going missing.

Step 4: Run it and read the result

This is the unedited output from this morning.

stable  2.1.277  (2026-09-18)
latest  2.1.284  (2026-09-28)
gap     6 releases / 10 days   (arithmetic says 7)
installed 2.1.284: 0 releases behind latest
not yet on stable:
  2.1.278  2026-09-19  Changed auto mode for Claude API and Enterprise users, and on Bedrock, Vertex, Foundry and gateways,
  2.1.280  2026-09-22  Added Claude Opus 5.5 (`claude-opus-5-5`), now the default Opus model — 1M context, $4/$20 per Mtok
  2.1.281  2026-09-23  Added Claude apps gateway support for newer Claude Desktop keys in `desktop` policy blocks, includin
  2.1.282  2026-09-24  Added a `maxProseWidth` setting that caps the width of Claude's prose in wide terminals while tables
  2.1.283  2026-09-25  Added `x-claude-code-prompt-id` to the gateway hint headers so LLM gateways can group the requests t
  2.1.284  2026-09-28  Added Claude Sonnet 5.5 (`claude-sonnet-5-5`), now the default Sonnet model on the Anthropic API — 1

The installed line shows 0 because this machine follows latest. On a stable-channel machine the same line becomes installed 2.1.277: 6 releases behind latest. The list stays non-empty even when your own gap is zero, and that is deliberate: it reflects the state "I am current, but a colleague on stable is not."

For the daily log, add --quiet.

stable=2.1.277 latest=2.1.284 gap=6rel/10d installed=2.1.284

Three things that ran against my intuition

Some of what the numbers showed me I only learned by counting, so I'll set it down honestly.

Subtraction lies. As mentioned above, 2.1.279 does not exist. I've known for a long time that version numbers skip, yet I had still been doing "how far behind" in my head as a subtraction. A tool that measures the gap has to count the sequence of releases that exist, not the numbers.

"About a week" is a pointer, not a window. I had pictured the stable channel as a window sliding along one week behind, every day. In reality, the pointer has not moved since 2.1.277 was published on September 18, even though 2.1.278 appeared the very next day. If the description about skipping releases with major regressions is accurate, then the pointer is something a person moves on purpose. I can't see the reasoning from the outside, but I did learn not to treat the day count as an assumption.

Release notes arrive after the binary. Comparing publish times for 2.1.284, the npm registry shows 17:11 UTC and the GitHub release note shows 18:02. That is a 51-minute gap. I suspect there have been mornings where I checked only the release notes and wrote down "nothing new." That is why the script confirms a version's existence and its headline in two different places.

One more thing came from re-reading the documentation. Switching from latest to stable records your current version as minimumVersion, so auto-update won't move you to an older build. I had braced for a downgrade when switching, and that note took a weight off my shoulders.

Make it one line a day

Once the tool exists, put it somewhere that runs without you remembering. I added one line to the morning checks on my operations machine.

# append one line at 08:05 every morning (script placed in ~/bin)
5 8 * * * /usr/bin/python3 "$HOME/bin/claude_channel_gap.py" --quiet >> "$HOME/claude_channel.log" 2>&1

The accumulated lines become the material for a decision. In a week where the gap sits at 2 releases, staying on stable costs you nothing. On a morning like today — 6 releases, 10 days, two default-model changes among them — you can decide that same day whether to move ahead with claude update or to wait while naming the model explicitly with --model.

As far as I understand it, the resolution of model aliases lives in the CLI build. Keep writing opus on an older build and you keep calling the previous generation even after the default has changed. I wrote about recording and guarding those switches in Two hooks that record every model switch and stop the ones you never agreed to. On checking the version before rewriting any configuration, there is The morning a deprecation notice appeared, I checked versions before editing config.

Measure the gap, then decide again

Looking at this morning's numbers, I came to think there is no once-and-for-all answer to "stable or latest." A channel isn't something you choose once; it's something you re-decide after measuring the gap. That is the one line I try not to cross, even in a busy week, as an indie developer keeping a few machines running.

Start by typing the two lines from Step 2 by hand and writing down today's stable and latest. That is where I started, too.