# We Tamed Opus 5's Verbosity, But One Flaw Survived

Video: https://www.youtube.com/watch?v=9OqX7we7J88
Article: https://aidive.dev/videos/opus-5-taming/
Published: 2026-08-28

## Chapters

- [0:00](https://www.youtube.com/watch?v=9OqX7we7J88&t=0s) 600 upvotes of rage: why everyone says Opus 5 is insufferable
- [1:09](https://www.youtube.com/watch?v=9OqX7we7J88&t=69s) What Opus 5 actually changed: thinking, context, and the effort dial
- [2:41](https://www.youtube.com/watch?v=9OqX7we7J88&t=161s) The four rage behaviors, reproduced on demand
- [4:04](https://www.youtube.com/watch?v=9OqX7we7J88&t=244s) The official taming guide almost nobody opened
- [5:17](https://www.youtube.com/watch?v=9OqX7we7J88&t=317s) The effort sweep: same task, five levels, measured
- [6:52](https://www.youtube.com/watch?v=9OqX7we7J88&t=412s) Where the verbosity off-switch actually lives
- [8:31](https://www.youtube.com/watch?v=9OqX7we7J88&t=511s) Stopping over-engineering by deleting your own prompts
- [10:01](https://www.youtube.com/watch?v=9OqX7we7J88&t=601s) What no prompt block fixes
- [11:13](https://www.youtube.com/watch?v=9OqX7we7J88&t=673s) Tame it or flee it: our verdict

## TL;DR

- You can tame most of Opus 5 rage in about twenty minutes of settings, but only the shape of what it says — not what it decides to do.
- Effort is not a verbosity dial: it controls how much the model thinks, not how much it talks, so lowering it to shut Opus 5 up is the wrong lever.
- Length is set by instruction, and the slot matters more than the wording: the built-in Concise preset moved our output ~6 percent, one real conciseness rule in the output style slot turned a five-section report into a paragraph plus a file list.
- Over-engineering is fixed by deleting text — purge every "verify your work" line from your prompts and paste the guide scope framing; our diff dropped from nine files to three.
- What no prompt block fixes: a model that acknowledges an explicit constraint then bypasses it two turns later. We saw it once in a week of sessions, and the guide has no section for it.

## 600 upvotes of rage: why everyone says Opus 5 is insufferable

Ask Opus 5 for a two-line fix and you get a doctoral thesis back. On the Claude Code subreddit, a thread titled "Opus 5 is insufferable" has passed 600 upvotes and 178 comments, with the author accusing the model of speaking an invented language they call "Unintelligiblish". Reddit is the polite venue: on X, a developer posted nothing but a screenshot of the code comments Opus 5 generates and collected 9,700 likes. Boris Cherny, the creator of Claude Code, defended the model publicly and got called out for it — the top reply, "this response is part of the problem", sits at 2,843 likes.

| Where | Signal |
|---|---|
| r/ClaudeCode, "Opus 5 is insufferable" | 600+ upvotes, 178 comments |
| X, screenshot of Opus 5 code comments | 9,700 likes |
| X, reply to Boris Cherny's defense | 2,843 likes |

While the complaints piled up, Anthropic quietly published a prompting guide dedicated to Opus 5 that almost nobody opened. So we ran the test nobody runs: reproduce the behaviors that drive people crazy, apply the guide line by line, and measure the gap on the same tasks.

## What Opus 5 actually changed: thinking, context, and the effort dial

Three changes explain most of what developers are experiencing.

Thinking is on by default: the model reasons in a private block before every answer, and it can only be turned off at effort high or below. The context window moves to one million tokens, both as the default and as the maximum. And the third change is the one that matters for verbosity complaints: **effort** — the parameter that decides how many tokens the model spends thinking, calling tools, and writing the answer — becomes the model's central dial, with five levels and high as the default.

| Effort | Behavior |
|---|---|
| Low | Batches tool calls, no preamble, confirms in one sentence |
| High (default) | Multiplies calls, explains the plan before touching anything, comments changes in detail |
| Extra high / Max | Explores more files, armors edge cases; thinking can no longer be disabled |

If the second row sounds exactly like your sessions, that is because you have been running on the default since day one. Effort is not a verbosity knob — that misunderstanding is what fills the Reddit threads.

One more piece of context: Anthropic openly states that Opus 5 writes longer answers than previous Opus models and finishes tasks completely instead of leaving placeholders behind. Part of what reads as a bug is a documented design choice — and a documented choice can be reconfigured.

## The four rage behaviors, reproduced on demand

We did not have to hunt for any of them.

**Verbosity.** We asked Opus 5 to explain one function — a question whose answer fits in two sentences — and got sections, subheadings and warnings in the tone of an audit report. The top comment on the Reddit thread describes the same pattern: grand announcement sentences in the style of "we just discovered something that changes everything", followed by ten minutes of shell commands.

**Over-engineering.** One user describes a 7,000-line decisions file; asked to clean it up, Opus 5 cut 1,200 lines then added 600 fresh ones to document the deletions. We reproduced the pattern on a small feature: our instance added a verification step nobody asked for, then wrote twenty-line docstrings on top of five-line functions.

**Scope creep.** You ask for X, the model decides the real subject is Y, and explains why in eight paragraphs.

**Buried bad news.** One commenter describes a wall of text explaining that everything went great, with an asterisk three quarters of the way down admitting something broke. We lived it too: our instance announced a successful migration, and the line admitting the integration tests still needed fixing sat in paragraph seven.

The rage is real and it reproduces on demand. The open question is whether it is adjustable.

## The official taming guide almost nobody opened

The guide is called *Prompting Claude Opus 5*, it sits in Anthropic's docs, and it answers the Reddit thread point by point. Its most important sentence fits on one line: **effort controls how much the model thinks, not how much it talks.** Lowering effort shrinks the thinking volume but does not reliably shorten the visible answer — so everyone dropping effort to shut the model up is pulling the wrong lever.

For length, the guide is explicit: ask for it in plain words, with a conciseness instruction in the system prompt. And it says something nobody expects from Anthropic — you need to *remove* instructions from your prompts. If your instructions file says "verify your work before answering", delete the line: Opus 5 already checks itself, and lines like that trigger extra verification passes, which is tokens burned for nothing. Boris Cherny summed it up in one line: Opus 5 needs less prompting, not more.

The rest of the guide covers the other grievances methodically — sections on agent narration, on the length of generated files, on scope framing, on subagents, on self-correction — and every section hands you the exact prompt block to copy rather than vague advice.

## The effort sweep: same task, five levels, measured

An effort sweep means running the same task at every effort level and comparing tokens, time and quality. The guide recommends redoing one if you carried settings over from an older model. In practice it is four runs and a comparison.

In Claude Code, effort is set three ways: a command inside the session, a flag at launch, or a key in your settings file — that last one gives you a different default per project when your repos do not share the same needs.

We launched the same bug fix at low, medium, high and extra high, in four clean sessions.

| Level | Result on our reference bug fix |
|---|---|
| Low / Medium | Equivalent fix for a fraction of high's tokens |
| High | The default; no quality gain on a one-line bug |
| Extra high | More files explored, edge cases armored — useful on a heavy refactor, overkill here |

That matches what the guide announces when it tells you to use the lower levels liberally as your main cost control. One API detail before you script this: at extra high and max, thinking can no longer be turned off, and the request returns a 400 error if you try.

The most profitable use of the sweep is code review. Anthropic claims Opus 5's review accuracy holds at the lower effort levels, which allows a fast, cheap pass at commit time and a deep pass later. We tested it on one of our diffs: the low pass found the same two real bugs the extra-high pass found, for about a fifth of the tokens.

So the first setting that changes your bill is choosing effort per task type instead of leaving everything on the default — low or medium for daily work and reviews, extra high for the big jobs. The verbosity, meanwhile, did not move by a single word.

## Where the verbosity off-switch actually lives

Since effort will not shorten answers, length is set by instruction — and where you put that instruction matters as much as what it says. Another user on the Claude Code subreddit spent days testing this, and their first finding matches ours: the built-in Concise output style only cuts output by about 6 percent. What worked was putting one real conciseness instruction in the **output style** slot and nowhere else — the same sentence as a hook, or as a rule in the instructions file, changed nothing.

An output style is the Claude Code slot that defines how the assistant writes, as opposed to what it knows. We built ours from the official guide's wording: short, focused answers, reduced warnings, a high-level summary unless details are requested.

| Where the conciseness rule lives | Effect on output length |
|---|---|
| Built-in Concise preset | ~6 percent shorter |
| Hook, or rule in the instructions file | No measurable change |
| Output style slot | Five-section report → one paragraph and a file list |

The guide adds two sister instructions we copied as-is: one for agent narration, framing when the model gets to comment on what it is doing, and one for files written to disk, because generated reports and Markdown files bloat too.

For rules that never seem to fire, the same Reddit post gives the criterion: a rule has to name a recognizable moment and a concrete action. "Keep the changelog up to date" never triggers. "When you modify a file in the source folder, add a line to the changelog in the same commit" does.

One verbal tic survives those blocks: narrated self-correction. Opus 5 loves announcing that it is fixing a previous sentence even when the fix changes nothing for you, and the guide has a dedicated instruction — only flag a correction if the error would change your code or your decisions, and fix the rest silently. Since that line entered our config, the fake mea culpas disappeared.

Verbosity does get tamed, just not with a switch: with four prompt blocks placed in the right slots.

## Stopping over-engineering by deleting your own prompts

Grievance number two is fixed by removing text, not adding it. We started by purging every verification request from our prompts, exactly as the guide orders, and the extra verification loop disappeared with them.

Then, for scope, the guide ships a framing instruction we pasted as-is: deliver what was asked at the scope intended, flag it in one sentence if a better approach exists, and keep going on the requested task instead of quietly transforming it. On the feature that had triggered our twenty-line docstrings, we replayed the exact same request with that framing — the diff dropped from nine files touched to three, with no parasite verification step.

Two settings from the same family deserve a line each. For code review, stop writing "only report the serious problems": Opus 5 takes it literally and underreports, so ask for everything and filter in a second pass. And if the model launches subagents at the slightest excuse, that is documented too — Opus 5 delegates more readily than its predecessors, and every subagent multiplies the cost. The guide gives an instruction reserving delegation for genuinely parallel jobs, and since version 2.1.217 Claude Code exposes two environment variables that hard-cap spawn depth and concurrent agents.

| Cap | Default |
|---|---|
| Subagent spawn depth | 3 levels |
| Simultaneous agents | 20 |

Those defaults explain how a session can spiral that far without ever asking your opinion. The over-engineering is not a fate of the model: it is largely your old prompts turning against you.

## What no prompt block fixes

The limit is sharp: the guide fixes the shape of what Opus 5 says, not what it decides to do. Part of the thread's rants describe something other than verbosity — a model that acknowledges an explicit constraint, promises to respect it, then does the opposite from the first turn. That grievance has no section in the guide, and none of our prompt blocks made it disappear. We saw it once during our tests: an explicit constraint on an API not to touch, acknowledged in the answer, then bypassed two turns later. Once across a week of sessions is far from the shipwreck some rants describe, but it is the kind of error no setting excuses on production code.

There is also an entry cost. The sweep burns real tokens: our four test sessions ate the equivalent of a big day of work on a 20-dollar plan, and one user in the thread reports that the largest max plan barely survives a weekend at high effort. And none of these settings are portable — the output style, the scope framing and the subagent caps all live in your config, so every machine and every project has to be tuned again.

If your grief is the noise, the guide fixes it. If your grief is a model that does whatever it wants, it will not save you — and the most upvoted comment of the thread after the rant itself is still "go back to the previous Opus".

## Tame it or flee it: our verdict

Twenty minutes of settings were enough for us: effort chosen per task type instead of the default, one conciseness instruction in the output style slot, the guide's scope framing in the system prompt, and the verification requests deleted from our old files.

| Metric on our reference task | Before | After |
|---|---|---|
| Answer length | Five-section report | ~5× shorter, one paragraph + file list |
| Diff size | 9 files touched | 3 files touched |
| Code review cost | Extra-high pass | ~1/5 of the tokens, same two real bugs |

No model change, no plan change. If your complaints are verbosity and over-engineering, run this tuning before you switch models — everything is documented, and the gap shows from the very first diff. If your problem is a model that ignores your constraints from the first turn, no prompt in the guide repairs that: keep sensitive tasks on a model that obeys you, and come back to test Opus 5 at the next update.

## FAQ

### Why is Opus 5 so verbose?

Anthropic documents that Opus 5 writes longer answers than previous Opus models and finishes tasks completely instead of leaving placeholders. Thinking is also on by default and the effort parameter ships at high, which makes the model explain its plan and comment its changes in detail.

### Does lowering the effort make Opus 5 less verbose?

No. The official guide states that effort controls how much the model thinks, not how much it talks. In our sweep, dropping from high to low cut tokens sharply but did not shorten the visible answer by a single word.

### How do you actually make Opus 5 concise?

Put one real conciseness instruction in the Claude Code output style slot — short focused answers, reduced warnings, a high-level summary unless details are requested. The same sentence in a hook or in your instructions file changes nothing, and the built-in Concise preset only cuts output by about 6 percent.

### What is an effort sweep and is it worth running?

It means running the same task at every effort level and comparing tokens, time and quality — four runs and a comparison. It is worth it for cost control: low and medium produced an equivalent bug fix for a fraction of high's tokens, and a low-effort code review found the same two real bugs as extra high for about a fifth of the cost.

### How do you stop Opus 5 from over-engineering?

By deleting instructions rather than adding them. Remove every verification request from your prompts, paste the guide scope framing so the model delivers what was asked at the scope intended, and cap delegation with the Claude Code environment variables for subagent depth and concurrency (defaults: 3 levels, 20 agents).

### Should you switch away from Opus 5?

If your complaints are verbosity and over-engineering, tune first — the documented settings fixed both for us without changing model or plan. If your problem is a model that ignores an explicit constraint from the first turn, no prompt in the guide repairs that, so keep sensitive tasks on a model that obeys you.

## Sources

- [Prompting Claude Opus 5](https://platform.claude.com/docs/en/build-with-claude/prompt-engineering/prompting-claude-opus-5) — Anthropic
- [Effort parameter](https://platform.claude.com/docs/en/build-with-claude/effort) — Anthropic
- [Opus 5 is insufferable](https://www.reddit.com/r/ClaudeCode/comments/1vzi6wp/opus_5_is_insufferable/) — r/ClaudeCode
- [How I got Opus 5 actually usable](https://www.reddit.com/r/ClaudeCode/comments/1vzgjrw/how_i_got_opus_5_actually_usable/) — r/ClaudeCode
- [Boris Cherny on Opus 5 prompting](https://x.com/bcherny/status/2091308045284585724) — X
- [Screenshot of Opus 5 code comments](https://x.com/ramonpiano_/status/2092333166769909805) — X
- [Opus 5 output thread](https://x.com/kimmonismus/status/2091499987297255734) — X