Claude Code gets slow for one of three reasons: your context window is bloated, you're on the wrong model for the task, or you're leaving free speed on the table by not using fast mode. The fix is almost never "wait for Anthropic to make it faster" — it's picking Haiku, Sonnet, Opus, or Fable 5 based on task difficulty, running /clear between unrelated tasks, and toggling /fast for interactive work where latency matters more than cost.
Why Claude Code Slows Down in the First Place
Most Claude Code slowdowns trace back to one root cause: the context window filling up. Every file Claude reads, every command it runs, and every message in the conversation gets appended to that window, and a single debugging session or codebase exploration can generate tens of thousands of tokens without you noticing. As the window fills, two things happen at once — responses get slower because there's more context to process on every turn, and quality drops because Claude starts losing track of earlier instructions buried under noise.
The second cause is model mismatch. Running Opus or Fable 5 on a task a smaller model would handle just as well burns time and money for no quality gain. The third is simply not using the speed tools Anthropic ships: fast mode, effort levels, and subagents that offload research into a separate context instead of your main one.
The Three Levers: Model, Effort, and Context
Anthropic's own framing for this, from its guide to choosing a model and effort level in Claude Code, comes down to one question: when a result misses the mark, did Claude "not try hard enough, or not know enough"? That distinction tells you which lever to pull.
- Model — controls how much the system knows and how well it handles ambiguity, unfamiliar domains, and genuinely hard problems. Pick a bigger model when the task is hard, not by default.
- Effort level — controls how much work Claude does before answering: how many files it reads, how deep its verification goes, how long it persists on a multi-step task before checking back in.
- Context — controls how much irrelevant history and file content is dragging down every single turn, independent of model or effort.
Fixing the wrong lever is the most common mistake. If Claude has the full context it needs and still gets a hard problem wrong, that's a model problem — raising effort won't fix a knowledge gap. If Claude skips files, avoids running tests, or gives up mid-task, that's an effort problem, not a reason to jump to a more expensive model.
Fast Mode: 2.5x Faster Opus, No Quality Tradeoff
Fast mode is a research-preview feature that makes Claude Opus generate output up to 2.5x faster. It is not a smaller or dumber model — it's the same Opus weights, same reasoning, running on an API configuration that prioritizes token-generation speed over cost. Toggle it in an interactive session by typing /fast and pressing Tab.
What to know before turning it on:
- Opus only. Fast mode works on Opus 5 and Opus 4.8. It is not available on Sonnet, Haiku, or Fable, and enabling it will auto-switch you to Opus if you're on a different model.
- It costs more. Fast mode pricing is $10/MTok input and $50/MTok output on Opus 5 — double the standard Opus rate ($5/$25).
- Turn it on early. The first time you enable fast mode in a conversation, you pay the full fast-mode price for the entire existing context, so flipping it on at the start of a session is cheaper than switching mid-conversation.
- It needs usage credits. Fast mode draws from usage credits on Pro/Max/Team/Enterprise plans, separate from your normal subscription rate limits, and Team/Enterprise orgs need an admin to enable it first.
- It's not in VS Code. Fast mode currently only works in the Claude Code CLI.
Use fast mode for rapid iteration and live debugging where you're watching the output stream in. Leave it off for long autonomous runs, CI/CD pipelines, or batch work, where standard-speed Opus (or a cheaper model entirely) gets the same result for less money.
Choosing the Right Claude Model for Software Development
As of August 2026, the lineup for coding work is Haiku 4.5, Sonnet 5, Opus 5, and Fable 5. Pricing and the right use case for each:
| Model | Input / Output (per MTok) | Best for |
|---|---|---|
| Haiku 4.5 | $1 / $5 | Simple, high-volume, latency-sensitive tasks — routing, tagging, quick lookups, chatbot-style Q&A. |
| Sonnet 5 | $2 / $10 | Everyday coding: routine edits, mechanical refactors, code review, most day-to-day development. The default for most developers. |
| Opus 5 | $5 / $25 | Complex reasoning: architecture decisions, subtle bugs, long autonomous runs, multi-step tasks across unfamiliar code. |
| Fable 5 | $10 / $50 | The hardest, longest-running problems — tasks Opus and Sonnet can't reliably finish at any effort level. 1M-token context window. |
The practical default: start on Sonnet 5. It's a capable generalist and the model most developers never need to move off of. Reach for Opus 5 specifically when the problem is genuinely hard — an unfamiliar codebase, an architectural tradeoff, a bug that's resisted a few passes already — not as a default "just in case" upgrade. Drop to Haiku 4.5 for mechanical, low-stakes work where speed and cost matter more than depth. Fable 5 is worth its premium only when Opus has already failed at high effort and the task justifies the cost; it's never anyone's default model.
In Claude Code, /model switches between them, and the opusplan alias is worth knowing about: it automatically uses Opus during plan mode for the reasoning-heavy exploration and planning phase, then switches to Sonnet for the actual code-writing execution — getting Opus-quality planning at Sonnet's execution cost.
Effort Levels: The Lever Most Developers Never Touch
Effort controls adaptive reasoning — how much the model thinks before it acts, independent of which model you're on. Opus 5, Sonnet 5, and Fable 5 all support the same five levels:
| Level | When to use it |
|---|---|
low | Short, scoped, latency-sensitive tasks that aren't intelligence-sensitive. |
medium | Cost-sensitive work where you can trade off some intelligence for lower token usage. |
high | The default on every current model. Balances token usage and intelligence for most coding tasks. |
xhigh | Deeper reasoning at higher token spend, for harder problems than the default handles well. |
max | Deepest reasoning available. Can show diminishing returns and is prone to overthinking — test before adopting broadly rather than leaving it on by default. |
Set it with /effort (opens a slider, or pass a level name directly), with the --effort flag at launch, or by adding effortLevel to a settings file. There's also a ultracode setting reachable from the same menu — it runs at xhigh and additionally has Claude Code plan and orchestrate a dynamic multi-step workflow for substantive tasks, rather than just reasoning harder on a single response.
For a one-off deep-reasoning request without changing your session's effort setting, put the word ultrathink anywhere in a single prompt. Claude Code recognizes it as a keyword and adds deeper reasoning for that turn only — other phrases like "think hard" are just passed through as ordinary text and don't do anything special.
7 Ways to Make Claude Code Actually Faster
- Run
/clearbetween unrelated tasks. This is the single highest-leverage speed fix. A clean context window means faster responses and fewer mistakes; a session that's accumulated three unrelated tasks' worth of file reads is going to be slower and less accurate on all of them. - Stop correcting the same mistake more than twice. If you've corrected Claude twice on the same issue in one session, the context is now polluted with failed approaches that keep influencing the next attempt. Clear and restart with a more specific prompt instead of a third correction.
- Delegate research to subagents. Telling Claude to "use a subagent to investigate X" runs that exploration in a separate context window and reports back a summary, instead of dumping every file it reads into your main conversation.
- Write a lean CLAUDE.md, not a bloated one. CLAUDE.md loads on every single session. For each line, ask "would removing this cause a mistake?" — if not, cut it. An over-long CLAUDE.md causes Claude to start ignoring parts of it, which defeats the purpose entirely.
- Pipe files in instead of asking Claude to read them.
cat error.log | claude "analyze this"gets the full content into context in one shot, without a separate tool call and round-trip to read the file. - Use CLI tools for external services. Installing
gh,aws, or similar CLIs is more context-efficient than Claude falling back to raw API calls, which often also means avoiding unauthenticated rate limits. - Match effort and model to the task, every time. Don't run everything at
maxeffort on Opus by default — it's slower and more expensive with real diminishing returns on tasks that didn't need it. Save the heavy settings for when a task has actually earned them.
FAQ
Does fast mode make Claude Code's answers worse?
No. Fast mode uses the exact same Opus model and reasoning — it changes how fast the model writes its output, not how it thinks. You get identical quality and capability, just delivered faster, at roughly double the standard token price.
Should I always use the highest effort level for the best results?
No. high is the default on every current model for a reason — it balances intelligence and token usage for most coding tasks. max effort is prone to overthinking and shows diminishing returns; Anthropic's own guidance is to test it before adopting it broadly rather than leaving it on all the time.
What's the difference between switching models and raising effort?
Model controls what Claude knows and how well it handles genuinely hard or unfamiliar problems. Effort controls how much work it does before answering — files read, tests run, verification depth — at a fixed level of capability. If Claude has full context and still gets something wrong, that's a model problem; if it's rushing through a task without checking its own work, that's an effort problem.
Why does Claude Code get slower the longer a session runs?
Because the context window fills up. Every file read, command output, and message stays in the conversation, and LLM performance degrades as that window fills — both in speed and in how well earlier instructions are followed. Running /clear between unrelated tasks, rather than letting one session sprawl across several topics, is the main fix.
Is fast mode available on Sonnet or Haiku?
No. Fast mode is only supported on Opus 5 and Opus 4.8. It's not available on Sonnet, Haiku, Fable, or any other model, and it isn't supported in the VS Code extension — only the Claude Code CLI.
What is the opusplan model alias for?
It's a hybrid mode that uses Opus during plan mode, where the heavier reasoning helps with architecture decisions and exploration, then automatically switches to Sonnet once you leave plan mode for the actual code-writing. It's a way to get Opus-quality planning without paying Opus rates for the whole implementation.
Which Claude model should I use by default for everyday coding?
Sonnet 5. It's priced at $2/$10 per million tokens, handles routine edits, refactors, and code review well, and is the model most developers never need to move off of. Reserve Opus 5 for tasks that are genuinely hard — not as a default upgrade — and Fable 5 for the rare cases where Opus has already failed at high effort.
Further reading:
- AGENTS.md vs CLAUDE.md: What's the Real Difference, and Do You Need Both? (2026)
- CodeGraph and the Best Code Indexing Tools for Faster, More Efficient AI-Assisted Development (2026)
- AI Coding Agent Pricing and Usage Limits FAQ: Claude Code vs Cursor vs Copilot vs Codex (2026)
- Why Is Cursor AI Slow and Hallucinating in 2026? Every Real Cause and the Fix for Each One