Configuration Commands

Configuration commands let you change how Claude Code behaves without editing files manually. Most open an interactive panel; a few accept a direct argument for quick changes from the prompt.

/config

Interactive settings panel

/model

Switch the active AI model

/memory

Edit project memory (CLAUDE.md)

/plan

Enter plan mode

/theme

Change UI colour theme

/vim

Toggle Vim keybindings

/effort

Set reasoning effort level

/doctor

Diagnose installation issues

/status

Show full runtime status

/permissions

Manage tool permission rules

/config

Opens an interactive full-screen panel for browsing and editing all Claude Code settings. Changes are written to your user settings.json or the project-level settings.json depending on which scope you select. Aliases: settings
Arguments: none
Non-interactive: no

What you can configure

Default model and thinking/effort level
Output style (streaming, compact, verbose)
Colour theme and UI preferences
Sandbox restrictions (filesystem read/write and network)
Tool permission rules (always-allow, always-deny, always-ask)
Privacy settings
Editor integration preferences

Example

> /config

Opens the settings panel. Use arrow keys to navigate sections, Enter to edit a value, and Esc to close.

You can also edit ~/.claude/settings.json (user-level) or .claude/settings.json (project-level) directly in your editor. Changes take effect on the next command.

/model

Switches the AI model used for the current session. Changes take effect immediately for the next message. Arguments: [model name or shorthand]
Non-interactive: no (opens an interactive picker when no argument is given)

Usage

Without an argument, opens an interactive model selector:

> /model

With an argument, switches immediately:

> /model claude-opus-4-5
> /model claude-sonnet-4-5
> /model claude-haiku-4-5

Common shorthands:

Shorthand	Resolves to
`opus`	Latest Claude Opus model
`sonnet`	Latest Claude Sonnet model
`haiku`	Latest Claude Haiku model

Persistence

The selected model is not persisted across sessions by default. To set a permanent default, use /config or add "model" to your settings.json:

{
  "model": "claude-opus-4-5"
}

/memory

Opens the CLAUDE.md memory file editor. Claude Code reads CLAUDE.md files at session start and injects their contents into the system prompt, giving the model persistent project-specific context. Arguments: none
Non-interactive: no

Memory file hierarchy

Claude Code looks for CLAUDE.md files at multiple levels:

~/.claude/CLAUDE.md          # global user memory
<project-root>/CLAUDE.md     # project memory (auto-discovered)
<subdirectory>/CLAUDE.md     # directory-scoped memory

Running /memory opens an interactive file selector showing all discovered memory files. Select one to open it in your $EDITOR ($VISUAL takes precedence).

What to put in CLAUDE.md

# CLAUDE.md

This file provides guidance to Claude Code when working in this repository.

## Build & test commands
- Build: `npm run build`
- Test (all): `npm test`
- Test (single): `npm test -- --testPathPattern=<filename>`
- Lint: `npm run lint`

## Architecture notes
- API layer lives in `src/api/` — all routes use Express middleware from `src/middleware/`
- Database models are in `src/models/` using Prisma ORM
- Do not use `any` — always type API request/response shapes

/init can generate an initial CLAUDE.md for your project by analysing the codebase. Run it at the root of any new project to get started quickly.

/plan

Enters plan mode for the current session, or views the current plan if one has already been created. Arguments: [open | <description>]
Non-interactive: no

Plan mode overview

In plan mode, Claude Code switches to a read-only permission context. The model can explore files, run read-only commands, and draft a plan — but cannot write files or execute destructive commands without explicit user approval. Use plan mode when:

A task is complex enough to warrant designing an approach before touching code.
You want to review a proposed set of changes before they are made.
You are in a sensitive codebase and want a gate before any writes.

Usage

Enter plan mode interactively:

> /plan

Open a specific plan by description:

> /plan open
> /plan redesign the authentication flow

Exiting plan mode

Type /plan again to toggle back to normal mode, or approve the proposed changes when prompted. The session’s permission mode is restored to its previous value.

/theme

Opens the theme picker. Claude Code ships with several built-in colour themes for the terminal UI. Arguments: none
Non-interactive: no

Available themes

Theme	Description
`dark`	Default dark background
`light`	Light background for bright terminals
`solarized-dark`	Solarized dark palette
`solarized-light`	Solarized light palette
`dracula`	Dracula colour scheme

> /theme

Select a theme with arrow keys and press Enter to apply. Changes take effect immediately and are saved to your settings.

/vim

Toggles between Vim mode and Normal mode for the REPL input line. In Vim mode, the input respects standard Vim motion commands (h, j, k, l, w, b, 0, $, i, a, Esc, etc.). Arguments: none
Non-interactive: no

> /vim

  Input mode: Vim  (press Esc for Normal mode, i for Insert mode)

Toggle it off again with another /vim call. The setting is persisted to your user configuration.

/effort

Sets the reasoning effort level for the model. Higher effort levels increase thinking depth and token usage; lower levels are faster and cheaper. Arguments: [low | medium | high | max | auto]
Non-interactive: no (opens picker if no argument)

Level	Behaviour
`auto`	Claude Code decides based on task complexity (default)
`low`	Minimal thinking; fastest and cheapest
`medium`	Moderate thinking
`high`	Extended thinking enabled
`max`	Maximum thinking budget

Examples

> /effort high

  Effort level set to: high

> /effort
# Opens interactive picker

Effort levels only apply to models that support extended thinking (Claude 3.7+ Sonnet/Opus). For other models the setting is silently ignored.

/doctor

Runs a diagnostic check of your Claude Code installation, configuration, and environment. Reports any issues with missing dependencies, misconfigured settings, API connectivity, or outdated binaries. Arguments: none
Non-interactive: no
Disabled by: DISABLE_DOCTOR_COMMAND=1 environment variable

What it checks

Claude Code binary version and installation path
Node.js / Bun runtime version
API key validity and connectivity
settings.json schema validity (user and project levels)
MCP server connection status
Required shell utilities (git, rg, etc.)
Terminal capability detection

Example output

> /doctor

  ✓ Claude Code  v1.2.3  ~/.local/bin/claude
  ✓ Runtime      Bun 1.1.8
  ✓ API key      Valid (claude.ai subscription)
  ✓ Connectivity  api.anthropic.com  200 OK
  ✓ ripgrep      rg 14.1.0
  ✗ MCP server   "filesystem" — connection refused
    → Check that the server process is running and the path in settings.json is correct.

/status

Displays a comprehensive status summary for the current session: version, model, account, API connectivity, active tools, and permission mode. Arguments: none
Immediate: yes (shown without waiting for a new turn)

> /status

  Claude Code  v1.2.3
  Model        claude-opus-4-5  (effort: auto)
  Account      [email protected]  (Pro)
  API          api.anthropic.com  ✓
  Permission   default
  MCP servers  github (connected), filesystem (connected)
  Tools        Read, Edit, Write, Glob, Search, Bash, Agent, ...

/permissions

Opens the permission management panel for reviewing and editing tool allow/deny rules. These rules control which tools Claude Code can use without prompting for approval. Aliases: allowed-tools
Arguments: none

Permission rule types

Rule type	Behaviour
`always_allow`	Tool use is approved automatically, no prompt shown
`always_deny`	Tool use is blocked outright
`always_ask`	User is always prompted, even if auto-approval is on

Rules can be scoped to specific tools, file paths, or shell command prefixes. Examples from settings.json:

{
  "permissions": {
    "allow": [
      "Read",
      "Glob",
      "Search",
      "Bash(git log*)",
      "Bash(npm test*)",
      "mcp__github__list_issues"
    ],
    "deny": [
      "Bash(rm -rf*)",
      "Bash(git push --force*)"
    ]
  }
}

/hooks

Shows the currently configured hooks — shell commands or scripts that Claude Code runs before or after specific tool events. Arguments: none
Immediate: yes Hooks are defined in settings.json under the hooks key. The /hooks command provides a read-only view; edit the file directly to add or change hooks.

{
  "hooks": {
    "PreToolUse": [
      {
        "matcher": "Bash",
        "hooks": [{ "type": "command", "command": "echo 'Running bash command'" }]
      }
    ],
    "PostToolUse": [
      {
        "matcher": "Edit|Write",
        "hooks": [{ "type": "command", "command": "npm run lint --silent" }]
      }
    ]
  }
}

/init

Analyses the current repository and creates (or improves) a CLAUDE.md memory file. Prompts you for which components to set up — memory file, skills, and hooks. Arguments: none

> /init

Claude Code reads README.md, existing config files, and the project structure to generate focused, non-generic guidance. The result is written to CLAUDE.md in the project root.

Run /init when starting work on an unfamiliar codebase. The generated CLAUDE.md gives future Claude Code sessions the context they need to be productive immediately.

Built-in Tools

Slash Commands

Analysis Reports

/config

/model

/memory

/plan

/theme

/vim

/effort

/doctor

/status

/permissions

​/config

​What you can configure

​Example

​/model

​Usage

​Persistence

​/memory

​Memory file hierarchy

​What to put in CLAUDE.md

​/plan

​Plan mode overview

​Usage

​Exiting plan mode

​/theme

​Available themes

​/vim

​/effort

​Examples

​/doctor

​What it checks

​Example output

​/status

​/permissions

​Permission rule types

​/hooks

​/init

Build docs developers (and LLMs) love

/config

What you can configure

Example

/model

Usage

Persistence

/memory

Memory file hierarchy

What to put in CLAUDE.md

/plan

Plan mode overview

Usage

Exiting plan mode

/theme

Available themes

/vim

/effort

Examples

/doctor

What it checks

Example output

/status

/permissions

Permission rule types

/hooks

/init