Why Is Claude So Verbose? How to Get Shorter AI Answers

Quick answer: Claude tends to write long responses because it defaults to thoroughness when a request is open-ended or ambiguous, and because nothing in the conversation has told it otherwise. The fastest fix in the Claude.ai app is switching to the built-in Concise style (Search and tools → Use style → Concise). For a permanent fix, set a standing preference in Settings, or add a short, direct instruction to your system prompt if you're building on the API. Below is exactly how each option works, when to use which one, and why response length varies by model.

Why Claude Gives Long Answers in the First Place

Claude doesn't have a fixed "verbosity level." Instead, the model tries to judge how much explanation a task actually needs and writes accordingly. In practice, that judgment can skew long for a few reasons:

• Ambiguous prompts get the safe, thorough treatment. If you ask "how do I fix this bug?" without more context, Claude often explains the cause, the fix, and alternative approaches, because it can't be sure which part you actually need.

• Helpfulness defaults toward completeness. Without an explicit length or format constraint, the model tends to cover edge cases, caveats, and background context rather than risk leaving something out.

• Formatting habits add bulk. Headers, bullet lists, bolded summaries, and "in conclusion" recaps are all things Claude reaches for by default, and each one adds words even when the actual content is short.

• Newer models actively try to calibrate. According to Anthropic's own prompt engineering documentation, current Claude models attempt to match response length to how complex the task appears, so simple lookups tend to get short answers and open-ended analysis gets longer ones. That calibration isn't perfect, and it's tunable through your prompt.

• Developer reports suggest model and agent behavior can vary. A recent Hacker News discussion describes Claude models as more verbose than some alternatives, while commenters point out that the surrounding agent/tooling layer can also affect how much the model narrates. Treat this as an observed workflow difference, not a universal model rule.

• One model is a known exception. Anthropic's documentation notes that Claude Opus 5 defaults to longer responses than earlier models, and that adjusting the effort parameter does not reliably shorten its visible output — you have to ask for brevity directly in the prompt.

None of this means Claude is malfunctioning. It means the model hasn't been told what "short" means for your specific use case yet.

The Fastest Fix: Switch to a Concise Style

If you're using Claude.ai, the quickest fix doesn't require writing any custom instructions. Anthropic's Styles feature includes a built-in Concise preset designed specifically for shorter, more direct responses.

To turn it on:

1. Open a chat (new or existing).

2. Click the Search and tools menu below the message box.

3. Select Use style.

4. Choose Concise from the list.

Claude will apply the style to your next message, and you can switch styles mid-conversation whenever you want — the style you have selected at the time you send a message is the one that's used. Alongside Concise, Claude.ai also ships Normal, Formal, and Explanatory presets, and Normal and Concise are the two styles you can't hide from the menu.

This is the right first move if you just want shorter answers occasionally, without touching any settings that follow you into every future chat.

Build a Custom Style for Your Own Voice

If Concise is close but not quite right — maybe you want short answers that still include code comments, or brief replies that skip pleasantries entirely — you can create a custom style instead of using the preset.

Claude.ai supports two ways to build one, both accessed from Use style → Create & Edit Styles → Create Custom Style:

• Upload writing samples. Paste or upload text that reflects how you want Claude to write (a PDF, DOC, or TXT file works). Claude analyzes the sample and generates a matching style.

• Describe the style in words. Choose "Describe style instead," pick a starting point, and either let Claude draft the instructions or write your own exact wording under "Use Custom Instructions."

Custom styles are worth the extra setup time if you're using Claude for a recurring task — like drafting terse Slack updates or writing changelog entries — where the "shape" of a good answer is more specific than what a single preset covers.

Set a Standing Preference So Every Chat Starts Concise

Styles apply per conversation. If you want brevity to be the default across every new chat without picking a style each time, the better tool is your account-level preferences, found in Settings. This is where you can tell Claude, in plain language, how you generally want it to respond — for example, asking it to lead with the direct answer, skip restating the question, and avoid summarizing at the end unless you ask for one.

Unlike a Style, which is scoped to the chats where you select it, this kind of standing preference applies everywhere by default, which makes it the right place for a durable "keep it short" rule rather than a one-off request.

Ask for Brevity in the Prompt Itself

Sometimes you don't want to change any settings — you just want this one answer to be shorter. A direct instruction in your message works well, and it's more reliable if you say what you want instead of only what you don't want.

Effective phrasing looks like:

• "Answer in 3 sentences or fewer."

• "Give me the direct answer first, then stop — no background unless I ask."

• "Skip the summary at the end."

• "Use plain prose, no bullet points or headers."

That last point matters more than it sounds. Telling Claude "don't use markdown" is weaker than telling it what format to use instead — for example, asking for flowing prose paragraphs instead of lists gets a more consistent result, because the model has a concrete target rather than just a restriction.

A few more things that make in-message instructions more reliable:

• Match the complexity of your question to the answer you want. A tightly scoped question ("What does useEffect do?") tends to get a tighter answer than an open-ended one ("What are the implications of X given Y and Z?"). If you want brevity, strip your prompt down to the actual question before adding constraints on top of it.

• Use direct, imperative phrasing over hedged requests. "Explain X in 3 sentences" is a clearer signal than "Could you maybe give a short explanation of X if that's alright?" This isn't about tone or politeness — it's that vague, softened requests give the model more room to over-explain.

• Give the request a structure when it's a multi-part task. Splitting a task into a role, the specific task, explicit constraints (word count, format), and the output format you want tends to produce tighter, more predictable answers than one long unstructured prompt — this is standard prompt-engineering practice, not a Claude-specific trick.

One caveat worth knowing: instructions early in a long conversation tend to fade in influence as the chat grows. If you set a brevity rule at the start of a long session and notice Claude drifting back to longer answers many messages later, just restate it. This is also a good reason to start a new chat when you switch topics rather than stacking an unrelated question onto a long thread — the model is still weighing everything said earlier, including any brevity instruction that's now buried under dozens of messages.

Developer and API Fixes for Verbose Output

If you're calling Claude through the API rather than Claude.ai, response length is a prompting problem, not a settings toggle — there's no separate "concise mode" flag. Anthropic's prompt engineering documentation recommends handling it directly in your system prompt. A short, explicit instruction works better than a vague one:

Provide concise, focused responses. Skip non-essential context, and keep examples minimal.

If you notice specific patterns of over-explaining — say, Claude always restating the question before answering, or always adding a caveats section — add a targeted line about that exact pattern rather than a generic "be brief," since specific feedback steers the model more reliably than general instructions.

A few other levers worth knowing:

• max_tokens sets a hard ceiling on output length, but it can truncate a response rather than making the prose naturally concise — use it as a safety cap, not your primary style control.

• stop_sequences can end generation at a marker you define, which is useful for structured outputs but won't make prose more concise on its own.

• Keep your instruction stack manageable. For Claude Code, don't use CLAUDE.md as a dumping ground for every communication preference. Anthropic's output-style documentation specifically separates communication/output-format instructions from project and codebase instructions: output styles are for how Claude communicates, while CLAUDE.md is for project-specific guidance. citeturn2view0

It's Not Just Length — Claude's Writing Habits Add to the Feeling of Verbosity

Some of what reads as "verbose" isn't extra length at all — it's filler patterns that make a normal-length answer feel padded: restating your question before answering it, opening with a broad scene-setting sentence, closing with an unrequested summary, or defaulting to uniform "Bold term: explanation" list formatting for things that would read better as plain sentences. None of these add real information, but they all add words.

You can address this the same way you address length: with a standing instruction. A short, practical version to add to your account preferences might look like this:

• Answer the question directly, without restating it first.

• Don't open with a general scene-setting sentence or close with a summary unless one is genuinely useful.

• Default to plain prose for explanations; reserve bullet points and headers for content that's genuinely list-like.

• Skip stock filler phrases ("it's worth noting that," "in today's fast-paced world," "plays a crucial role in").

This is a lighter version of the kind of "sounds less like a template" instruction some Claude users share in custom instructions — the goal isn't to ban the model from ever using a list, it's to stop those patterns from being the automatic default for everything.

Reducing Verbosity in Claude Code

If your "verbose Claude" problem is specifically about Claude Code narrating every step, reading files it doesn't need, or explaining routine actions at length, that's a separate setting from anything in Claude.ai. Claude Code has its own output styles, and the built-in Concise style is designed exactly for this. Anthropic's current documentation says output styles change how Claude responds, not what it knows, by modifying the system prompt for role, tone, and output format. citeturn2view0

One important update: the old standalone /output-style command was deprecated in v2.1.73 and removed in v2.1.91. The current way to change styles is /config or the outputStyle setting in a settings file. The built-in Concise style requires Claude Code v2.1.237 or later. citeturn2view1

• Concise style makes Claude lead with the result, skip preamble and step-by-step narration, and keep responses short by default — while still doing the underlying engineering work as thoroughly as normal. Error reports, security warnings, and confirmations before destructive actions stay in full regardless of style.

To set it, run /config in the terminal and select Output style, or set the outputStyle field directly in a settings file. You can also write a fully custom output style as a Markdown file with your own instructions if Concise doesn't match exactly what you want.

Two other habits that come up often in developer discussions of this issue:

• Keep CLAUDE.md short and specific. An overloaded CLAUDE.md file with too many instructions can cause Claude to follow some of them inconsistently, verbosity guidance included. Community reports describe large instruction files becoming harder to follow; one recent Claude Code discussion reported better compliance after reducing a roughly 300-line CLAUDE.md to about 40 lines. That's an individual report, not a guaranteed threshold. citeturn1view0 Keep CLAUDE.md focused on project-specific instructions that genuinely need to persist, and use output styles for communication preferences.

• Prefer concrete format rules over "be concise." A recent Claude Code discussion recommends rules such as "outcome first, max 5 lines, expand only if I ask." The useful idea is to specify the desired output format rather than merely complaining about verbosity. citeturn1view0

• Give Claude Code a narrow, explicit scope up front. Vague instructions can encourage broader exploration and more narration than a specific, bounded request. Community reports also suggest that long sessions can drift from brevity rules; when that happens, starting a fresh context and re-anchoring the task can be more effective than arguing about the response style. Treat this as a workflow tip rather than a documented guarantee. citeturn1view0

Practical Prompt Structure That Reduces Noise

A useful pattern from a developer's hands-on experiment is to avoid putting every requirement into one giant prompt. Instead, separate the role, task, constraints, optional steps, and output format. The author reported that breaking a broad request into smaller stages made responses faster and more focused, and that explicit limits such as "Answer in 100 words" or "Assume I already know the basics" reduced unnecessary explanation. This is an individual experiment, so treat the reported 63% response-time improvement as a personal result, not a guaranteed Claude performance gain. citeturn2view2

For example:

Role: Experienced backend engineer.
Task: Explain how to reduce API response time.
Constraints: Max 120 words. No basic explanations.
Steps: List methods, choose the best one, explain why.
Output: Short bullet points.

This approach gives Claude a clear target instead of making it infer the desired level of detail from a long, multi-purpose request.

Reduce Token Waste, Not Just Visible Word Count

Long answers are not the only source of wasted usage. A long conversation also carries accumulated context into later turns, and repeated follow-up messages can add more history. Ruben Hassid's workflow recommends using short prompts, asking Claude to ask clarifying questions when appropriate, reusing stable prompt structures, and editing an earlier message instead of stacking multiple "actually, change X" follow-ups. These are practical usage-management techniques rather than guarantees about output length. citeturn2view5turn1view4

For Claude Code specifically, the practical lesson is simple: avoid turning every small correction into another long instruction block. Keep persistent instructions compact, make the current task explicit, and start a fresh session when an old conversation has accumulated too much irrelevant context.

Make Claude Sound Less Like a Template

Verbosity can also be a style problem. Will Francis identifies patterns that can make Claude-generated writing feel padded even when the raw word count isn't extreme: throat-clearing introductions, repetitive paragraph rhythms, "Bold term: explanation" lists, unnecessary signposting, repeated conclusions, and stock phrases. His suggested approach is to give Claude direct voice rules, vary sentence and paragraph length, avoid generic AI phrases, and use contractions and plain language. citeturn2view3

For content-writing workflows, you can add rules such as:

• Start with the actual point instead of a broad introduction.

• Don't restate the user's question.

• Vary sentence and paragraph length.

• Use headings and bullets only when they improve structure.

• Avoid filler phrases such as "It's worth noting that" or "In today's rapidly evolving world."

• Repeat a point once at most; if it has already been said clearly, move on.

These rules address the feeling of "AI verbosity" as well as literal response length.

Model-Specific Notes on Verbosity

Response length isn't identical across every current Claude model, and the differences affect which fix will actually work:

Because these behaviors are tied to specific model versions and can change as Anthropic ships updates, check the current prompt engineering documentation if you're building something that depends on precise output length.

A Better Rule: Control Verbosity Without Removing Useful Detail

The goal isn't to force every response into a tiny paragraph. Claude's Concise output style is designed to shorten narration while still doing the engineering work thoroughly, and Anthropic says errors, security warnings, and confirmations for destructive actions remain complete. citeturn2view0

Use short output for routine status updates, simple questions, and straightforward fixes. Allow more detail for architecture decisions, debugging with multiple possible causes, security issues, migrations, and tasks where tradeoffs matter.

Common Mistakes That Make Verbosity Worse

• Saying "be brief" once, at the very top of a long chat. The instruction loses weight as the conversation grows. Repeat it if answers start creeping back up.

• Only telling Claude what not to do. "Don't use bullet points" without a replacement format often produces inconsistent results. Say what format you do want.

• Asking for brevity on a genuinely complex question. If a task actually requires multi-step reasoning or several caveats, forcing a short answer can cut information you needed, not just filler. Concise and complete aren't always compatible — decide which one you actually need first.

• Confusing style with substance. A Concise style changes tone and structure, not accuracy. If an answer feels long because it's covering real edge cases, shortening it doesn't remove the underlying complexity, it just hides it.

Quick Troubleshooting Checklist

If Claude's answers still feel too long after trying the above, work through these in order:

1. Confirm which surface you're using — Claude.ai styles and settings don't apply to API calls, and API system prompts don't apply inside Claude.ai.

2. Check whether a Style is already selected that isn't Concise; it may be overriding your one-off request.

3. Make your in-message instruction concrete ("3 bullet points max") instead of vague ("keep it short").

4. If you're on the API, verify your system prompt actually includes a length instruction — it doesn't happen by default.

5. If you're on Claude Opus 5, remember that effort isn't the lever for this; the prompt instruction is.

FAQs

Does asking Claude to "be concise" reduce answer quality?

It can, if the task genuinely needs the detail Claude is including. For factual lookups or simple tasks, brevity instructions rarely cost you anything. For multi-step technical or analytical questions, test whether the shorter answer still covers what you need before relying on it.

Is there a single global setting that makes every Claude response short?

The closest thing on Claude.ai is a standing preference set in your account settings, which Claude will follow by default across new chats. There isn't an equivalent single toggle on the API — you set it in your system prompt for each application.

Why does Claude repeat my question before answering?

This is a common pattern in longer or more thorough responses. Adding an instruction like "don't restate the question, just answer it" usually removes it.

Does the Concise style work the same way for coding questions?

Yes, but for code-heavy tasks you may want a custom style instead, since the default Concise preset optimizes for shorter prose and may trim explanatory comments you actually want to keep.

Will Claude remember my preference for shorter answers in a new chat?

A Style selected in one conversation doesn't carry over to a new chat automatically. An account-level preference set in Settings does apply by default to new conversations.

Does lowering the effort parameter make API responses shorter?

For most current models it can reduce the amount of internal reasoning, but for Claude Opus 5 specifically, Anthropic's documentation notes this doesn't reliably shorten the visible response — you need an explicit conciseness instruction instead.

Can I make Claude stop using bullet points and headers entirely?

Yes — tell it what format to use instead of just what to avoid, for example asking for flowing prose paragraphs and reserving formatting for code blocks only. A flat "no markdown" instruction is less reliable than a positive format instruction.

Conclusion

Claude's verbosity isn't a bug so much as a default calibrated toward thoroughness in the absence of other instructions. The fix depends on how often you need it: use the Concise style for occasional shorter answers, a custom style for a recurring specific format, a standing account preference if you want brevity everywhere by default, and a direct system-prompt instruction if you're building on the API. Whichever layer you use, specific and positive instructions — what to include, not just what to cut — consistently outperform a plain "be brief."