{"slug": "how-to-customize-claude-code-output-styles", "title": "How to customize Claude Code output styles", "summary": "Anthropic's Claude Code now lets developers change how the coding agent communicates through output styles, persistent instructions that set Claude's role, tone and response format for an entire session, alongside the standard Default behavior. Anthropic ships four built-in styles — Proactive, Concise, Explanatory and Learning — selectable via the /output-style command, the /config menu or the VS Code extension, and Claude Code saves the chosen style at the project level in .claude/settings.local.json. Built-in style names are case-sensitive when edited directly in the settings file, so \"Concise\" works while \"concise\" falls back to Default, though the /output-style command itself is case-insensitive.", "body_md": "Everybody has a preference for how we want an AI coding agent to work.\n\nMaybe you want Claude Code to stop explaining everything and just make the change. Maybe you’re working in an unfamiliar codebase and want it to explain why it touched each file. Or maybe you’re actively trying to learn and don’t want Claude writing every interesting piece of code for you.\n\nYou can put some of those instructions in `CLAUDE.md`, and I’ve certainly done that before. But **Claude Code output styles** is a cleaner tool for changing *how Claude behaves*.\n\nAn output style changes Claude’s role, tone, and response format for an entire session. Instead of writing “be concise” or “explain your reasoning” over and over, you select a style once and Claude carries those instructions into subsequent requests.\n\nClaude Code ships with several built-in output styles already, but the much more interesting part is that you can build your own.\n\n## What are Claude Code output styles?\n\nClaude Code output styles are persistent instructions that control how Claude interacts with you. They don’t replace your prompt. If I tell Claude to fix a race condition, the prompt still defines the task. The output style controls how Claude\n\ncommunicates that work.\n\nAnthropic currently includes the normal `Default` behavior plus four built-in output styles:\n\n- **Proactive**\n- **Concise**\n- **Explanatory**\n- **Learning**\n\nEach one keeps Claude Code’s standard software engineering behavior while adding additional instructions about how Claude should work with you.\n\nYou can see your available styles by running:\n\n```\n/output-style\n```\n\nOr switch directly:\n\n```\n/output-style concise\n```\n\n**Claude Code saves the selected style at the local project level in** `.claude/settings.local.json`, so you don’t need to select it every time you start working in that project. You can also choose an output style through `/config`, or through the Output Styles menu in the VS Code extension.\n\nYou can even configure it manually:\n\n```\n{\n  \"outputStyle\": \"Concise\"\n}\n```\n\nOne minor gotcha is that when you edit the settings file directly, the built-in style names are case-sensitive. `Concise` works. `concise` falls back to the Default style. The `/output-style` command itself is case-insensitive.\n\nToday’s post is sponsored by **re:cinq**\n\n**re:cinq** is an engineering consultancy with a strong repuration for helping companies integrate AI into their work.\n\nIf you want expert help building AI-augmented development skills into your existing teams, re:cinq can help.\n\nWhether you’re exploring AI Native transformation, looking for engineering expertise, interested in partnerships or collaborations, or simply want to exchange ideas, re:cinq can help\n\n## The built-in Claude Code output styles\n\nBefore building your own style, I’d spend some time with the built-in options. They solve several very common frustrations with coding agents.\n\n### Default\n\n`Default` is normal Claude Code.\n\nThere aren’t any additional output-style instructions. Claude gets its standard software engineering system prompt and behaves the way you’re probably already accustomed to.\n\nYou can return to it with:\n\n```\n/output-style default\n```\n\nI’d treat this as the baseline rather than necessarily the best option.\n\n### Concise\n\nThis is probably the first style I’d recommend experienced developers try.\n\n```\n/output-style concise\n```\n\nConcise tells Claude to lead with the result and remove much of the narration, preamble, and recap around its work. Simple questions should generally get answers in one to three sentences. Importantly, Anthropic says the underlying engineering work is still performed as thoroughly as it is under the Default style.\n\nThat distinction is useful.\n\nThere are plenty of times where I want Claude Code spending substantial effort understanding a problem, running tests, and checking its work. I just don’t necessarily need a running commentary describing everything it is doing.\n\nIf you already understand the codebase well and primarily use Claude Code as an implementation agent, `Concise` is a very sensible default.\n\nClaude will still provide longer output when you explicitly ask for an explanation or when information is necessary for things like errors, security warnings, failing tests, or destructive actions.\n\n### Proactive\n\nProactive changes something slightly different.\n\n```\n/output-style proactive\n```\n\nInstead of stopping to ask you about relatively routine implementation decisions, Claude is instructed to make reasonable assumptions and continue working.\n\nIt also avoids switching into plan mode unless you explicitly ask it to plan.\n\nThis is particularly interesting if you’re moving toward a more agentic workflow.\n\nOne of the biggest productivity killers with coding agents is assigning what should be a 15-minute autonomous task, walking away, and coming back to discover that the agent stopped 30 seconds later to ask whether you prefer option A or option B.\n\nProactive is essentially saying: use your judgment and keep moving unless the decision really needs me.\n\nIt doesn’t disable Claude Code’s permission system. Tool permissions still determine which operations Claude can execute without approval. Anthropic also instructs the Proactive style to check with you before actions that delete data or modify shared or production systems.\n\n### Explanatory\n\nExplanatory goes in the opposite direction:\n\n```\n/output-style explanatory\n```\n\nClaude still does the task, but it also adds short `Insight` sections explaining important decisions it made.\n\nThese explanations appear in your conversation rather than being dumped into your source files as comments. Anthropic describes them as short explanations of things like patterns in your codebase or reasoning behind an implementation choice.\n\nI like this one for an unfamiliar repository.\n\nThere is a big difference between asking Claude to implement something in a codebase you’ve worked in for five years and having it implement something in a repository you cloned yesterday.\n\nIn the second case, I want the agent doing the work, but I also want to absorb some of what it learns.\n\nExplanatory gives you a bit of that without turning every prompt into:\n\n```\nMake this change and also explain the architecture and why you made every important decision.\n```\n\n### Learning\n\nLearning is the most unusual built-in style.\n\n```\n/output-style learning\n```\n\nClaude still performs routine implementation work and includes the same kinds of `Insight` blocks you get with Explanatory. But when it reaches a small piece of code involving a meaningful decision, it can leave that piece for **you** to implement.\n\nI think this is a smart response to one of the legitimate problems with AI-assisted development.\n\nIf the agent writes every line while you merely approve diffs, it becomes very easy to stop learning.\n\nLearning mode gives Claude the grunt work while intentionally preserving some of the parts where you have to think.\n\nI wouldn’t use it when trying to ship something as quickly as possible. I *would* consider using it when learning a new framework, language, codebase, or engineering pattern.\n\nIf you’re interested in using Claude Code to *learn*, here’s some recommended reading:\n\n## Creating your own custom Claude Code output style\n\nThe built-in styles are useful, but [custom Claude Code output styles](https://code.claude.com/docs/en/output-styles#create-a-custom-output-style) are where this feature becomes much more powerful. Much like a skill, a custom output style is simply a Markdown file containing frontmatter plus instructions for Claude.\n\nYou can use one globally for your user:\n\n```\n~/.claude/output-styles/\n```\n\nOr create styles that belong to a particular project:\n\n```\n.claude/output-styles/\n```\n\nThe filename becomes the style name unless you explicitly provide a different name in the frontmatter. Let’s make one together.\n\nSuppose I want Claude to behave more like a senior engineer working beside me.\n\nI want it to implement things rather than endlessly discuss them, but I also want it to call out architectural decisions, suspicious assumptions, and anything that could create technical debt.\n\nI might create:\n\n```\n~/.claude/output-styles/senior-engineer.md\n```\n\nWith:\n\n```\n---\nname: Senior Engineer\ndescription: Implement directly while highlighting important engineering decisions\nkeep-coding-instructions: true\n---\n\nWork as an experienced software engineer collaborating with another experienced engineer.\n\nPrefer implementing the requested change instead of explaining how I could implement it myself.\n\nKeep routine explanations brief.\n\nWhen you encounter an important architectural decision, surprising codebase convention, meaningful tradeoff, or potential source of technical debt, explain it clearly before proceeding.\n\nDo not narrate routine file reads, searches, edits, or test execution.\n\nAsk me a question only when the answer materially changes the implementation and cannot reasonably be inferred from the codebase.\n\nAfter implementation, tell me:\n\n1. What changed\n2. Any important engineering decisions\n3. Anything I should verify manually\n\nDo not provide a lengthy recap when there is nothing significant to add.\n```\n\nThe most important part of that example may actually be:\n\n```\nkeep-coding-instructions: true\n```\n\nAnthropic says custom output styles do **not** include Claude Code’s normal software engineering instructions by default. If your custom style is merely changing how Claude communicates while you still want Claude behaving like a coding agent, you generally want `keep-coding-instructions: true`.\n\nIf you leave it out, you can turn Claude Code into something else entirely.\n\nFor example, you could make an output style for technical writing, data analysis, product management, or codebase tutoring where the standard coding-agent behavior is unnecessary.\n\nOnce the file exists, restart Claude Code if it was already running. Custom style files are loaded when Claude Code starts. Then select it:\n\n```\n/output-style \"Senior Engineer\"\n```\n\nOr run:\n\n```\n/output-style\n```\n\nand choose it from the available styles.\n\nFrom that point forward, those instructions apply to every response in the session.\n\n## Output styles vs. CLAUDE.md\n\nThere is some overlap here, so the distinction is worth understanding.\n\nAnthropic recommends `CLAUDE.md` for information Claude needs to know about your project: conventions, architecture, commands, repository structure, and other codebase-specific knowledge.\n\nAn output style is more about **how Claude should behave**.\n\nFor example:\n\n`CLAUDE.md`:\n\n```\nRun bin/rails test before completing backend changes.\n\nServices live in app/services.\n\nWe use Result objects rather than raising exceptions for expected failures.\n```\n\nOutput style:\n\n```\nKeep explanations short.\n\nImplement routine decisions without asking.\n\nCall out architectural tradeoffs before making them.\n```\n\nThose two things complement each other nicely.\n\nAnthropic also distinguishes output styles from several other Claude Code extension mechanisms. Skills are better when instructions apply to one specific type of task. Hooks are appropriate when something must happen every time rather than merely being an instruction Claude is expected to follow. Subagents are useful when you want a separate agent with its own system prompt, tools, and context.\n\nThat framing helped output styles click for me:\n\n`CLAUDE.md` **tells Claude about the environment. Output styles define the working relationship.**", "url": "https://wpnews.pro/news/how-to-customize-claude-code-output-styles", "canonical_source": "https://www.augmentedswe.com/p/claude-code-output-styles", "published_at": "2026-10-19 11:14:34+00:00", "updated_at": "2026-10-19 11:16:50.766615+00:00", "lang": "en", "topics": ["ai-agents", "ai-tools", "developer-tools", "ai-products"], "entities": ["Anthropic", "Claude Code", "re:cinq", "Visual Studio Code"], "also_reported_by": [], "alternates": {"html": "https://wpnews.pro/news/how-to-customize-claude-code-output-styles", "markdown": "https://wpnews.pro/news/how-to-customize-claude-code-output-styles.md", "text": "https://wpnews.pro/news/how-to-customize-claude-code-output-styles.txt", "jsonld": "https://wpnews.pro/news/how-to-customize-claude-code-output-styles.jsonld"}}