Source: raw/Anthropic_Just_Revealed_Which_Effort_Level_to_Use.md (Ben AI video). First-party sources checked against it: ai-research/claude-dev-blog-spending-your-effort-2026-09-25.md (Thariq Shihipar, “Using Claude Code: Spending your effort”, claude.dev, 2026-09-25), ai-research/claude-docs-effort-2026-10-28.md (Claude platform docs, Effort page, fetched 2026-10-28) and ai-research/claude-blog-model-and-effort-level.md (Lydia Hallie’s model-versus-effort post).
Creator: Ben AI · URL: https://www.youtube.com/watch?v=Q876SRB_-1M · Duration: 12:30 · Platform: YouTube · Uploaded: 2026-10-22
Ben AI’s video turns an Anthropic post on effort levels into a level-by-level guide for business tasks. The post is Thariq Shihipar’s “Spending your effort” (claude.dev, 2026-09-25), which tests the same builds at different effort levels on Opus 5.5 and breaks down Terminal-Bench 3.0 results by effort. This article gives Thariq’s evidence first, then Ben’s business examples and decision questions, then the places where Ben’s paraphrase drifts from the sources. The short version: effort decides how much checking and how many independent decisions Claude makes, so pick it by how involved you want to be and how costly a hidden mistake would be, not by how long the task is.
What effort controls
- A time budget, in Thariq’s analogy. “If someone asked you to do something in 12 hours straight, you might assume they just want you to do it and try very hard. If someone asked you to do the same task in 1 hour, you’d try to get them the best version that meets their task and then expect to iterate from there.”
- More independent judgement and verification at higher levels. Thariq: “Claude will always try and do your task reasonably, but higher effort will involve Claude taking more independent action for judgement and verification.”
- More questions at lower levels. Lydia Hallie’s earlier post: at lower effort Claude “would rather ask you for more context than spend tokens figuring something out on its own.” Ben’s framing: low keeps you in the loop; high lets Claude decide for you, which suits work you will not be around for. See Model vs. Effort.
- Effort applies to every output token, not only thinking. The docs say lower effort also means “fewer and terser tool calls.”
Thariq’s evidence
Three builds on Opus 5.5 (single runs, illustrative):
| Task | Low | Medium | High | Max | What changed |
|---|---|---|---|---|---|
| ”Build a personal fitness and workout tracker app” (underspecified) | 1.5 min | 4 min | 11 min | 67 min | Low gave a log and one graph; max added detail such as a heat chart, with Claude making more choices along the way |
Redesign Claude Code’s /config menu (lightly specified) | 1 min | 28 min | Every level had the same idea. Low was an interactive sketch that “didn’t look very much like Claude Code”; max was a polished mockup with walkthroughs | ||
| The fitness app again, from a detailed spec written after Claude interviewed him | 16 min | 22 min | 33 min | 79 min | The outputs looked “fairly similar” across levels and models |
The third row is the practical lesson: once the spec is detailed, effort matters much less.
Terminal-Bench 3.0 (Anthropic internal runs, 5 attempts per task, Fable 5.1’s production safety interventions off):
- Edge-case-heavy tasks gain most. An HTML sanitizer task went from 1/5 at low to 5/5 at xhigh on Fable 5.1. The low runs wrote a filter in one pass and tested one page; a high run reviewed its own draft adversarially, read the parser’s source, ran an XSS test suite and wrote a fuzzer.
- Opus 5.5 examples: a storage-engine bug fix went from 0/5 at low to 4/5 at xhigh; a linear-program solver from 0/5 at low to 5/5 at high; a gene-set enrichment analysis on proteomics data from 0/5 at low to 4/5 at high. In the last one, low picked one data-prep method and reported; high tried two, saw the results disagree and found out why.
- Fable 5.1, low vs max across 370 attempts: passes rose from 140 to 214, with median tokens per attempt rising from 73k to 222k. “Missed a case” failures fell from 59 to 24.
- One failure type got worse. “Picked the wrong reading” of an ambiguous requirement rose from 25 to 47. Thariq’s summary: more effort “tends to reduce failures due to missing edgecases” but “does not fix when the model has the wrong approach.”
- By category (Fable 5.1, low to top effort): Security 64% to 87%, Hardware 34% to 75%, ML 54% to 73%, Science 41% to 61%, Software 43% to 56%, Media 18% to 30%, Operations 12% to 22%. His label for the last: “Rulebook-style work stays low.”
Thariq’s rule of thumb, verbatim:
- Low: “for when I want quick responses that are in the loop, e.g. brainstorming, sketching, easy changes”
- Medium: “for most of my regular software engineering work, e.g. new feature implementation.”
- High: “for work where verification is important or there are edge cases, e.g. fixing a bug in a brownfield codebase.”
- Max: “When I want Claude to operate fully autonomously to solve difficult problems.”
- He gives no separate rule for xhigh.
His own loop for feature work: give Claude a spec and ask it to interview you about missing details, implement on low, review and iterate on low, then verify and test on high.
Ben’s business version
Ben keeps Thariq’s levels and swaps in office tasks. The examples are his.
| Level | Use it when | Ben’s example tasks |
|---|---|---|
| Low | You will iterate with Claude, the task is simple, or you are polishing a version made at a higher level | 15 newsletter subject lines; “make this client email friendlier and half as long”; tagging support tickets by issue type; short summaries; a rough outline for next week’s newsletter. He now preps YouTube videos on low |
| Medium (Opus 5.5’s default) | You can say what good looks like and will review the result once | A follow-up email from call notes and pricing; turning a video into a LinkedIn post; meeting summaries with decisions and next steps; a weekly report in a fixed format; quick research before a client call |
| High | A hidden mistake would cost money, trust or a decision, or the task has many edge cases | Reconciling a revenue report against Stripe; “why did our churn go up last quarter?”; flagging unusual payment terms in a contract; fact-checking; reading a 50-page report; a final “check every number against the source data” pass on a report built at low; building or fixing a skill, because a skill’s mistakes repeat every run |
| Xhigh / max | All three hold: you will walk away for hours, the job is long and hard, and quality matters more than time and usage | A year of support calls and tickets turned into cancellation reasons, an ICP breakdown and a product roadmap; reviewing a 50-page agreement before signing; an investor deck from metrics, a strategy doc and past decks as Claude’s best one-shot |
His four questions, asked in order, stopping at the first yes:
- Will you go back and forth on this, or is it simple? Low.
- Would a hidden mistake cost money, a client or a wrong decision? High.
- Are you handing off a long, hard, critical job and walking away? Xhigh or max.
- Anything else, or unsure: medium.
Other points he makes:
- If medium’s output is weak, fix the prompt before raising effort. He attributes this to Lydia Hallie; her post says to examine context first and raise effort only if Claude skipped a step or did not check its work.
- “A bad prompt can’t be fixed with a higher effort level.” Thariq’s spec test supports this, and the rise in “picked the wrong reading” at max shows that unclear requirements can get worse with more effort.
- Low-then-high saves money. Do the hard first version on high, tweak on low; or build on low and verify once on high, so you pay for high only on the final check.
- A free “effort mod”. Ben offers a Claude Code mod that reads each prompt and pops up a suggested effort level, with an option to apply it automatically. It is behind his resource link and was not inspected for this article. See Claude Mods. 2026-11-11: in a later video (
raw/Copy_These_5_Claude_Mods_Never_Hit_a_Token_Limit_Again.md) Ben calls it the effort optimizer mod: Sonnet reads your prompt and Claude’s last reply and suggests a switch “which you can still approve yourself”; the model picker does not show the change. ^[ambiguous] (this video shows an approve step, not automatic apply).
Where Ben’s paraphrase differs from the sources
| Ben says | What the source says |
|---|---|
The /config redesign took 1 minute on low and 28 on max “with a very similar outcome” | Same idea at every level, but different results: low was a sketch that did not look like Claude Code, max a polished mockup with walkthroughs. Thariq preferred low for iterating, not because the outputs matched |
| Anthropic’s docs say max “adds significant cost for relatively small quality gains” and can cause overthinking; low “does exactly what you ask,” so give it a checklist | Both lines are in the docs’ Opus 4.7 effort table, not in the Opus 5.5 or Fable 5.1 guidance. For Opus 5.5 the docs say to start at medium and run an effort sweep on your own evals. The advice may still hold, but it is older-model guidance |
| Extra high is “basically a cheaper version of max,” so always start there | Ben’s own advice. Thariq gives no xhigh rule; the docs describe xhigh as for “long-running agentic and coding tasks (over 30 minutes) with token budgets in the millions,” and not every model that supports max supports xhigh |
| Max is for when “I want zero input” (quoting Thariq) | Thariq’s written rule is “operate fully autonomously”. Same meaning; the quote may come from another talk |
| In “one of Anthropic’s own tests, Claude had to analyze a data set” | It is the Terminal-Bench 3.0 gene-set enrichment task on Opus 5.5, a science benchmark, not a business data set. His numbers (wrong every time on low, 4 of 5 on high) are right |
| Switching effort mid-chat “doesn’t cost you anything extra” on the newest models | True where the cache survives: in Claude Code, and on the API through the per-message effort change (beta) on Fable 5.1, Opus 5.5, Opus 5, Sonnet 5.5 and Haiku 5.5. On other models, such as Fable 5, a top-level effort change restarts the cache. Switching the model still re-reads the chat |
| Medium is the default “on Opus 5.5” | Correct. Most other models default to high on the API; Fable 5.1 defaults to high in Claude Code and medium in Claude.ai and Cowork (see [[claude-ai/claude-fable-5-1-mythos-5-1 |
Name fixes from the auto-captions: “Tariq”, “Tharic” and “Atharic” are Thariq Shihipar; “Lydia Holly” is Lydia Hallie; “Entropic” is Anthropic.
Fable 5.2 effort levels (added 2026-11-11)
Sources: Anthropic’s “Prompting Claude Fable 5.2” docs page (ai-research/anthropic-docs-prompting-claude-fable-5-2-2026-11-11.md) and the claude.dev model playbook (ai-research/claude-dev-blog-which-claude-model-should-you-build-with-2026-11-11.md).
- Defaults:
highon the API;mediumin the Claude apps and Claude Code./effort statusshows yours. - Per level:
lowfor quick back-and-forth, well-specified and high-volume work (on coding it scored close to Fable 5.1 at higher effort);mediumfor interactive coding, chat and everyday knowledge work;highfor hard coding, research, agentic work and long unattended runs;xhighonly for the hardest long-running work “where you’ve measured a gain”;maxfor measuring the ceiling or open-ended science and maths. - Most of the gain is at
high; above it gains are “uneven and task-dependent.” - Prompting can no longer replace a lower level. “Answer directly without deliberating” does not stop Fable 5.2 thinking at
mediumand above, and athighit thinks before almost every reply, including a greeting. Lower the effort for easy turns. - Lower effort means more early stops, so pair
lowormediumagentic runs with the guide’s “Finishing work” text. Details in Prompting Claude Fable 5.2. - Playbook rule: “Past
high, one more effort level can cost as much as a bigger model,” so pasthighon Opus 5.5, test Fable 5.2 at a lower level instead.
Try It
- Run one recurring task at low and at medium. Pick a weekly report or a client email. If low is good enough, keep it there and save the difference.
- Adopt the build-low, verify-high split for one deliverable. Draft a report or dashboard on low, iterate on low, then switch to high with “Check every number in this report against the source data and fix anything that’s off.”
- Write the spec before choosing a level. For anything bigger than an email, ask Claude to interview you about missing details first. Thariq’s spec test showed effort matters much less once the spec is clear.
- Reserve high for edge cases and money. Contracts, reconciliations, skills you will rerun, anything where one wrong figure goes unnoticed.
- Use max only when you will be away and the job is critical. If any of Ben’s three conditions fails, use high or xhigh.
- On the API, change effort per message, not per request. Use the per-message
output_config(beta headermid-conversation-output-config-2026-07-01) on supported models so the prompt cache survives the switch.
Key Takeaways
- Effort sets how much Claude checks and decides on its own. Low keeps you in the loop; high and max make more assumptions on your behalf.
- The gains are concentrated in edge-case-heavy work. Security and hardware tasks gained most on Terminal-Bench 3.0; rulebook-style operations work gained least.
- More effort does not fix a vague request. Ambiguous-requirement failures rose at max; a detailed spec narrowed the differences between levels.
- Medium is the right default on Opus 5.5. Move down for iteration and simple tasks, up for verification.
- Treat Ben’s max and checklist warnings as older-model guidance until Anthropic repeats them for the 5.5 models.
Open Questions
- Which “new article” did Ben mean? His video (2026-10-22) says Anthropic “just released” it; Thariq’s post is dated 2026-09-25. The “zero input” quote and the checklist advice are not in Thariq’s post, so Ben may also be drawing on a talk or a later piece not saved here.
- Do Terminal-Bench gains carry over to office work? Thariq’s numbers are coding, science and operations tasks with safety interventions off for Fable 5.1. Nobody has published comparable numbers for reports, decks or analysis.
- xhigh vs max on the 5.5 models. Neither source gives a rule for choosing between them beyond the docs’ 30-minute guideline.
- Ben’s effort mod has not been inspected; what it sends and where is unknown.
Related
- Model vs. Effort (Claude Code) — Lydia Hallie’s model-versus-effort heuristic and the Claude Code
/effortsettings. - Claude Opus 5.5 — the model whose default is medium.
- Claude Fable 5.1 + Mythos 5.1 — the other model in Thariq’s Terminal-Bench breakdown.
- Prompting Claude Opus 5.5 — the “Calibrate effort” guidance and per-message effort.
- The Thinking Lever — the earlier talk on effort and adaptive thinking.
- Claude Usage Limits Playbook — effort as one lever for stretching a plan.
- Which Claude Model for Which Job — the model side of the same decision.
- Claude Mods — where Ben’s effort mod would run.