# Still leaving Claude Code on high effort for everything? It's not doing what you think > Source: > Published: 2026-09-26 06:40:42+00:00 Most people who use Claude Code a lot pick an effort level once and never change it. Usually it's something high, like one level below the maximum. Ask them why, and the honest answer is often: "It feels safer. I haven't actually measured it." I haven't measured mine either. But I recently read Thariq Shihipar's post [Using Claude Code: Spending your effort](https://claude.dev/blog/spending-your-effort/). He ran the same tasks at each of Claude Code's five effort levels (`low`, `medium`, `high`, `xhigh` and `max`) and looked at what actually changed. TL;DR: effort doesn't make Claude smarter. It changes how much Claude checks its own work, and how many decisions it makes without asking you. That sounds like more effort is always better. It isn't. Extra checking pays off on some tasks and just burns time and tokens on others. And when a task is unclear, more effort can make Claude confidently build the wrong thing. Here are the four findings that changed how I think about it. The clearest example in the post is an HTML sanitizer: code that strips out every way someone could sneak JavaScript into a page. The model was Fable 5.1, one of Anthropic's newest models, and it tried the task 5 times at each effort level. At `low`, each attempt took about two minutes. Claude wrote the filter in roughly one pass, tested it on one hand-written page, and passed 1 time out of 5. At `xhigh`, it passed 5 times out of 5. One high-effort run took about 33 minutes. Claude went after its own first draft like an attacker would, read the parser's source code, ran a standard XSS test suite, and then wrote a fuzzer on top of all that. It didn't get smarter. It got suspicious of itself. So here's how I think about it now: **effort is mostly about how much Claude double-checks itself, and how many calls it makes on its own, before it hands the work back.** Once you see it like that, running at almost-max all the time looks a bit silly. Some tasks need all that double-checking. A lot of them don't. The post has a chart that sorts every Fable 5.1 attempt by what went wrong. There are 370 attempts at `low` on the left and 370 at `max` on the right. *Chart from Thariq Shihipar's post. Each square is one attempt. Green passed, purple missed an edge case, blue made the wrong call.* Most failures are one of two kinds: Going from `low` to `max`, missed edge cases dropped by more than half, from 59 to 24. Wrong calls only dropped by about a fifth, from 133 to 107. That makes sense. More effort means more testing, and testing catches edge cases. But no amount of testing tells Claude it's solving the wrong problem. One kind of wrong call actually went up: Claude picking the wrong meaning of an unclear task. At `low` it happened 25 times. At `max` it happened 47 times, almost double. Thariq hints at why earlier in the post: at higher effort, Claude "will also make more assumptions on my behalf." The longer it works on its own, the more it guesses what you meant, and some of those guesses are wrong. To be fair, it could also be that these mistakes were always there and just got easier to spot once the sloppier ones went away. Either way, if your task is fuzzy, more effort won't save you. A clearer task will. The post also breaks the results down by type of task. *Chart from Thariq Shihipar's post. Hollow dot: pass rate at low effort (the two lowest levels). Filled dot: pass rate at top effort (`high`, `xhigh` and `max`). The orange line is Fable 5.1.* Here's how I read it: And extra effort isn't free. At `max`, Claude used about three times as many tokens per attempt as at `low`. So if you keep effort high all the time, you pay that price on every task, even the ones where it barely helps. Quick warning: each category only has 4 to 20 tasks, so don't take the exact percentages too seriously. What matters is how big the gaps between categories are. He also tried some real builds on Opus 5.5. When he gave it a vague prompt to build a personal fitness and workout tracker app, the results were wildly different at each level. `low` took about 1.5 minutes and gave him a log with a graph. `max` took 67 minutes and threw in extras like a heat chart. Then he had Claude interview him first and turned his answers into a detailed spec. This time, every effort level built a fairly similar app. `low` just got there in 16 minutes, while `max` took 79. The spec filled in the gaps that extra effort had been filling before. That's why his go-to loop for new features looks like this: `low`.` high`, since that's where the missed edge cases from point 2 get caught. My own habit is much less scientific than any of this. I keep effort on the lowest setting when I'm working alongside Claude and just want things done fast. When I hand it a task and walk away for a while, I turn it up. There's no data behind that. It just felt right: when I'm sitting there, I'm the one checking the output, so I'd rather have quick turns. When I'm gone, nobody is checking, so Claude might as well do it. Reading the post, I noticed it lines up with something Thariq says: the right level depends on how much you want to stay in the loop. I had the right instinct and no evidence. The post gave me the evidence, and one blind spot I hadn't noticed. Points 2 and 4 are changing one thing for me: before I walk away, I'm going to let Claude ask its questions first. Otherwise I'm leaving it alone on a long run, and going by that data, that's exactly when it's more likely to guess wrong about what I meant. Effort isn't a quality dial you set once and forget. It decides how much Claude checks its own work, and how many calls it makes without you. So match it to the task: You can switch levels mid-conversation with `/effort`, and it doesn't break the prompt cache. So there's no real reason to leave it on one setting. If you use Claude a lot, the [original post](https://claude.dev/blog/spending-your-effort/) is worth reading. It has animated versions of the charts I talked about here. If you've ever compared two effort levels on the same task, share your findings in the comments.