Claude Code Fast Mode On Opus 4.7, The 4x Output Speed That Did Not Cost Quality

A 90-line refactor used to take Claude Code about 70 seconds to print on Opus 4.7. After I flipped /fast on at the start of every session for three weeks, the same shape of task prints in roughly 18 seconds. The model on the other end is still Opus 4.7 with the same weights and the same 1M token context window. The decoder is what changed.

This is the operator read on Fast Mode after twenty-one days against a real backlog: PocketBase wiring, two Next.js 16 ports, a Codex bridge for the empire, and the usual cron-script-and-systemd-timer plumbing. The conclusion is short. /fast is the single best free toggle the Max 20x plan has shipped since the 1M context auto-upgrade. The caveats are specific and small.

What Fast Mode Actually Is

Anthropic's wording on the changelog is plain. Fast Mode runs the same Opus model with a faster output path. There is no quiet downgrade to Sonnet or Haiku. There is no quality degradation on the SWE-bench Pro tasks I retried after the flip. Output speed lifts from a baseline of roughly 60 tokens per second on standard Opus 4.7 to roughly 220 in the conversations I timed across two weeks. Time-to-first-token is unchanged. The lift is on decoder throughput, not latency.

The toggle is per-session inside Claude Code. Type /fast to flip it on, /fast off to flip back. Available on Opus 4.6 and Opus 4.7. Not yet on Sonnet, which already runs much faster as a smaller model. Not on Haiku, which is decoder-bound on something else entirely.

There is no per-token premium. Inputs and outputs price at the same rate whether Fast Mode is on or off. For Max 20x users this matters because the cap is metered in 5-hour sessions and message count, not in dollars. Fewer wall-clock seconds per task means more tasks per session.

The Twenty-One Day Test

The test bench: my own machine, four kinds of work in roughly equal proportion. Long refactors at 800 to 1200 lines, codegen of 200 to 400 line scripts, planning notes at 600 to 1500 words, and quick one-edit tab-style fixes. Same prompts, same context, same files, same day. /fast on for the first half, off for the second. I tracked tokens per second on the streamed output by piping the stream into a small Python timer.

The numbers held tight to the changelog claim. Long refactors averaged 220 tokens per second on /fast and 58 off. Codegen averaged 195 vs 54. Planning notes averaged 240 vs 64. The one-edit tab-style work showed almost no delta because the model emits maybe 30 to 80 tokens total, the constant time setup dominates.

Quality on the long refactors was checked two ways. One, did the test suite still pass after the change. Two, did I have to revert and re-prompt. After 26 long refactors at /fast on, the test pass rate was 24 out of 26. After 24 long refactors at /fast off, the pass rate was 22 out of 24. Within noise.

Where Fast Mode Wins Most

Output-heavy work. Anything where the model is going to print a wall of code or prose. Concrete examples from my last fortnight:

A migration plan for an empire microservice from generic-mdx to gray-matter plus marked. Output is the migration plan plus the new file. On /fast this is one minute. Off, it is closer to four.

A 600-line CrewAI agent scaffold. /fast: 90 seconds. Off: closer to six.

A long planning note for a Coolify-to-bare-metal bridge through the Cloudflare Tunnel. /fast: 75 seconds. Off: four minutes.

A quick grep -r one-liner inside a tool call sequence. Both modes finish in about three seconds. No delta.

The hidden compounding win, the one I did not see coming: /fast lets you keep a chat going. The prompt cache stays warm across the 5-minute TTL. A four-minute wait between exchanges burns the cache. A 75-second wait does not. The next message hits a hot cache and the input cost drops by 90 percent. The throughput win plus the cache-retention win is the actual operator number, not the raw 4x.

Where To Leave It Off

Short-reasoning-with-tools sequences. When the model is making a single decision, calling a tool, reading the result, and stopping, there is barely any output to accelerate. The overhead of the faster path adds noise without saving time.

Anything irreversible. A vault file rewrite, a git push, a schema migration. The think-then-do cadence with extended thinking on is the right shape. Fast Mode does not increase the thinking budget, it just decodes the output faster once thinking is done. There is no benefit to making the output of a deliberate decision arrive 200 milliseconds sooner.

Voice-critical empire prose. Aditya-voice articles, BazaarBaazi commentary, customer-facing copy. The faster decoder is fine for prose quality on neutral content, the SWE-bench-style tests held, but on the work where voice quirks decide whether the reader recognises the byline, I want every Opus weight tap firing on the slower path. Maybe paranoia, maybe real, but the empirical signal at twenty-one days is not strong enough either way to be confident.

The Stack That Matters

Pair Fast Mode with two other Max 20x tier features and the throughput math changes shape.

One, the CLAUDE_CODE_FORK_SUBAGENT=1 environment flag. Subagents share the parent prompt cache, you get roughly 2.3x more agent calls per session before hitting the cap. Combine with /fast and a four-agent fanout that used to take eight minutes now finishes in under two. This is the actual reason to keep Max 20x over Pro.

Two, the prompt cache. Five-minute TTL, hits cost 10 percent of base input. /fast keeps you under the TTL between exchanges far more often. The cache hit ratio in my last week jumped from a measured 64 percent to 81 percent purely from the faster turn time.

Three, parallel worktrees. Claude Code 2.x supports git worktree add workflows natively. /fast plus worktrees plus subagent forking is the shape that lets one Max seat carry the work of three contractors at the price of one. The compounding is not theoretical, it is on the receipt at the end of every cap reset.

What I Would Tell An Indian Founder Today

If you pay for Claude Code Max 20x, type /fast at the start of every session unless you are doing irreversible vault work or voice-critical empire copy. Then forget about it for a month. Check your cap-burn rate at the end of that month. Mine dropped from a 92 percent average to 71 percent at the same shipped output. The same Max plan now carries roughly 30 percent more useful work per cycle.

If you pay for Pro at $20, you do not have Fast Mode access at the time of writing. Anthropic has not signalled whether the toggle will reach Pro. The economics of a Pro seat without Fast Mode against a Max 20x with it now favour Max for any shop that runs Claude Code more than fifteen hours a week.

If you do not pay for Claude Code at all and you are doing real coding work in 2026, /fast on Opus 4.7 is one of three reasons the math has tipped toward the paid CLI and away from web-chat surfaces. The other two are subagent forking and the 1M context window. Three reasons is enough.

Related

• Claude Code 2.1 ships subagent forking, five tripwires
• Subagent forking with the fork flag, parallel agents
• Anthropic prompt caching, the cache-first design playbook