Output Styles, Status Line & More

This content was generated with the assistance of AI and should be verified against the official documentation of each tool and framework before being relied on in production.

This section’s bibliography lists the reference material consulted while preparing these pages.

This page is written against the Claude Code CLI 2.1.283, VS Code 1.139 with the GitHub Copilot Chat extension, and the GitHub Copilot CLI 1.0.88, all re-verified as current as of 2026-09-28; re-check the linked docs before relying on an exact field name, since these surfaces change often. The four surfaces below are, in varying degrees, specific to the Claude Code CLI: output styles and the status line have no direct Copilot equivalent, keybindings are a general editor/CLI mechanism both tools happen to offer in their own way, and environment variables exist in every one of these tools but under different, tool-specific names. Each section says plainly where Copilot has nothing comparable.

Output styles

An output style is a set of instructions that sets Claude’s role, tone and response format for an entire session, so a preference doesn’t have to be repeated in every prompt. Claude Code ships five styles — default plus four built-ins — verified against Claude Code — Output styles:

Style What changes Use it when

Style	What changes	Use it when
Default	No style instructions added; Claude follows Claude Code’s standard software-engineering system prompt.	No style has been selected.
Proactive	Claude starts implementing right away and makes reasonable assumptions about routine decisions instead of asking, while still checking in before anything that deletes data or touches a shared/production system.	You want fewer routine questions and will redirect Claude if an assumption is wrong.
Concise	Responses lead with the result; preamble, step-by-step narration and closing recaps are dropped. Error reports, failing tests, security warnings and destructive-action confirmations still print in full.	Default responses run longer than you want. Requires Claude Code v2.1.237 or later.
Explanatory	Claude adds short `Insight` blocks explaining the reasoning behind a change, shown in the conversation — never written into files as comments.	You’re getting to know a codebase and want the "why" alongside the "what".
Learning	Same `Insight` blocks as Explanatory, plus Claude leaves a `TODO(human)` marker for a piece with a real design decision and asks you to write it yourself before continuing.	You want hands-on practice while the task still gets done.

Default

No style instructions added; Claude follows Claude Code’s standard software-engineering system prompt.

No style has been selected.

Proactive

Claude starts implementing right away and makes reasonable assumptions about routine decisions instead of asking, while still checking in before anything that deletes data or touches a shared/production system.

You want fewer routine questions and will redirect Claude if an assumption is wrong.

Concise

Responses lead with the result; preamble, step-by-step narration and closing recaps are dropped. Error reports, failing tests, security warnings and destructive-action confirmations still print in full.

Default responses run longer than you want. Requires Claude Code v2.1.237 or later.

Explanatory

Claude adds short Insight blocks explaining the reasoning behind a change, shown in the conversation — never written into files as comments.

You’re getting to know a codebase and want the "why" alongside the "what".

Learning

Same Insight blocks as Explanatory, plus Claude leaves a TODO(human) marker for a piece with a real design decision and asks you to write it yourself before continuing.

You want hands-on practice while the task still gets done.

Switching styles never changes the active permission mode — Proactive still asks for anything the permission mode itself requires.

Selecting a style

/output-style <style> switches style starting with your next message and saves the choice to .claude/settings.local.json, so it persists for the project (the command ignores case); /output-style with no argument lists the choices and marks the current one. /config → Output style does the same from a menu. The same choice can be set directly in a settings file, where the value is case-sensitive — write the built-in names as Proactive, Concise, Explanatory and Learning, since a value that matches no style, such as explanatory, falls back to Default:

.claude/settings.local.json

{
  "outputStyle": "Explanatory"
}

Setting outputStyle in ~/.claude/settings.json makes it the default across projects; a project’s own settings file still takes precedence, per the settings precedence Permissions & Settings covers. See Claude Code — Output styles.

Custom output styles

A custom style is a Markdown file: YAML frontmatter, then free-form instructions for Claude. It is saved as ~/.claude/output-styles/<name>.md (user scope), .claude/output-styles/<name>.md (project scope), or under a managed-settings directory; a plugin can also ship one under its own output-styles/ directory. The file name becomes the style’s name unless name is set in frontmatter. Claude Code reads style files at startup, so restart it after creating or editing one.

Key Type Required What it does

Key	Type	Required	What it does
`name`	string	No	Display name in the `/config` picker. Defaults to the file name.
`description`	string	No	Description shown in the `/config` picker.
`keep-coding-instructions`	boolean	No	When `true`, keeps Claude Code’s built-in software-engineering instructions alongside the custom style’s own. Defaults to `false` — a custom style otherwise replaces those instructions entirely.
`force-for-plugin`	boolean	No	Plugin output styles only: applies the style automatically whenever the plugin is enabled, overriding the user’s own `outputStyle` setting. Defaults to `false`.

name

string

Display name in the /config picker. Defaults to the file name.

description

string

Description shown in the /config picker.

keep-coding-instructions

boolean

When true, keeps Claude Code’s built-in software-engineering instructions alongside the custom style’s own. Defaults to false — a custom style otherwise replaces those instructions entirely.

force-for-plugin

boolean

Plugin output styles only: applies the style automatically whenever the plugin is enabled, overriding the user’s own outputStyle setting. Defaults to false.

.claude/output-styles/diagrams-first.md

---
name: Diagrams first
description: Lead every explanation with a diagram
keep-coding-instructions: true
---

When explaining code, architecture, or data flow, start with a Mermaid diagram showing the structure, then
explain in prose.

## Diagram conventions

Use `flowchart TD` for control flow and `sequenceDiagram` for request paths. Keep diagrams under 15 nodes.

GitHub Copilot’s and VS Code’s customization docs describe no equivalent surface — no session-wide, swappable "role and tone" instruction file that replaces the built-in system prompt the way outputStyle does, as of 2026-09-28. The closest available lever is a custom agent's own system-prompt body, which shapes one agent’s behavior rather than the whole session’s.

The status line

The status line is a customizable bar Claude Code renders in its own row above the built-in footer badges, driven by a shell script that receives session data as JSON on stdin and prints whatever the script wants displayed. It is configured with a statusLine object in a settings file, verified against Claude Code — Customize your status line:

~/.claude/settings.json

{
  "statusLine": {
    "type": "command",
    "command": "~/.claude/statusline.sh",
    "padding": 2
  }
}

type is currently always "command". command is a shell command or script path, run in a shell, so an inline one-liner works too (e.g. piped through jq). padding is an optional integer, defaulting to 0, that adds extra horizontal spacing in characters on top of the interface’s own indentation. An optional refreshInterval (in seconds, minimum 1) also re-runs the command on a timer, for time-based data such as a clock. Running /statusline (optionally describing what to show) generates and wires up a script for you; /statusline delete (or clear, or remove it) removes the configuration again.

The script’s input contract

Claude Code runs the command when a session starts or resumes, then again when a new assistant message arrives, /compact finishes, the permission mode or vim mode changes, the command itself changes, or a refreshInterval timer elapses — debounced at 300 ms, so a burst of changes runs the script once. Each run feeds it a JSON object on stdin. The commonly used fields, verified against the same page:

Field What it holds

Field	What it holds
`model.id`, `model.display_name`	The current model’s identifier and display name.
`workspace.current_dir`, `cwd`	The current working directory (same value in both; `workspace.current_dir` is the preferred one).
`workspace.project_dir`	The directory Claude Code was launched from, which can differ from `cwd`.
`cost.total_cost_usd`	Estimated session cost in USD, computed client-side; resets to 0 on `/clear`.
`cost.total_duration_ms`, `cost.total_api_duration_ms`	Total session wall-clock time, and time spent waiting on API responses, in milliseconds.
`context_window.context_window_size`, `context_window.used_percentage` (nested under `context_window`)	The model’s maximum context size in tokens and how much of it is currently used.
`output_style.name`	The name of the currently active output style.
`session_id`, `version`	The session’s unique id, and the running Claude Code version.

model.id, model.display_name

The current model’s identifier and display name.

workspace.current_dir, cwd

The current working directory (same value in both; workspace.current_dir is the preferred one).

workspace.project_dir

The directory Claude Code was launched from, which can differ from cwd.

cost.total_cost_usd

Estimated session cost in USD, computed client-side; resets to 0 on /clear.

cost.total_duration_ms, cost.total_api_duration_ms

Total session wall-clock time, and time spent waiting on API responses, in milliseconds.

context_window.context_window_size, context_window.used_percentage (nested under context_window)

The model’s maximum context size in tokens and how much of it is currently used.

output_style.name

The name of the currently active output style.

session_id, version

The session’s unique id, and the running Claude Code version.

~/.claude/statusline.sh

#!/usr/bin/env bash
# Read JSON data that Claude Code sends to stdin
input=$(cat)

MODEL=$(echo "$input" | jq -r '.model.display_name')
DIR=$(echo "$input" | jq -r '.workspace.current_dir')
PCT=$(echo "$input" | jq -r '.context_window.used_percentage // 0')

echo "[$MODEL] 📁 $(basename "$DIR") | ${PCT}% context"

GitHub Copilot’s and VS Code’s docs describe no scriptable equivalent, as of 2026-09-28: nothing there drives a status bar from a user-supplied script reading a documented JSON contract the way statusLine does.

Keybindings

~/.claude/keybindings.json rebinds Claude Code’s own keyboard shortcuts; /keybindings creates or opens it. Verified against Claude Code — Customize keyboard shortcuts, the file is a single object with a bindings array, each entry naming a context (where the bindings apply) and a map of keystrokes to actions (namespace:action, e.g. chat:submit). Changes are picked up automatically, with no restart needed.

Field Type What it does

Field	Type	What it does
`$schema`	string	Optional JSON Schema URL for editor autocompletion.
`$docs`	string	Optional documentation URL, informational only.
`bindings`	array	The binding blocks, each with a `context` string and a `bindings` map.

$schema

string

Optional JSON Schema URL for editor autocompletion.

$docs

string

Optional documentation URL, informational only.

bindings

array

The binding blocks, each with a context string and a bindings map.

~/.claude/keybindings.json

{
  "$schema": "https://www.schemastore.org/claude-code-keybindings.json",
  "$docs": "https://code.claude.com/docs/en/keybindings",
  "bindings": [
    {
      "context": "Chat",
      "bindings": {
        "ctrl+e": "chat:externalEditor",
        "ctrl+u": null
      }
    }
  ]
}

Setting an action to null unbinds the default shortcut for that key in that context instead of assigning a new one. Contexts include Global (applies everywhere), Chat (the main prompt), Autocomplete, Confirmation (permission and other yes/no dialogs), Transcript, Task, ThemePicker, Settings and several others, each exposing its own set of actions — for example app:toggleTodos (Ctrl+T, Global) and chat:externalEditor (Ctrl+G, Chat). Claude Code validates the file when it loads and warns about parse errors, invalid context names, unknown actions, reserved-shortcut conflicts and duplicates; a binding with an unknown action name is skipped, and any default for that key stays in effect.

VS Code has its own general, editor-wide keybindings.json (opened via the Keyboard Shortcuts editor’s "Open Keyboard Shortcuts (JSON)" command), a JSON array of {"key", "command", "when"} rule objects, verified against VS Code — Keybindings. It rebinds VS Code and its extensions' commands generally, including Copilot Chat’s own commands, rather than being specific to Copilot the way Claude Code’s file is specific to Claude Code.

Environment variables

Claude Code reads a large set of environment variables; the table below covers the commonly used ones, verified against Claude Code — Environment variables:

Variable Purpose

Variable	Purpose
`ANTHROPIC_API_KEY`	API key sent as the `X-Api-Key` header; used instead of a Claude Pro/Max/Team/Enterprise subscription when set (always in `-p` mode; after a one-time approval in an interactive session).
`ANTHROPIC_MODEL`, `ANTHROPIC_DEFAULT_MODEL`	The model to use. `ANTHROPIC_MODEL` applies over the `model` settings key from any file; `ANTHROPIC_DEFAULT_MODEL` (v2.1.236+) only sets the model new sessions start on, when no file sets `model`.
`ANTHROPIC_DEFAULT_SONNET_MODEL`, `ANTHROPIC_DEFAULT_OPUS_MODEL`, `ANTHROPIC_DEFAULT_HAIKU_MODEL`	The concrete model ID each alias (`sonnet`, `opus`, `haiku`) resolves to.
`ANTHROPIC_BASE_URL`	Overrides the API endpoint, for a proxy or gateway; also disables MCP tool search and Remote Control on a non-first-party host.
`DISABLE_TELEMETRY`	Set to any non-empty value to opt out of telemetry — even `0` or `false` opts out; unset it to turn telemetry back on.
`DISABLE_ERROR_REPORTING`	Set to any non-empty value to opt out of error reporting (same "even `0` opts out" rule).
`CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC`	Set to any non-empty value to disable non-essential network traffic: auto-updates, telemetry, error reporting, `/feedback`, release notes and similar checks.
`BASH_DEFAULT_TIMEOUT_MS`, `BASH_MAX_TIMEOUT_MS`	Default (120000) and maximum (600000) timeouts, in milliseconds, for a long-running Bash command.

ANTHROPIC_API_KEY

API key sent as the X-Api-Key header; used instead of a Claude Pro/Max/Team/Enterprise subscription when set (always in -p mode; after a one-time approval in an interactive session).

ANTHROPIC_MODEL, ANTHROPIC_DEFAULT_MODEL

The model to use. ANTHROPIC_MODEL applies over the model settings key from any file; ANTHROPIC_DEFAULT_MODEL (v2.1.236+) only sets the model new sessions start on, when no file sets model.

ANTHROPIC_DEFAULT_SONNET_MODEL, ANTHROPIC_DEFAULT_OPUS_MODEL, ANTHROPIC_DEFAULT_HAIKU_MODEL

The concrete model ID each alias (sonnet, opus, haiku) resolves to.

ANTHROPIC_BASE_URL

Overrides the API endpoint, for a proxy or gateway; also disables MCP tool search and Remote Control on a non-first-party host.

DISABLE_TELEMETRY

Set to any non-empty value to opt out of telemetry — even 0 or false opts out; unset it to turn telemetry back on.

DISABLE_ERROR_REPORTING

Set to any non-empty value to opt out of error reporting (same "even 0 opts out" rule).

CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC

Set to any non-empty value to disable non-essential network traffic: auto-updates, telemetry, error reporting, /feedback, release notes and similar checks.

BASH_DEFAULT_TIMEOUT_MS, BASH_MAX_TIMEOUT_MS

Default (120000) and maximum (600000) timeouts, in milliseconds, for a long-running Bash command.

A settings file’s env block applies a variable to every session (and every subprocess Claude Code starts); a value there overwrites the same variable exported in your shell. Its values are stored in plain text, so keep credentials out of it entirely — and never commit one to a project’s .claude/settings.json. For the API credential, point apiKeyHelper at a command that fetches it from a secret manager instead:

~/.claude/settings.json

{
  "apiKeyHelper": "~/.claude/bin/fetch-anthropic-key.sh",
  "env": {
    "BASH_DEFAULT_TIMEOUT_MS": "300000"
  }
}

Claude Code runs the helper through the system shell, sends its output as the API credential, caches it for five minutes by default and re-runs it after a 401/403. See Claude Code — Settings reference (apiKeyHelper) and (env). GitHub Copilot and VS Code also read environment variables (for example, for proxy configuration), but under their own tool-specific names, not the ANTHROPIC_*/Claude-Code-specific ones above; consult each tool’s own documentation before assuming a name carries over.

Output Styles, Status Line & More

Output styles

Selecting a style

Custom output styles

The status line

The script’s input contract

Keybindings

Environment variables

Related pages

References