How to make AI harnesses talk less

Most AI harnesses ship a switch for this, or at least a place to put a rule. Claude Code has a built-in Concise output style. Codex has a personality setting plus three config keys that hide reasoning summaries and lower the model’s verbosity. Cursor has no switch, so there you work with rules, and its CLI has a print mode that keeps only the final message. Turn those on and most of the chatter goes away. The rest you fix with a few lines in an instructions file, or with a ready-made skill.

The harness is the program around the model: Claude Code, Codex, Cursor, and the others. The model writes the words. The harness decides which instructions to send it and what to show you. That’s why the fix is rarely “switch model” and almost always a harness setting.

Almost every coding agent session looks the same. You ask for a small change. The agent tells you what it is about to do, does it, then explains what it did, then lists what you could do next. You wanted the diff.

This post put it bluntly, and a lot of people agreed. The fixes are cheap. Here they all are, with what each one does and doesn’t fix.

Two kinds of noise

Before changing anything, split the problem in two. The fixes are different.

The first kind is what the model writes: the preamble (“Let me take a look at…”), the running commentary, the recap at the end, the bullet list of next steps nobody asked for. This comes from the model and from the system prompt the tool wraps around it. If you want to see how much of a product lives in that wrapper, I wrote about reading Claude’s published system prompts.

The second kind is what the tool shows you: reasoning summaries streaming while the model thinks, tool call logs, file diffs, command output. This is UI. The model did not “say” it. The tool decided to render it.

Claude Code, Codex, and Cursor have separate knobs for each. If you turn down the wrong one, nothing changes and you conclude the tool is broken.

Why “be concise” in your instructions file doesn’t stick

The first thing everyone tries is a line in CLAUDE.md or AGENTS.md: “Be concise.” Then the agent ignores it, and people give up on instructions altogether.

Here is why.

The instruction is vague. “Concise” has no length. The model reads it, agrees, and writes the same amount. Anthropic’s own docs on CLAUDE.md say to write instructions “concrete enough to verify”. A rule like “list the changed file paths, nothing else” is verifiable. “Be brief” is not.

The instruction is context, not configuration. Both tools load these files once, at the start of the session, as text in the prompt. Over a long session, especially after the tool compacts the conversation to save space, the effect fades. Settings that the tool re-applies on every request, like an output style or a config key, don’t fade.

The instruction can’t reach the second kind of noise. No amount of “be concise” hides reasoning summaries or tool logs. Those are rendered by the tool, and the tool has its own switch for them.

So use the built-in switches for the bulk of it, and keep instruction files for the specific shapes the switches don’t cover. Here is how, tool by tool.

Claude Code

I checked everything below against Claude Code 2.1.268. Run claude --version to see yours, and claude update to get the latest one.

Turn on the Concise output style

Claude Code has five built-in output styles: Default, Proactive, Concise, Explanatory, and Learning. Concise is the one you want.

Inside a session, run /config, pick Output style, and choose Concise. Claude Code writes the choice to .claude/settings.local.json in the current project.

If you want it everywhere, put it in your user settings file, ~/.claude/settings.json:

{
  "outputStyle": "Concise"
}

The style kicks in with your next message. Before version 2.1.251 it only applied after /clear or a new session, so if it seems ignored, update.

What does it do? Output styles are extra instructions Claude Code adds to the system prompt on every request. The Concise one tells Claude, in short:

1. Lead with the result. No “Let me…” at the start and no recap at the end.
2. Cut narration, keep substance. Don’t restate the request, the plan, or each step.
3. Short by default. Answer simple questions in one to three sentences of plain prose. Use headers and bullets only when they carry real structure.
4. Skip hedging. Mention a caveat only when it changes what you should do next.
5. Give full detail when asked. Brevity never means withholding something you requested.
6. Never trade correctness for brevity. Error reports, failing tests, security warnings, and confirmations for destructive actions keep their full content.

That last rule matters. It’s the difference between an agent that talks less and an agent that hides things.

Concise needs Claude Code 2.1.237 or later. If you still have a /output-style command in your muscle memory, it’s gone: deprecated in 2.1.73 and removed in 2.1.91. /config replaced it.

Write your own style

If Concise is still too much, or not enough, write a custom style. It’s a Markdown file:

mkdir -p ~/.claude/output-styles

---
name: Terse
description: Results only, one paragraph max
keep-coding-instructions: true
---

Reply with the result and nothing else. No preamble, no summary of the changes, no suggestions for next steps.

When you edit files, list the file paths you touched, one per line. Do not describe the edits.

If the task failed, say what failed and stop.

Save it as ~/.claude/output-styles/terse.md. Restart Claude Code, run /config, and select Terse under Output style.

The keep-coding-instructions: true line is important. Without it, a custom style replaces Claude Code’s built-in software engineering instructions, so Claude forgets how to scope changes, verify work, and so on. You want to change how it talks, not how it codes.

Custom styles live in ~/.claude/output-styles for you, or .claude/output-styles inside a project for the whole team.

Put the rule in CLAUDE.md

For rules about the shape of the answer, CLAUDE.md still has a place:

# ~/.claude/CLAUDE.md

## Output

- After editing files, list the paths. Do not explain the edits.
- For yes/no questions, answer yes or no, then one sentence.
- No summaries, no next steps, no praise.

~/.claude/CLAUDE.md applies to every project. A CLAUDE.md in the repo root applies to that project and gets committed, so your teammates get the same behavior. CLAUDE.local.md is for personal rules you don’t want to commit.

Keep it short and specific, for the reasons above. Use the output style for tone and CLAUDE.md for concrete shapes and project facts.

The free AI Fundamentals course has a lesson on project rules if you want the wider picture, and I wrote about the AGENTS.md convention that Codex and most other agents use for the same job.

One-off with a flag

For a single session, append to the system prompt from the command line:

claude --append-system-prompt "Reply with results only. No preamble, no recap."

Turn it into an alias when you like it:

alias cc='claude --append-system-prompt "Reply with results only. No preamble, no recap."'

This works in bash, zsh, and fish. --append-system-prompt adds to the default prompt. Its sibling --system-prompt replaces the whole thing, which you almost never want for coding.

Check you did not turn on verbose mode

This is the second kind of noise. Claude Code has a verbose mode that shows full tool output turn by turn. It’s off by default, but if you once ran claude --verbose or flipped it in /config, you’re reading the raw transcript of every command. Run /config and check that Verbose is off.

The transcript viewer (Ctrl+O) is the on-demand version of the same thing. Open it when you need the details, close it when you don’t.

Codex

I checked the following against Codex CLI 0.154.0. codex --version shows yours, codex update upgrades.

Set the personality to pragmatic

Codex has a personality setting with three values: friendly, pragmatic, and none.

friendly is warm and explains more. pragmatic is, in OpenAI’s words, “more terse, direct” with “fewer social flourishes; higher ratio of actionable information per token”. none disables the personality instructions and lets your own instructions define the tone.

Existing users were kept on pragmatic when this shipped, but new installs default to friendly. If Codex felt chattier after you set up a new machine, this is why.

Change it for the current chat with the slash command:

/personality

Pick Pragmatic in the popup. Codex confirms it in the transcript. This doesn’t persist.

To make it the default, add one line to ~/.codex/config.toml:

personality = "pragmatic"

Codex hides /personality when the active model doesn’t support it. If you don’t see the command, the setting won’t do anything either.

Hide the reasoning summaries

While Codex thinks, it streams reasoning summaries into the transcript. That’s a lot of the “word vomit” people complain about, and it’s the second kind of noise. Nothing about the answer changes if you hide it.

# ~/.codex/config.toml
hide_agent_reasoning = true

This suppresses reasoning events in the interactive UI and in codex exec output.

If you want a middle ground, keep the events but shorten them:

model_reasoning_summary = "concise"

Values are auto, concise, detailed, and none. none turns summaries off at the model level.

Lower the model’s verbosity

This one controls the length of the final answer itself. It maps to the verbosity parameter of the GPT-5 family in the Responses API:

model_verbosity = "low"

Values are low, medium, and high. When unset, Codex uses the default of the selected model. It only applies to models that support the parameter.

Write output rules in AGENTS.md

Codex reads ~/.codex/AGENTS.md before every task, in every repository. Put your output rules there:

# ~/.codex/AGENTS.md

## Final answers

- Lead with what changed or what the answer is.
- Keep it under 8 lines unless I ask for detail.
- No preamble. No "Next steps" section.
- List touched file paths, one per line.

OpenAI’s own prompting guide describes the final-answer style they tune Codex for, and it starts with “be very concise”. Your file just sharpens the default.

A project AGENTS.md in the repo root adds to the global one. Files closer to your working directory win when they conflict.

To check Codex actually loaded it, ask:

codex "Summarize the current instructions."

Codex quotes the items from your file back to you.

If you set personality = "none" and rely on AGENTS.md alone, you get exactly the tone you wrote, and nothing layered on top.

All of it in one file

Here is a complete ~/.codex/config.toml for a quiet Codex:

personality = "pragmatic"
hide_agent_reasoning = true
model_verbosity = "low"

For a one-off run, pass the same keys with -c:

codex -c hide_agent_reasoning=true -c model_verbosity=low

In scripts, only keep the last message

When you call Codex from a script, you don’t want the transcript at all. codex exec has a flag for that:

codex exec "Add a README section for the test command" -o last.md

-o (or --output-last-message) writes the agent’s final message to a file, so your script reads one clean file instead of parsing the transcript.

Cursor

Cursor is different from the other two: there is no output style, no personality setting, no verbosity key. The docs have one lever for how the agent writes, and it’s rules. I checked this against the Cursor docs and Cursor CLI 2026.09.10 (agent --version).

Put the rule in User Rules

User Rules are plain text, stored on your Cursor account, and sent with every Agent conversation in every project. Open Customize in the sidebar, go to Rules, and add your text under User Rules.

Cursor’s own docs use this exact case as the example: “Please reply in a concise style. Avoid unnecessary repetition or filler language.” That’s a start, but it’s an adjective. Give it shapes:

Lead with the result. No preamble, no recap of what you just did.
After editing files, list the paths, one per line. Do not describe the edits.
For yes/no questions: yes or no, then one sentence.
Skip the "next steps" section unless I ask for it.

User Rules apply in Agent, Ask, Plan, and Debug modes. They don’t apply to Tab completions or to Inline Edit (Cmd+K), which have their own prompts.

One thing to know: when rules conflict, Cursor applies them in the order Team Rules, then Project Rules, then User Rules, and the earlier source wins. A project rule that asks for detailed explanations beats your personal rule that asks for none.

Or in a project rule

For one repository, put the same text in .cursor/rules/output.mdc:

---
alwaysApply: true
---

- Lead with the result. No preamble, no recap.
- After editing files, list the paths, one per line.
- No "next steps" section unless asked.

alwaysApply: true sends it with every chat in that project. The file must end in .mdc; a plain .md in that folder is ignored because it has no frontmatter. The old .cursorrules file in the project root still works but is marked legacy, and the migration path is exactly this: one rule with alwaysApply: true.

If you’d rather not deal with frontmatter, Cursor also reads AGENTS.md in the project root and in subdirectories, and it reads CLAUDE.md the same way. Same content, plain Markdown.

These files get committed, so the same caution as before: your teammates get your tone rules too. Keep personal preferences in User Rules and project facts in the repo.

What the UI can and can’t hide

Cursor lets you choose how much of the agent’s tool activity it shows. The setting is called tool call density, with three levels: Compact, Balanced, and Detailed. Compact collapses the tool traces to short results. The model’s thinking sections are collapsed by default as well, and you expand them by hand when you want them.

None of that touches the prose. There’s no setting that makes the model’s answer shorter. If the text itself is the problem, rules are the only fix inside the app.

The CLI

Cursor’s terminal agent is the agent command (the installer also puts a cursor-agent alias on your PATH). For scripts, its print mode does the filtering for you:

agent -p "Which command moves this branch onto main?"

With -p, the default text output format prints only the final assistant message. No progress lines, no tool call summaries, no intermediate “I’ll read the file” messages. Cursor also suppresses thinking events entirely in print mode, whatever the output format.

If you want the structured version:

agent -p --output-format json "Summarize the failing tests" | jq -r .result

Note the difference: the json format’s result field is the concatenation of all the text the agent wrote between tool calls, so it’s chattier than text. If you only want the answer, text is the quieter choice.

Add --force when you want the agent to run commands and edit files without confirmation, which is what you usually want in a script.

Rules apply in the CLI too. It loads .cursor/rules and reads AGENTS.md and CLAUDE.md from the project root. Whether your account-level User Rules reach the CLI isn’t documented, so put anything that must hold in scripts in a project file.

Two settings in ~/.cursor/cli-config.json cut interactive noise:

{
  "hints": false,
  "suggestNextPrompt": false,
  "display": {
    "showThinkingBlocks": false
  }
}

suggestNextPrompt is the follow-up suggestion at the end of each turn. hints are the tips shown while the agent works. Both are the second kind of noise. Merge these keys into the existing file rather than replacing it, since the CLI manages other fields there. I covered installing this CLI in the post on running Cursor cloud agents on a Mac mini.

Ready-made skills

If you don’t want to write the rules yourself, someone already did.

i-have-adhd is an MIT-licensed skill with one job: stop the agent from burying the answer. Its ten rules include “lead with the next action”, “number multi-step tasks”, “cap lists to five items”, and “no preamble, no recap, no closers”. It also keeps the exceptions you want: full explanations when you ask for one, and a confirmation before destructive commands.

It installs as a plugin in Claude Code:

claude plugin marketplace add ayghri/i-have-adhd
claude plugin install i-have-adhd@i-have-adhd

And in Codex:

codex plugin marketplace add ayghri/i-have-adhd --ref main
codex plugin add i-have-adhd@i-have-adhd

Then type /i-have-adhd in a session. It stays on until you say “stop adhd mode”. The repository also has install steps for Cursor, Gemini CLI, Copilot, and OpenCode.

caveman is the other popular one, and the more extreme. It makes the agent drop articles, filler, and full sentences in the prose around the code, while code, commands, paths, and error messages stay untouched. “New object ref each render. Inline object prop = new ref = re-render. Wrap in useMemo.” That kind of answer. The skill is MIT, and the author’s own benchmark across ten coding prompts measured 65% fewer output tokens on average, with the honest footnote that the skill’s rules cost 1 to 1.5k input tokens per turn, so on work that was already terse you save nothing.

claude plugin marketplace add JuliusBrussee/caveman
claude plugin install caveman@caveman

For Codex and other agents that read the skills format:

npx skills add JuliusBrussee/caveman --skill '*' -a codex --yes

Then /caveman to switch it on, /caveman lite for a softer version, /caveman off to stop. The repository also ships a local proxy that compresses what the agent reads, which is a different problem and a bigger commitment. Start with the skill.

A warning from people who tried it: past a certain point, terse answers take more effort to decode than long ones. “Reply in one line” sounds great until the line is a puzzle. Try lite before ultra.

The nice thing about a skill is that it’s a file. If a rule annoys you, fork it and change the line. If you want to write one from scratch, the free AI Agent Skills course walks through the format.

If you use Cursor, the pstack plugin has a tiny bro skill that does the opposite job on demand: it makes the agent restate its last message in plain language, without jargon. Handy when the answer is buried in the fourth paragraph and you don’t want to re-read. I wrote a deep dive into pstack if you want the rest of it.

What works with every agent

Some fixes have nothing to do with the tool.

Ask for a shape, not a length. “Be brief” is an adjective and models drift back. “Reply with the file paths you changed” is a shape. “Five sentences or fewer” is a shape. “Answer yes or no, then one sentence” is a shape. One reader of that thread asks the agent to return its open questions as numbered options, then replies with Q1 3, Q2 1. A hard limit gives the model something to check itself against. An adjective leaves it to judge, and it always judges that it was already concise.

Answer first, reasoning on request. If the caveat that matters is in paragraph nine, more text made the answer worse. Tell the agent to put the conclusion in the first line and to keep the reasoning for when you ask. This is exactly what the Claude Code Concise style and the i-have-adhd skill enforce.

Ask for the artifact. If you want a commit message, ask for the commit message. If you want to review the change, ask for the diff and the test output. Most of the explanation you get by default is the agent guessing what you want to read. Tell it.

Don’t ask for the plan first. “Tell me what you’ll do, then do it” sounds sensible, but you get the paragraph, and sometimes the agent stops there. OpenAI’s prompting guide for the Codex models says as much: prompting for upfront plans and status updates can make the model stop before the work is done. If you want a plan, ask for a plan and nothing else. Otherwise ask for the change.

Give it a writing standard. A few people point their agents at an existing style guide instead of writing rules. Two that come up: Simplified Technical English (ASD-STE100), the controlled language used for aircraft maintenance manuals (short sentences, one instruction per sentence, a limited vocabulary), and the Google developer documentation style guide. You don’t need the full specification. “One idea per sentence, no adverbs, no analogies” gets you most of the way.

Stop reading the stream. For anything longer than a one-line fix, don’t watch the agent work. Read the final diff. Hiding the reasoning and turning off verbose modes make that easier, but the habit matters more than the setting.

Re-issue the rule after compaction. Both tools compact long conversations to save context. Instructions that lived in the conversation can fade after that. Rules in output styles, config.toml, and skills survive, which is one more reason to put them there instead of typing “be brief” every time.

Trade-offs

Less text is not free.

You lose the “why”. A concise agent tells you it changed three files. It doesn’t tell you it also noticed a bug in a fourth one and left it alone. The Claude Code Concise style keeps error reports and warnings in full for this reason. If you write a custom style, keep that rule.

Hidden reasoning hides mistakes early. The reasoning summaries in Codex are noisy, but they’re also where you see the agent heading the wrong way before it writes any code. If you hide them, review the diff more carefully. Several people in that thread said they want some visibility into what is happening. model_reasoning_summary = "concise" is the compromise: shorter summaries, not none.

Team files affect the team. A “one line only” rule in a committed CLAUDE.md or AGENTS.md applies to a colleague who is onboarding and would like the explanations. Keep tone rules in your user-level files (~/.claude/, ~/.codex/) and project facts in the repo.

Cheap settings beat clever prompts. Every extra instruction costs input tokens on every request. The built-in Concise style and personality = "pragmatic" are tuned by the vendors and cost nothing extra. Start there. Add your own rules only for what they miss.

None of this makes it zero. The models were trained on feedback where longer answers often scored as more helpful. Settings and rules push against that, they don’t remove it. A few people in the thread had Concise on, verbosity low, and rules in both instruction files, and still found Claude wordier than they wanted. Expect a big cut, not silence. The hedging in particular survives most instructions, so when a caveat is useless, say so once and move on.

My recommendation

If I had to pick one change per tool, it’s outputStyle: "Concise" for Claude Code, personality = "pragmatic" plus hide_agent_reasoning = true for Codex, and a four-line User Rule for Cursor. A few lines in three places. Do that first, use the agents for a day, and only then write custom rules for whatever still annoys you.

The default chattiness is a choice the vendors made for people who are new to these tools. Once you know what the agent is going to do, you don’t need it narrated.

Related

The AGENTS.md guide covers everything else that belongs in an instructions file, and the AI Fundamentals course has the wider picture on prompts, rules, and context. For the Cursor side, the pstack deep dive and the Cursor cloud agents on a Mac mini post go deeper into skills and the CLI. The AI Guide for Developers collects the rest of what I’ve written on working with these tools.

Want me to talk about your product? You can sponsor this site.