◉CLAUDE LABJP
●CC 2.1.327 — Claude Code 2.1.327 (11/18) adds claude mcp add-json, which reads a server's JSON from stdin●MCP.JSON — The same release stops project-scope mcp add and remove from wiping other keys in .mcp.json●SONNET 4.5 — Retires on the Claude API on 11/30, 11 days left. Sweep model IDs in code and saved settings in one pass●GATEWAY — Users report that behind a gateway, 1M-context models compact so late that each reply takes tens of seconds●NEON — Gemini 4 Neon went GA on 11/18. If you run it next to Claude Code, keep each tool's MCP config separate●NEW — Linked Billing 402 or 403? Find Whose Wallet Is Empty First●CC 2.1.327 — Claude Code 2.1.327 (11/18) adds claude mcp add-json, which reads a server's JSON from stdin●MCP.JSON — The same release stops project-scope mcp add and remove from wiping other keys in .mcp.json●SONNET 4.5 — Retires on the Claude API on 11/30, 11 days left. Sweep model IDs in code and saved settings in one pass●GATEWAY — Users report that behind a gateway, 1M-context models compact so late that each reply takes tens of seconds●NEON — Gemini 4 Neon went GA on 11/18. If you run it next to Claude Code, keep each tool's MCP config separate●NEW — Linked Billing 402 or 403? Find Whose Wallet Is Empty First
Articles/API & SDK
⬡ API & SDK/2026-07-05Intermediate

Don't Let the Opus 4.7 Fast Mode Retirement (July 24) Kill Your Unattended Jobs

claude-opus-4-7 fast mode retires on 2026-07-24, and speed: fast starts throwing errors. Here's how to keep unattended pipelines from breaking silently: mechanically detect where fast mode is used, add a fail-closed runtime guard, and migrate to 4.8 with working code.

Claude API148Opus 4.84model migration3unattended opscost design4

✦ Premium Article

On a Saturday morning, going back through the auto-posting logs for the sites I run as an indie developer, I realized one scheduled job had been running for months with speed: "fast" hardcoded into it. It's code nobody touches. And that's exactly why it will fall over the moment the parameter's contract changes, with no one watching.

On 2026-07-24, fast mode for claude-opus-4-7 retires. After that date, any request that passes speed: "fast" to claude-opus-4-7 will error out. The model ID itself stays alive, so this won't show up on a model-retirement checklist. And yet one specific parameter combination quietly expires. The more your work runs unattended, the more vulnerable it is to this kind of change: the model survives, but the setting dies.

Below, I'll build the steps to cross July 24 quietly, with code you can actually run. We'll cover finding the usages, deciding where to migrate, guarding at runtime, and measuring after the move, as one continuous flow.

What Happens on July 24 — speed: "fast" Becomes an Error

First, let's get the shape of the change exactly right. What retires isn't the model; it's the fast mode speed setting on claude-opus-4-7. Per Anthropic's notice, after July 24 passing speed: "fast" to claude-opus-4-7 will error, and if you want fast mode you'll need to move to Opus 4.8's fast mode.

Here's the impact at a glance.

Call patternBehavior after July 24
model=claude-opus-4-7 + speed=fastError (migration required)
model=claude-opus-4-7 (no speed)Works normally
model=claude-opus-4-8 + speed=fastRuns in fast mode

The awkward part is that in most codebases speed is a write-once-and-forget parameter. You add it to a step where you want to shave latency, then never revisit it. In an interactive app you'd notice the exception the instant it fires, but in a nightly batch or a weekly scheduled job, failed runs just pile up in a log nobody reads. I've had unattended jobs stall silently more than once, and each time the real cost was how late I noticed.

So the goal of this migration isn't simply swapping claude-opus-4-7 for claude-opus-4-8. It's this: know where you use fast mode without relying on human memory, and make the system fall to the safe side at runtime even if a spot slips through.

Take Inventory First — Detect Fast Mode Usage Mechanically

Relying on memory or a single grep guarantees misses, because speed might arrive through a variable or hide in the default of a shared wrapper function. So instead of a plain string search, we set up a check that surfaces the places where Opus 4.7 and fast live in the same call.

Start with a lightweight first-pass sweep across the whole repo.

# First-pass screen: lines where opus-4-7 and speed/fast sit close together.
# It can't see variable-based values, so treat it as "narrow the field."
grep -rniE "opus-4-7|speed.{0,20}fast|fast.{0,20}speed" \
  --include="*.py" --include="*.ts" --include="*.js" \
  --include="*.json" --include="*.yaml" --include="*.yml" . \
  | grep -viE "node_modules|/dist/|/build/"

Once the first pass narrows things down, judge each call precisely. Here we target Python calls and use the AST to extract only cases where a single call has both model=...opus-4-7 and speed="fast". Reading the syntax tree instead of string proximity cuts false positives.

# fast_mode_scan.py - detect the co-occurrence of Opus 4.7 + speed=fast via AST
import ast
import pathlib
import sys
 
def literal(node):
    """Return the string value if it's a constant string, else None."""
    if isinstance(node, ast.Constant) and isinstance(node.value, str):
        return node.value
    return None
 
def scan_file(path: pathlib.Path):
    """Scan one file; return line numbers of risky calls."""
    hits = []
    try:
        tree = ast.parse(path.read_text(encoding="utf-8"))
    except (SyntaxError, UnicodeDecodeError):
        return hits  # leave unparseable files to the first-pass screen
 
    for node in ast.walk(tree):
        if not isinstance(node, ast.Call):
            continue
        model_val, speed_val = None, None
        for kw in node.keywords:
            if kw.arg == "model":
                model_val = literal(kw.value)
            elif kw.arg == "speed":
                speed_val = literal(kw.value)
        # Even if model comes via a variable, flag it when speed=fast is present.
        risky_model = model_val is not None and "opus-4-7" in model_val
        risky_speed = speed_val == "fast"
        if risky_speed and (risky_model or model_val is None):
            hits.append((node.lineno, model_val or "<variable>", speed_val))
    return hits
 
def main(root="."):
    total = 0
    for path in pathlib.Path(root).rglob("*.py"):
        if any(p in path.parts for p in ("node_modules", "dist", "build", ".venv")):
            continue
        for lineno, model, speed in scan_file(path):
            print(f"{path}:{lineno}  model={model} speed={speed}")
            total += 1
    print(f"\n{total} location(s) total")
    # Wire into CI: exit non-zero on any hit so it can't be ignored.
    return 1 if total else 0
 
if __name__ == "__main__":
    sys.exit(main(sys.argv[1] if len(sys.argv) > 1 else "."))

A run might look like this:

services/summarizer.py:88  model=claude-opus-4-7 speed=fast
jobs/nightly_digest.py:41  model=<variable> speed=fast
 
2 location(s) total

For a hit reported as model=<variable>, like the second one, check the variable by hand. If a shared wrapper's default holds claude-opus-4-7, that single line may actually fan out to several jobs. I wire this kind of scan into CI and fail the build on any hit. Just turning the inventory from "a chore I do when I remember" into "a check that runs every time" takes a lot of the anxiety out of migration gaps.

✦

Thank you for reading this far.

Continue Reading

What follows includes implementation code, benchmarks, and practical content we hope you'll find useful. This site runs without ads — server and development costs are supported entirely by members like you. If it's been helpful, we'd be truly grateful for your support.

WHAT YOU'LL LEARN
✦You can get ahead of the July 24 break, where hardcoded speed: fast in unattended jobs suddenly starts failing
✦You'll be able to mechanically detect fast mode usage across your codebase and add a fail-closed runtime guard
✦After migrating to Opus 4.8 fast mode, you can measure latency and cost to decide whether it's actually worth it
Secure payment via Stripe · Cancel anytime
✦

Unlock This Article

Get full access to the rest of this article. Buy once, read anytime. This site is ad-free — your support goes directly toward keeping it running.

or
Unlock all articles with Membership →
Share

Thank You for Reading

Claude Lab is ad-free, supported entirely by members like you. We publish practical guides daily with implementation code, benchmarks, and production-ready patterns. If you've found it useful, we'd love to have you on board.

  • ✦Copy-paste ready implementation code
  • ✦New advanced guides published daily
  • ✦$5/mo or $10 for lifetime access
View Membership →

Related Articles

⬡ API & SDK2026-10-07
Before You Switch Models, Replay Your Own Call Shapes Against the Candidate for a Few Tokens
Change a model ID and the first production request is where a 400 shows up. Here is a small replay script that checks your own call shapes against a candidate model with max_tokens 16 before you switch.
⬡ API & SDK2026-11-18
Before Your Customers Pay Through Linked Billing: Reading a 402 or 403 to Find Whose Wallet Is Empty
Linked billing, released in beta on November 17, lets you choose who pays on every Claude API request through billing_policy. When a request billed to a customer comes back as a 402 or 403, here is how I work out which wallet is the cause, when to pay for it myself, and a small Python wrapper that keeps that decision in one place.
⬡ API & SDK2026-11-17
If You Rely on Claude's Text Watermark, Check temperature in the Request Body, Not Your Code
Since November 16, text from Opus 4.6, Opus 4.5, Sonnet 4.5, and Haiku 4.5 carries Anthropic's text watermark, but non-default temperature, top_p, or top_k may drop it. Here is how I log the request body once and decide.