Claude Code on Admantium

Claude Code CLI: Session & Context Management

Thu, 18 Jun 2026 00:00:00 +0000

Claude Code is an agentic tool that can execute commands on an installed computer. Its focus is coding, helping to implement programs from scratch, to add features, for bug fixing, and for refactoring of complex code bases.

In an ongoing blog series, I systematically explore the CLI, slash commands, and use cases. This article presents a grouped overview of all available commands, scoping the typical session lifecycle and helping you understand when to use which command.

The technical context of this article is claude_code v2.1.91, published on 2026-04-02. Examples and most CLI commands should work with newer versions too.

While I’m fascinated by the capabilities of artificial intelligence tools and applications, crafting blog articles remains my personal skill. Every character, number, and symbol in this article was typed manually, with the exception of verbose copies from log messages and screenshots.

Claude Code CLI: Slash Command Overview

Once a Claude Code session is started, more than 40 built-in slash-commands are available. They can be grouped into different categories that reflect the session lifecycle of its invocation, augmented by universal commands. Here is my proposed structure:

🌀 Session Configuration
- /add-dir: Add an additional working directory to the current session
- /rename: Provide a meaningful name to the conversation, which reflects the variable name of the conversation file
- /model: Determine the LLM model to be used
- /effort: Configures the effort level of the model, adjusting its internal reasoning behavior
- /login: Log in to the Anthropic subscription or Console
- /logout: Log out of an Anthropic account
🌀 Session Reflection
- /cost: Shows the current session cost
- /usage: Shows token consumption in the context of a subscription plan
- /status: Shows essential CLI, model, and account information
- /stats: Shows usage statistics and activity overview
- /config: General purpose configuration
- /update-config: Customizations of Claude Code internals
- /export: Create a compact conversation summary
- /insights: Generates a detailed report with meta information about the current session
Session Management
- /batch: Execute a plan file as a parallel running sub-session
- /btw: Process an additional instruction during a long-running main task
- /loop: Run a specific prompt periodically
- /tasks: List all background tasks
- /fork: Define a staging point in the conversation history from which different branches can be invoked
- /rewind: Roll back the conversation and optionally code base to an earlier state
- /exit: Stop the terminal
- /resume: Continue a session
Context Management
- /clear: Reset the conversation history
- /compact: Define a new conversation history entry, limiting the context that is sent to the LLM provider
- /context: Visualize current context usage as a colored grid
- /memory: Edit Claude memory files
Conversation Ops
- /rename: Provide a meaningful name to the conversation
- /init: Read the current project and generate a CLAUDE.md file
- /plan: Toggle between editing and plan mode
- /simplify: Review the changed code for efficiency
- /review: Review a merge request and optionally check comments from an origin repo
- /security-review: Invoke a special agent that checks the source code for security issues
- /diff: View and commit staged file changes
- /copy: Copy the last answer to the clipboard
- /export: Create a compact conversation summary
Terminal Configuration
- /theme: Configure the color theme
- /color: Configure prompt bar color
- /terminal-setup: Configure key bindings
- /vim: Enable or disable VIM editor support when editing files via the CLI
- /statusline: Set up a custom status line for the terminal
Diagnostics & User Support
- /release-notes: Show the Claude Code release notes
- /doctor: Check configuration status
- /debug: Enable verbose debugging output and check for known issues
- /feedback: Write feedback about your Claude Code experience
- /help: Show general information about available slash commands
- /powerup: Explore Claude Code feature with small lessons
- /stickers: Order Claude Code stickers
- /buddy: Hatch a Tamagotchi-like coding companion
Permissions
- /permissions: Fine-grained allow & deny tool permission rules
- /sandbox: Configure settings to secure Claude terminal access and program execution rights
Extensions
- /hooks: View hook configurations for tool events
- /skills: View installed skills
- /agents: Create and manage agents
- /mcp: Set up and manage MCP server definitions
- /chrome: Start a local Chromium browser for browser interaction
- /plugin: Browse and configure CLI extension
- /reload-plugins: Reload all configured plugins
Integrations
- /ide: Show IDE integrations for Claude, for example in Visual Studio Code
- /install-github-app: Configure GitHub actions that interact with Claude
- /install-slack-app: Configure Slack integration
- /mobile: Show a QR code to download the iOS or Android app
- /claude-api: Build native apps that integrate with Anthropic SDK

From this list, groups marked with 🌀 are the focus of this article.

What are Claude Code Sessions?

Whenever the Claude Code CLI is invoked, a new session is created. On a high-level view, the user enters prompts, which are analyzed and processed to create internal tasks, such as checking/asking for permissions, suggesting and executing tools, and editing files. Each of these tasks is represented in the session history as a specific JSON document, with a unique type and attribute. Let’s investigate this in detail to learn about one part of Claude Code’s functionality.

Here is an example of starting a new session in my universal-skill-converter project.

> claude

─── Claude Code v2.1.91 ────────────────────────────────────────────────╮
│                                       │ Tips for getting started      │
│            Welcome back!              │ Run /init to create a CLAUDE… │
│                                       │ ───────────────────────────── │
│               ▐▛███▜▌                 │ Recent activity               │
│              ▝▜█████▛▘                │ 1h ago   Parse @README.md     │
│                ▘▘ ▝▝                  │ 22h ago  Explain @Dockerfile  │
│                                       │ 22h ago  Explain the file @D… │
│  claude-haiku-4.5 · API Usage Billing │ /resume for more              │
│             /opt/claude               │                               │
╰───────────────────────────────────────────────────────────────────────╯
❯ Parse @README.md
  ⎿  Read README.md (4 lines)

● I'll parse the README.md file for you.
  Read 1 file (ctrl+o to expand)

● Based on the README.md file, here's what I found:
  README.md Analysis

  The README.md file contains minimal content:
  # universal-skill-converter

  Summary:
  - The file contains only a title: "universal-skill-converter"
  - There are no additional descriptions, instructions, or content
  - The file appears to be essentially empty except for the project title

  This suggests the project is either in early stages or the README hasn't been populated with detailed
  information yet.

Resume this session with:
claude --resume 67614647-7351-408e-88b8-2846dc62b860

See the output when quitting the session – this is the session name. Let’s take a look at where it is stored in your local ~/.claude directory.

Note: I’m using the claude-code-container from my previous article.

find "${HOME}/.claude" -type f -name *2846dc62b860* | head -5

# Log output
/home/node/.claude/projects/-opt-claude/67614647-7351-408e-88b8-2846dc62b860.jsonl

As can be seen, the complete session transcript is stored in the directory ~/.claude/projects/-opt-claude. The base name of this string is the current working directory, which defaults to /opt/claude when using my container image. This file is a JSON document containing all interactions. Let’s take a look at the first items:

cat /home/node/.claude/projects/-opt-claude/67614647-7351-408e-88b8-2846dc62b860.jsonl | jq | head -15

# Log messages
{
  "type": "permission-mode",
  "permissionMode": "default",
  "sessionId": "67614647-7351-408e-88b8-2846dc62b860"
}
{
  "type": "file-history-snapshot",
  "messageId": "1ce9315d-d77c-4f52-8e8a-bf22db5d9139",
  "snapshot": {
    "messageId": "1ce9315d-d77c-4f52-8e8a-bf22db5d9139",
    "trackedFileBackups": {},
    "timestamp": "2026-04-04T09:37:47.285Z"
  },
  "isSnapshotUpdate": false
}

Items have a type argument. The first messages in the session log represent system messages. Let’s see the other types, and narrow it down to the entered user message.

cat /home/node/.claude/projects/-opt-claude/67614647-7351-408e-88b8-2846dc62b860.jsonl | jq -r '.type' | sort

# Log output
permission-mode
file-history-snapshot
user
user
user
file-history-snapshot
user
assistant
assistant
user
assistant
last-prompt
permission-mode
custom-title
agent-name
system
system
custom-title
agent-name
permission-mode

Let’s see the user message for the first prompt. It contains a set of metadata about the session’s context (parentUuid, promptId, uuid), invocation and version information (version, entrypoint,cwd), and the message itself (message.role, message.content).

{
  "parentUuid": "8d64d2af-615d-4cfe-8843-273de873d9da",
  "isSidechain": false,
  "promptId": "97fe3efe-e395-41b9-96aa-34497e529ca4",
  "type": "user",
  "message": {
    "role": "user",
    "content": "Parse @README.md"
  },
  "uuid": "cfab7717-ca08-45bf-9e0f-2241668efe23",
  "timestamp": "2026-04-04T09:38:00.929Z",
  "permissionMode": "default",
  "userType": "external",
  "entrypoint": "cli",
  "cwd": "/opt/claude",
  "sessionId": "67614647-7351-408e-88b8-2846dc62b860",
  "version": "2.1.91",
  "gitBranch": "main"
}

The directly following system message contains the same context, invocation, and version information, but a structurally different message with message.type, message.role, message.model, and usage statistics.

{
  "parentUuid": "cfab7717-ca08-45bf-9e0f-2241668efe23",
  "isSidechain": false,
  "message": {
    "id": "msg_2026040417373648e22180f7914ce1",
    "type": "message",
    "role": "assistant",
    "model": "claude-sonnet-4.6",
    "content": [
      {
        "type": "text",
        "text": "I'll parse the README.md file for you.\n"
      }
    ],
    "stop_reason": null,
    "stop_sequence": null,
    "usage": {
      "input_tokens": 0,
      "output_tokens": 0
    }
  },
  "type": "assistant",
  "uuid": "9b4b857e-3a25-4b03-b20b-da76f5677c77",
  "timestamp": "2026-04-04T09:38:09.698Z",
  "userType": "external",
  "entrypoint": "cli",
  "cwd": "/opt/claude",
  "sessionId": "67614647-7351-408e-88b8-2846dc62b860",
  "version": "2.1.91",
  "gitBranch": "main",
  "slug": "hashed-enchanting-ritchie"
}

And finally, the directly following tool invocation. It reveals the fields message.content.type, message.content.name, message.content.input.file_path. And at message.usage, statistics about the LLM invocation, which parsed the file content and formulated an answer, can be found.

{
  "parentUuid": "9b4b857e-3a25-4b03-b20b-da76f5677c77",
  "isSidechain": false,
  "message": {
    "id": "msg_2026040417373648e22180f7914ce1",
    "type": "message",
    "role": "assistant",
    "model": "claude-sonnet-4.6",
    "content": [
      {
        "type": "tool_use",
        "id": "call_enqown30a3q",
        "name": "Read",
        "input": {
          "file_path": "/opt/claude/README.md"
        }
      }
    ],
    "stop_reason": "tool_use",
    "stop_sequence": null,
    "usage": {
      "input_tokens": 34459,
      "cache_creation_input_tokens": 0,
      "cache_read_input_tokens": 838,
      "output_tokens": 53,
      "server_tool_use": {
        "web_search_requests": 0,
        "web_fetch_requests": 0
      },
      "service_tier": "standard",
      "cache_creation": {
        "ephemeral_1h_input_tokens": 0,
        "ephemeral_5m_input_tokens": 0
      },
      "inference_geo": "",
      "iterations": [],
      "speed": "standard"
    }
  },
  "type": "assistant",
  "uuid": "2da6dc71-8c0c-486a-9593-b04e0674a795",
  "timestamp": "2026-04-04T09:38:09.698Z",
  "userType": "external",
  "entrypoint": "cli",
  "cwd": "/opt/claude",
  "sessionId": "67614647-7351-408e-88b8-2846dc62b860",
  "version": "2.1.91",
  "gitBranch": "main",
  "slug": "hashed-enchanting-ritchie"
}

These interaction types are at the heart of Claude’s agentic loop. Each prompt you provide gets analyzed, injected into pre-defined system prompts, sent to an LLM, which then provides assistant, tool-run, and tool-execution commands.

With this understanding, let’s continue with investigating the session commands.

Session Configuration

`/add-dir`

Once the Claude session starts, it is bound to the current working directory. This command adds additional directories, and Claude will access and utilize tools in the other directory too.

──────────────────────
❯ /add-dir /opt/spa
──────────────────────
  spac/     directory

...
Add directory to workspace

    /opt/spac

    Claude Code will be able to read files in this directory and make edits when
    auto-accept edits is on.

  ❯ 1. Yes, for this session
    2. Yes, and remember this directory
    3. No

`/rename`

Sessions are created with a generic name. This command provides a memorable name.

❯ /rename universal-skill-converter-refinement
  ⎿  Session renamed to: universal-skill-converter-refinement

─────────────────────────────── universal-skill-converter-refinement ──
❯
─────────────────────────────────────────────────────────────────

`/model`

Model capacities drive the quality of work results. Anthropic distinguishes three different model levels that scale with code complexity: Opus, Sonnet, and Haiku.

The /model command allows manual selection, which you should use on a per-task level. Here is the dialog.

/model
────────────────────────
 Select model
  Switch between Claude models. Applies to this session and future Claude Code
   sessions. For other/previous model names, specify with --model.

  ❯ 1. Default (recommended)  Use the default model (currentlyclaude-sonnet-4.6) ·
                              $3/$15 per Mtok
    2. Sonnet (1M context)    Sonnet 4.6 for long sessions · $3/$15 per Mtok
    3. Opus (1M context)      Opus 4.6 with 1M context · Most capable for
                              complex work
    4. Haiku ✔                Haiku 4.5 · Fastest for quick answers · $1/$5 per
                              Mtok

`/effort`

When LLM models with thinking capabilities are invoked, they will work on a prompt self-reflectively, analyzing and checking their own output before formulating a response to the user. This amount of “thinking” can be controlled by the effort parameter with four values: max, high, medium, low. The default value in Claude is medium, recommended for balancing speed, cost, and task quality, which can be observed by fewer absolute tool calls than on other effort levels.

Here is an example of changing the parameter.

─────────────────────────────────────
❯ /effort  [low|medium|high|max|auto]
─────────────────────────────────────

`/login`

To use an Anthropic account as an LLM provider, either direct API invocation, called console account, or a subscription plan with rolling 5-hour/weekly/monthly token budgets, can be used.

The login command authenticates the current session with one of these options. Select one of the options, then an authorization request to Anthropic is shown. Open the link in your browser, then paste the auth code. Once completed, credentials are persisted in ~/.claude/settings.json, and do not need to be entered when starting the next session.

❯ /login
 Select login method:

 ❯ 1. Claude account with subscription · Pro, Max, Team, or Enterprise

   2. Anthropic Console account · API usage billing

   3. 3rd-party platform · Amazon Bedrock, Microsoft Foundry, or Vertex AI

`/logout`

When using an Anthropic subscription, session credentials are persisted in the ~/.claude/settings.json file. This command revokes the credentials at the Anthropic CLI, removes the credentials from the file, and terminates the session.

❯ /logout
Successfully logged out from your Anthropic account.

Session Reflection

`/cost`

During a long session, lots of tokens will be exchanged between your computer and an LLM provider. This command calculates the total amount of costs, but that’s opinionated toward using an API subscription model with Anthropic. For all other providers, you can add token costs in the manual model definition, and then get an estimate of the incurred costs.

/cost
  ⎿  Total cost:            $0.79
     Total duration (API):  1m 48s
     Total duration (wall): 6m 29s
     Total code changes:    151 lines added, 0 lines removed
     Usage by model:
             claude-haiku-4.5:  51.6k input, 3.1k output, 904.8k cache read, 0 cache
      write ($0.79)

`/usage`

When using Claude Code with an Anthropic subscription plan, this command shows how much of the rolling 5-hour and weekly usage limits is depleted.

This command was removed in v2.1.91, but for completeness, here is an example of its output.

/usage

Plan: Claude Max 5x (subscription)

Current 5-hour window
  Used:       18,400 tokens (23%)
  Remaining:  61,600 tokens (77%)
  Resets in:  2h 12m

Weekly usage
  All models:   38% used (resets Thu 04:00)
  Opus only:     4% used
  Sonnet only:   2% used

Rate limit status: OK (within all limits)
Extra usage:       Disabled

When you use a custom model definition, these models are mapped according to the environment variables "ANTHROPIC_DEFAULT_HAIKU_MODEL",  "ANTHROPIC_DEFAULT_SONNET_MODEL", and "ANTHROPIC_DEFAULT_OPUS_MODEL".

`/status`

Gain a quick overview about the CLI version, selected model, and other account information.

─────────────────────────────────────────────────────────────────
   Status   Config   Usage   Stats

Version: 2.1.91
  Session name: universal-skill-converter-refinement
  Session ID: 9bd58391-93ff-4c59-8d64-31d652281c14
  cwd: /opt/claude/universal-skills-converter/universal-skill-converter
  Auth token: ANTHROPIC_AUTH_TOKEN
  Anthropic base URL: https://api.z.ai/api/anthropic

  Model: claude-sonnet-4.6 (claude-sonnet-4.6)
  Setting sources: User settings, Enterprise managed settings (file)

  System Diagnostics
   ⚠ No write permissions for auto-updates (requires sudo)
``

Show essential CLI, model, and account information

And the config tab.

─────────────────────────────────────────────────────────────────
   Status   Config   Usage   Stats

  ╭─────────────────────────────────────────────────────────────────╮
  │ ⌕ Search settings…                                                                                                              │ 
  ╰─────────────────────────────────────────────────────────────────╯

    Auto-compact                              true
    Show tips                                 true
    Reduce motion                             false
    Thinking mode                             true
    Fast mode (Opus 4.6 only)                 false
    Rewind code (checkpoints)                 true
    Terminal progress bar                     true
    Show turn duration                        true
    Default permission mode                   Default
    Respect .gitignore in file picker         true
    Always copy full response (skip /copy     false
  picker)
    Auto-update channel                (CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAF
                                       FIC set)

    Theme                                     Dark mode
    Notifications                             Auto
    Language                                  Default (English)
    Editor mode                               normal
    Show PR status footer                     true
    Model                                     sonnet[1m]

`/stats`

Every interaction with Claude is logged inside the ./claude directory, with a path-prefix of the current working directory, and session files in JSONL format. These files contain timestamps, and can be used to create a visual representation of usage patterns.

Here are my current stats:

─────────────────────────────────────────────────────────────────
      Overview   Models

        Apr May Jun Jul Aug Sep Oct Nov Dec Jan Feb Mar Apr
        ···············································█▓·▒▒
    Mon ··················································▒
        ···················································
    Wed ················································░··
        ················································▒··
    Fri ················································█▓▓
        ··············································██░▓░

        Less ░ ▒ ▓ █ More

    All time · Last 7 days · Last 30 days

    Favorite model:claude-haiku-4.5     Total tokens: 4.7m

    Sessions: 52                    Longest session: 20h 28m 13s
    Active days: 15/30              Longest streak: 4 days
    Most active day: Mar 8          Current streak: 3 days

    Your longest session is ~6x longer than watching Titanic

And the models tab:

 ─────────────────────────────────────────────────────────────────
      Overview   Models


    Tokens per Day
      861k ┼──╮
      753k ┤  │
      646k ┤  ╰──╮
      538k ┤     │
      430k ┤     ╰──╮              ╭──╮     ╭──╮
      323k ┤     ╭──╮              │  │  ╭──╯  │
      215k ┤  ╭──╯  │              │  ╰──╯     │
      108k ┼──╯     │─────╮  ╭─────╮        ╭──│  ╭──
         0 ┼────────╰────────╯─────╰─────────────────
            Mar 7       Mar 18      Mar 28      Apr 4
    ●claude-haiku-4.5 · ●claude-sonnet-4.6 · ●claude-opus-4.6

    All time · Last 7 days · Last 30 days

    ●claude-haiku-4.5 (51.4%)                 ●claude-opus-4.6 (19.3%)
      In: 2.1m · Out: 350.9k                In: 720.4k · Out: 187.2k
    ●claude-sonnet-4.6 (29.3%)
      In: 1.3m · Out: 47.9k

`/config`

The many settings of Claude Code can be scattered along configuration files. This command allows a top-level overview about all defined settings for a particular session context. It also allows you to edit these settings, which will be persisted in the local .claude folder, the scope which overrides all other settings except managed ones.

As seen in other dialogues too, this one renders vertical tabs, starting with the “Config” section.

─────────────────────────────────────────────────────────────────
   Status   Config   Usage   Stats


  ╭─────────────────────────────────────────────────────────────────╮
  │ ⌕ Search settings…                                                                                                              │ 
  ╰─────────────────────────────────────────────────────────────────╯

    Auto-compact                              true
    Show tips                                 true
    Reduce motion                             false
    Thinking mode                             true
    Rewind code (checkpoints)                 true
    Verbose output                            false
    Terminal progress bar                     true
    Show turn duration                        true
    Default permission mode                   Default
    Respect .gitignore in file picker         true
    Always copy full response (skip /copy     false
  picker)
    Auto-update channel                       latest
    Theme                                     Dark mode
    Notifications                             Auto
    Output style                              default
    Language                                  Default (English)
    Editor mode                               normal
    Show PR status footer                     true
    Model                                     claude-haiku4.5
    Auto-connect to IDE (external terminal)   false
  ↓ 1 more below

  Type to filter · Enter/↓ to select · ↑ to tabs · Esc to clear

The remaining two tabs are just aliases for the /usage and /stats commands.

/update-config

This command triggers an internal skill in which you can instruct a cinfig change.

Here is an example output when modifying the thinking mode.

/update-config Configure the thinking mode.

∴ Thinking…

  The user wants to configure thinking mode. According to the update-config skill, thinking mode is configured using alwaysThinkingEnabled (a simple
  setting that can use the Config tool).

  Let me clarify what they want to configure since "thinking mode" could mean:

- Enable/disable thinking (alwaysThinkingEnabled: true or false)

─────────────────────────────────────────────────────────────────
 ☐ Thinking

Would you like to enable or disable thinking mode?

❯ 1. Enabled
     Always show thinking process (default for Haiku)
  2. Disabled
     Disable extended thinking
  3. Type something.
─────────────────────────────────────────────────────────────────
  4. Chat about this

Enter to select · ↑/↓ to navigate · Esc to cancel

`/export`

The complete conversation log is serialized into JSONL files. User prompts, and the LLMs answers, are rendered in plain text in the terminal. And this representation can be exported into the clipboard or a file.

Here is an example export during working on my skill-converter project.

╭─── Claude Code v2.1.91 ──────────────────────────────────────────────────────╮
│                                           │ Tips for getting started         │
│               Welcome back!               │ Run /init to create a CLAUDE.md… │
│                                           │ ──────────────────────────────── │
│                  ▐▛███▜▌                  │ Recent activity                  │
│                 ▝▜█████▛▘                 │ No recent activity               │
│                   ▘▘ ▝▝                   │                                  │
│                                           │                                  │
│     claude-haiku-4.5 · API Usage Billing  │                                  │
│   /opt/claude/universal-skill-converter   │                                  │
╰──────────────────────────────────────────────────────────────────────────────╯

❯ /rename refactor-to-python
  ⎿  Session renamed to: refactor-to-python

❯ Refactor this app to python. Write the plan file "refactor-to-python.md"

● I'll help you refactor this app to Python. Let me start by exploring the
  codebase to understand its structure and functionality.

● Explore(Explore main codebase structure)
  ⎿  Done (42 tool uses · 45.7k tokens · 5m 21s)
  (ctrl+o to expand)

  Searched for 3 patterns (ctrl+o to expand)

● Now I understand the codebase completely. Let me create a plan file for
  refactoring to Python.

● Updated plan
  ⎿  /plan to preview

● I've created a comprehensive refactoring plan. Let me confirm a few key design
   choices with you:

● User answered Claude's questions:
  ⎿  · Which Python CLI framework should I use? → Click
     · Should I keep the same package structure and CLI command names? → Yes,
     identical
     · What test coverage target should I aim for? → >70%
     · Should I use async/await for file operations? → Sync (blocking)

● Updated plan
  ⎿  /plan to preview
...

❯ /export
  ⎿  Conversation copied to clipboard

`/insights`

All Claude Code interactions are stored in the ~./claude directory, which includes projects, sessions, and all prompts. This command checks all this data to provide a thorough analysis of how you use Claude in the form of an HTML document. It includes a summary of the projects you worked on, your style of interacting with Claude, statistics about session time and duration, and several helpful prompt additions to be put into the CLAUDE.md file. Finally, usage patterns are condensed into skill and hook suggestions.

Here are screenshots of my interactions:

Conclusion

When the Claude Code CLI starts, a new session is created. Sessions are the core context of any interactions, and were covered extensively in this blog article. You gained a general overview about sessions, including the directory layout, JSONL files containing a trace of user, assistant, and tools calls, and the different types of entries in these files. These structures form the backbone commands about session configuration and session reflection. For session configuration, you learned about a) adding additional working directories, b) how to rename a session, c) selecting the LLM to be used in the current session, d) controlling the amount of tokens spent on “thinking”, d) how to perform login and e) logout of an Anthropic subscription. For session reflection, you saw how to a) estimate costs, b) track token consumption, c) see all applicable configuration items, d) see statistics about your Claude Code sessions, e) get an editable text-overview about all currently active settings, f) instruct a config change, g) export user prompts and LLM answers, and h) gain valuable insights and improvements to using Claude Code, including additional sections to be inserted into CLAUDE.md, as well as skills and hooks for frequent changes.

Claude Code: Installation & Setup of the Agentic Coding Tool

Sat, 06 Jun 2026 00:00:00 +0000

In 2024, the evolution of Large Language Models and their utilization in software applications and webpage interfaces started. The GPT-4 model from OpenAI showed unparalleled capabilities for text generation and information assembly. In 2026, two trends merged: The continued evolution of model complexity and capabilities, as well as sophisticated frameworks and libraries that greatly enhanced agentic capabilities of LLM invocation.

Using LLMs as agents once was effectively a continued human-in-the-loop invocation where function calls needed to be monitored and corrected. But now, truly autonomous agents evolved. They apply function calling and function execution precisely, analyze errors and apply solutions when needed. They can fully interact with files and sockets on a computer, making autonomous code generation and even system operations a reality.

On the forefront of agentic tools is the CLI tool Claude Code. It promises and delivers excellent code generation capabilities, supporting developers of all maturity levels with increased productivity.

This article starts a new blog series about agentic tools, and starts with exploring the Claude Code CLI systematically. The particular focus for this article is the installation and initial configuration of Claude Code. Learn how to use a Docker container as a safe sandbox with fine-grained permissions and access only to files that you will work on.

The technical context of this article is claude_code v2.1.91, published on 2026-04-02. Examples and most CLI commands should work with newer versions too.

Docker Container Setup

Claude Code is an agentic tool with full support for creating, editing, and deleting any files on a computer or laptop. It can be installed natively via an install script, which essentially copies a platform-specific binary and required libraries, or as an NPM packages and its requirements.

To prevent accidental file modifications on your main computer, I recommend to setup a Docker image and start a Docker container that mounts your specific directories.

Directory Structure

Setup the following directory and file structure:

.
├── Dockerfile
├── build
│   ├── managed-settings.json

Dockerfile

The Docker image has these features:

Based on the official NodeJS LTS image
Installs claude-code as an NPM package
Copies default security permissions
Runs as a non-root user that can become root with a dedicated password

Here is the file:

FROM node:24-trixie

WORKDIR /opt/claude

RUN apt-get update \
  && apt-get install --no-install-recommends --yes \
    bubblewrap \
    nano \
    socat \
    sudo \
    vim \
  && rm -rf /var/lib/apt/lists/*

RUN npm install -g @anthropic-ai/claude-code@2.1.91 \
  && mkdir -p /etc/claude-code

ARG SUDO_PASSWORD
RUN echo "node:${SUDO_PASSWORD}" | chpasswd
RUN usermod -aG sudo node

COPY build/ /etc/claude-code/

ENV PATH="/home/node/.local/bin:${PATH}"
USER node
CMD ["sleep", "infinity"]

Use this Dockerfile as a staging point. If you are developing a Python, Go, or Rust project, add the required libraries and base tools to this file.

Permissions

When Claude Code starts, a permission dialog for the current folder is opened. By confirming this, read access to all files in this folder is provided. From there on, all tool invocations, from bash commands to binaries, need to be approved too. Certain commands can accidently expose files that contains secrets, run commands that print environment variables, or access network and Docker sockets.

To prevent this access, a permission file can be used. This file should be placed at an OS specific directory so that it provides global rules for all Claude Code sessions. In a Linux environment, the permission file should be placed at the location /etc/claude-code/managed-settings.json.

Paste the following content to prevent accidental exposure of common secrets, and reduce model invocation calls for telemetry.

{
  "$schema": "https://json.schemastore.org/claude-code-settings.json",
  "allow_remote_sessions": false,
  "attribution": {
    "commit": "",
    "pr": ""
  },
  "env": {
    "CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC": "1"
  },
  "permissions": {
    "deny": [
      "Bash(env*)",
      "Bash(netstat*)",
      "Bash(printenv*)",
      "Bash(ssh*)",
      "Bash(ss*)",
      "Bash(nc*)",
      "Bash(ncat*)",
      "Bash(netcat*)",
      "Read(**/.env*)",
      "Read(**/.git-credentials*)",
      "Read(**/.gitconfig*)",
      "Grep(**/.env*)",
      "Grep(**/.git-credentials*)",
      "Grep(**/.gitconfig*)",
      "Read(**/.bashrc*)",
      "Read(**/.zshrc*)",
      "Grep(**/.bashrc*)",
      "Grep(**/.zshrc*)",
      "Read(**/.bash_history*)",
      "Read(**/.zsh_history*)",
      "Grep(**/.bash_history*)",
      "Grep(**/.zsh_history*)",
      "Read(**/.ssh/**)",
      "Grep(**/.ssh/**)",
      "Read(/proc/**)",
      "Read(/proc*)",
      "Grep(/proc/**)",
      "Grep(/proc*)",
      "Read(**/*.sock)",
      "Grep(**/*.sock)",
      "Read(/run/docker.sock)",
      "Read(/var/run/docker.sock)"
    ]
  }
}

Building the Container

Build the container with the following command. A random password will be created for the default user node in order to prevent unobserved privilege escalation:

 docker build . \
  --build-arg SUDO_PASSWORD=$(LC_CTYPE=C tr -cd '[:alnum:]' </dev/urandom | head -c 10) \
  --tag claude-code-local:2.1.91

Take a good look at the build log, it reveals the generated password. Note it down.

Docker Container Usage

Starting the Container

When the Docker image is built, you can start it with the preferred mount directory as follows:

docker run --rm \
  --mount type=bind,src=./,dst=/opt/claude \
  --detach \
  --name claude-code-local \
  claude-code-local:2.1.91

Claude code persists session, memory, and global settings in the local ~/.claude directory. If you wish to keep these settings, you need to create and mount this directory to the container.

In a local terminal:

mkdir -p ~/.claude/

Then, start the container with the additional mount. If you have the container still running, you need to stop it first with docker stop claude-code-local

docker run --rm \
  --mount type=bind,src=./,dst=/opt/claude \
  --mount type=bind,src="${HOME}/.claude",dst=/home/node/.claude \
  --detach \
  --name claude-code-local \
  claude-code-local:2.1.91

Starting a Claude Code session

Model Configuration

During the first startup of the container, you need to authenticate with an LLM provider. In addition to using an Anthropic account, LLM routers such as openrouter or litellm can be used to gain access to any LLM provider, including Azure, Google, Ollama, and others.

You can also use your GitHub Co-Pilot subscription - which is shown here. Run the following command to exec into the container:

docker exec -it claude-code-local bash

Then, install and run the helper library copilot-api.

npx copilot-api@latest start --proxy-env
Need to install the following packages:
copilot-api@0.7.0
Ok to proceed? (y) y
ℹ Using VSCode version: 1.113.0
ℹ Not logged in, getting new access token
ℹ Please enter the code "9A4A-9DB1" in https://github.com/login/device

Open the link, login with your GitHub credentials, and paste the OTP code. Shortly afterwards, you should see which LLM models are selectable for your session.

Available models:
- claude-opus-4.6-fast
- claude-opus-4.6
- claude-sonnet-4.6
- gemini-3.1-pro-preview
- goldeneye-free-auto
- gpt-5.2-codex
- gpt-5.4
- raptor-mini-tertiary
- gpt-5-mini
- gpt-4o-mini-2024-07-18
- gpt-4o-2024-11-20
- gpt-4o-2024-08-06
- grok-code-fast-1
- text-embedding-3-small
- text-embedding-3-small-inference
- claude-haiku-4.5
- gpt-4.1-2025-04-14
- oswe-vscode-prime
- oswe-vscode-secondary
- gpt-41-copilot
- gpt-3.5-turbo-0613
- gpt-4
- gpt-4-0613
- gpt-4-0125-preview
- gpt-4o-2024-05-13
- gpt-4-o-preview
- gpt-4.1
- gpt-3.5-turbo
- gpt-4o-mini
- gpt-4
- gpt-4o
- gpt-4-o-preview
- text-embedding-ada-002

➜ Listening on: http://localhost:4141/ (all interfaces)

Finally, create ~/.claude/settings.json and paste the following content. Be sure to set a model mapping to your liking. Anthropics distinction into Haiku, Sonnet, and Opus needs to be mapped to available GitHub Co-Pilot models.

{
  "env": {
    "ANTHROPIC_BASE_URL": "http://localhost:4141",
    "ANTHROPIC_AUTH_TOKEN": "not-required",
    "ANTHROPIC_DEFAULT_OPUS_MODEL ": "claude-opus-4.6",
    "ANTHROPIC_DEFAULT_SONNET_MODEL ": "claude-sonnet-4.6",
    "ANTHROPIC_DEFAULT_HAIKU_MODEL": "claude-haiku-4.5",
  }
}

Session Start

And finally, you can start a Claude code session. Exec into the Docker container, which automatically jumps to the defined directory /opt/claude with your mounted project.

claude

The opening dialog starts …

And once confirmed, you can start your session.

Conclusion

Claude Code is one of the most prominent agentic tools for code generation. This article starts a new series to systematically explore its CLI tools, slash commands, and use-cases. You learned how to setup a Claude Code in a Docker container, which provides a sandboxed environment into which you mount specific local directories. You saw the Dockerfile, a managed settings permission files that restricts access to sensitive data and environments, and learned the commands to build, start, and use the Docker container. From the many options of LLM providers, GitHub CoPilot was chosen. The next article continues with the exploration of its CLI commands.