Build This Now
Build This Now
TastenkürzelStatus Line Guide
Claude Code VS Code ExtensionClaude Code vs Cursor in 2026OpenClaw vs Claude CodeKI-SEO und GEO-OptimierungClaude Code KeybindingsClaude Code Status-Zeile einrichten
speedy_devvkoen_salo
Blog/Toolkit/Extensions/Claude Code Status Line Setup

Claude Code Status-Zeile einrichten

Richte eine Claude Code Status-Zeile für Modell, Git-Branch, Sitzungskosten und Kontext-Auslastung ein. settings.json-Konfiguration, JSON-Eingabeformat, Bash-, Python- und Node-Skripte.

Hören Sie auf zu konfigurieren. Fangen Sie an zu bauen.

SaaS-Builder-Vorlagen mit KI-Orchestrierung.

Published Feb 24, 2026Toolkit hubExtensions index

Problem: Das Claude Code Terminal blendet viele nützliche Informationen aus. Eine eigene Status-Zeile zeigt dir direkt unter dem Chat-Interface: den Modellnamen, den Git-Branch, die laufenden Sitzungskosten und die Kontext-Auslastung.

Stell sie dir wie PS1 für Claude Code vor. Wenn du schon mal ein Shell-Prompt mit Oh-my-zsh oder Starship angepasst hast, kennst du das Prinzip. Eine Zeile mit Live-Infos, die dich beim Arbeiten orientiert.

Was die Status-Zeile anzeigt

Die Status-Zeile sitzt am unteren Rand des Claude Code Interfaces und aktualisiert sich bei jedem Gesprächswechsel. Was dein Skript ausgibt, wird angezeigt: das aktuelle Modell, den aktiven Git-Branch, die bisherigen Sitzungskosten oder wie voll das Kontextfenster ist.

So sieht eine konfigurierte Status-Zeile in der Praxis aus:

[Opus] my-project | main | $0.42 | Context: 37%

Eine Zeile. Modell, Projektordner, Git-Branch, Sitzungskosten bisher und der prozentuale Anteil des genutzten Kontextfensters. Jedes Feld aktualisiert sich automatisch.

Schnellstart mit /statusline

Der CLI hat den /statusline-Befehl direkt eingebaut. Tippe ihn in Claude Code ein und es wird ein Skript für dich generiert.

/statusline

Das Standardverhalten erstellt ein Status-Zeilen-Skript, das deinen Terminal-Prompt spiegelt. Du kannst auch eine konkrete Anfrage stellen:

/statusline show the model name in orange

/statusline display git branch and session cost

/statusline show context window percentage with color coding

Das war's. Claude Code schreibt das Skript, verdrahtet die Einstellungen und die Status-Zeile erscheint. Für volle Kontrolle geht's jetzt zur manuellen Einrichtung.

Manuelle Einrichtung via settings.json

Um sie von Hand zu konfigurieren, füge einen statusLine-Eintrag in die .claude/settings.json deines Projekts ein (oder in deine globale ~/.claude/settings.json, wenn du sie für alle Projekte willst):

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

Drei Felder, die du kennen solltest:

  • type: Immer "command" für skriptbasierte Status-Zeilen
  • command: Pfad zum Skript, das den Ausgabetext der Status-Zeile erzeugt
  • padding: Anzahl der Leerzeilen über der Status-Zeile (0 ist typisch)

Sobald der Eintrag vorhanden ist, erstelle die Skriptdatei und mache sie ausführbar:

touch ~/.claude/statusline.sh
chmod +x ~/.claude/statusline.sh

Der chmod +x-Schritt ist wichtig. Wenn deine Status-Zeile nie erscheint, liegt es fast immer an einer fehlenden Ausführungsberechtigung.

Wie die Status-Zeilen-Engine funktioniert

Die Mechanismen zu kennen zahlt sich aus, sobald du ein Skript debuggen oder anpassen willst:

  • Aktualisierungsauslöser: Die Status-Zeile wird bei jeder Änderung der Gesprächsnachrichten aktualisiert
  • Drosselung: Aktualisierungen laufen höchstens alle 300ms, um Leistungsprobleme zu vermeiden
  • Ausgabe: Nur die erste Zeile von stdout deines Skripts wird als Status-Zeilen-Text angezeigt
  • Farben: Vollständige ANSI-Farbcode-Unterstützung für die Gestaltung
  • Eingabe: Claude Code leitet ein JSON-Objekt mit Sitzungsdaten via stdin in dein Skript

Der letzte Punkt ist entscheidend. Dein Skript bekommt via stdin eine strukturierte JSON-Nutzlast mit dem aktuellen Modell, Workspace-Pfaden, Sitzungskosten, Kontextfenster-Statistiken und mehr. Parse es, formatiere es, gib eine Zeile auf stdout aus.

Die JSON-Eingabe, die dein Skript erhält

Bei jedem Status-Zeilen-Update bekommt dein Skript diese JSON-Struktur via stdin:

{
  "hook_event_name": "Status",
  "session_id": "abc123...",
  "cwd": "/current/working/directory",
  "model": {
    "id": "claude-opus-4-1",
    "display_name": "Opus"
  },
  "workspace": {
    "current_dir": "/current/working/directory",
    "project_dir": "/original/project/directory"
  },
  "version": "1.0.80",
  "cost": {
    "total_cost_usd": 0.01234,
    "total_duration_ms": 45000,
    "total_api_duration_ms": 2300,
    "total_lines_added": 156,
    "total_lines_removed": 23
  },
  "context_window": {
    "total_input_tokens": 15234,
    "total_output_tokens": 4521,
    "context_window_size": 200000,
    "used_percentage": 42.5,
    "remaining_percentage": 57.5,
    "current_usage": {
      "input_tokens": 8500,
      "output_tokens": 1200,
      "cache_creation_input_tokens": 5000,
      "cache_read_input_tokens": 2000
    }
  }
}

Die Felder, die in einer praktischen Status-Zeile die eigentliche Arbeit erledigen:

  • model.display_name: Kurzer Modellname wie "Opus" oder "Sonnet"
  • workspace.current_dir: Wo du gerade arbeitest
  • cost.total_cost_usd: Laufende Sitzungskosten in Dollar
  • cost.total_lines_added / total_lines_removed: Code-Änderungen verfolgen
  • context_window.used_percentage: Vorberechnete Kontextauslastung (0–100)
  • context_window.context_window_size: Gesamtgröße des Kontextfensters

Status-Zeilen-Skripte zum Kopieren

Unten findest du vollständige, lauffähige Skripte in verschiedenen Sprachen. Nimm das, das zu deinem Setup passt.

Einfache Bash Status-Zeile

Die kleinste Status-Zeile, die sich lohnt. Modellname plus aktuelles Verzeichnis:

#!/bin/bash
input=$(cat)
 
MODEL=$(echo "$input" | jq -r '.model.display_name')
CURRENT_DIR=$(echo "$input" | jq -r '.workspace.current_dir')
 
echo "[$MODEL] ${CURRENT_DIR##*/}"

Ausgabe: [Opus] my-project

Das Skript nutzt jq für das JSON-Parsing. Wenn jq nicht installiert ist, hol es dir mit brew install jq auf macOS oder sudo apt install jq auf Ubuntu.

Git-fähige Bash Status-Zeile

Branch-Informationen kommen dazu, was besonders nützlich ist, wenn du mehrere Feature-Branches jonglierst:

#!/bin/bash
input=$(cat)
 
MODEL=$(echo "$input" | jq -r '.model.display_name')
CURRENT_DIR=$(echo "$input" | jq -r '.workspace.current_dir')
 
GIT_BRANCH=""
if git rev-parse --git-dir > /dev/null 2>&1; then
    BRANCH=$(git branch --show-current 2>/dev/null)
    if [ -n "$BRANCH" ]; then
        GIT_BRANCH=" | $BRANCH"
    fi
fi
 
echo "[$MODEL] ${CURRENT_DIR##*/}$GIT_BRANCH"

Ausgabe: [Opus] my-project | feature/auth

Vollständige Bash Status-Zeile

Modell, Git-Branch, Sitzungskosten und Kontext-Prozentsatz, alles in einer Zeile:

#!/bin/bash
input=$(cat)
 
MODEL=$(echo "$input" | jq -r '.model.display_name')
CURRENT_DIR=$(echo "$input" | jq -r '.workspace.current_dir')
COST=$(echo "$input" | jq -r '.cost.total_cost_usd // 0')
PERCENT_USED=$(echo "$input" | jq -r '.context_window.used_percentage // 0')
 
# Git branch
GIT_BRANCH=""
if git rev-parse --git-dir > /dev/null 2>&1; then
    BRANCH=$(git branch --show-current 2>/dev/null)
    if [ -n "$BRANCH" ]; then
        GIT_BRANCH=" | $BRANCH"
    fi
fi
 
# Format cost to 2 decimal places
COST_FMT=$(printf '%.2f' "$COST")
 
# Round context percentage
PERCENT_INT=$(printf '%.0f' "$PERCENT_USED")
 
echo "[$MODEL] ${CURRENT_DIR##*/}$GIT_BRANCH | \$${COST_FMT} | Ctx: ${PERCENT_INT}%"

Ausgabe: [Opus] my-project | main | $0.42 | Ctx: 37%

Bash mit ANSI-Farben

Farbcodierung macht die Zeile auf einen Blick lesbar:

#!/bin/bash
input=$(cat)
 
MODEL=$(echo "$input" | jq -r '.model.display_name')
CURRENT_DIR=$(echo "$input" | jq -r '.workspace.current_dir')
COST=$(echo "$input" | jq -r '.cost.total_cost_usd // 0')
PERCENT_USED=$(echo "$input" | jq -r '.context_window.used_percentage // 0')
 
# ANSI colors
ORANGE='\033[38;5;208m'
GREEN='\033[32m'
YELLOW='\033[33m'
RED='\033[31m'
CYAN='\033[36m'
RESET='\033[0m'
 
# Color context percentage based on usage
PERCENT_INT=$(printf '%.0f' "$PERCENT_USED")
if [ "$PERCENT_INT" -lt 50 ]; then
    CTX_COLOR=$GREEN
elif [ "$PERCENT_INT" -lt 80 ]; then
    CTX_COLOR=$YELLOW
else
    CTX_COLOR=$RED
fi
 
COST_FMT=$(printf '%.2f' "$COST")
 
echo -e "${ORANGE}[$MODEL]${RESET} ${CURRENT_DIR##*/} ${CYAN}\$${COST_FMT}${RESET} ${CTX_COLOR}Ctx:${PERCENT_INT}%${RESET}"

Unter 50% ist der Kontext-Prozentsatz grün. Zwischen 50–80% gelb. Über 80% rot. Ein schnelles visuelles Signal, wann es Zeit ist, das Kontextfenster zu verwalten.

Hilfsfunktionen für komplexere Skripte

Wenn ein Status-Zeilen-Skript wächst, halten Hilfsfunktionen es lesbar:

#!/bin/bash
input=$(cat)
 
# Helper functions for clean extraction
get_model()     { echo "$input" | jq -r '.model.display_name'; }
get_dir()       { echo "$input" | jq -r '.workspace.current_dir'; }
get_cost()      { echo "$input" | jq -r '.cost.total_cost_usd // 0'; }
get_context()   { echo "$input" | jq -r '.context_window.used_percentage // 0'; }
get_added()     { echo "$input" | jq -r '.cost.total_lines_added // 0'; }
get_removed()   { echo "$input" | jq -r '.cost.total_lines_removed // 0'; }
get_version()   { echo "$input" | jq -r '.version'; }
 
MODEL=$(get_model)
DIR=$(get_dir)
COST=$(printf '%.2f' "$(get_cost)")
CTX=$(printf '%.0f' "$(get_context)")
ADDED=$(get_added)
REMOVED=$(get_removed)
 
echo "[$MODEL] ${DIR##*/} | \$$COST | Ctx:${CTX}% | +$ADDED/-$REMOVED"

Ausgabe: [Opus] my-project | $0.42 | Ctx:37% | +156/-23

+156/-23 am Ende verfolgt hinzugefügte und entfernte Zeilen in der Sitzung. Ein schneller Überblick, wie viel Code sich tatsächlich geändert hat.

Python Status-Zeile

Für Python-Nutzer statt Bash:

#!/usr/bin/env python3
import json
import sys
import os
import subprocess
 
data = json.load(sys.stdin)
 
model = data["model"]["display_name"]
current_dir = os.path.basename(data["workspace"]["current_dir"])
cost = data.get("cost", {}).get("total_cost_usd", 0)
ctx_pct = data.get("context_window", {}).get("used_percentage", 0)
 
# Get git branch
git_branch = ""
try:
    result = subprocess.run(
        ["git", "branch", "--show-current"],
        capture_output=True, text=True, timeout=2
    )
    if result.returncode == 0 and result.stdout.strip():
        git_branch = f" | {result.stdout.strip()}"
except Exception:
    pass
 
print(f"[{model}] {current_dir}{git_branch} | ${cost:.2f} | Ctx:{ctx_pct:.0f}%")

Node.js Status-Zeile

Für JavaScript-Entwickler:

#!/usr/bin/env node
const fs = require("fs");
const path = require("path");
const { execSync } = require("child_process");
 
let input = "";
process.stdin.on("data", (chunk) => (input += chunk));
process.stdin.on("end", () => {
  const data = JSON.parse(input);
 
  const model = data.model.display_name;
  const currentDir = path.basename(data.workspace.current_dir);
  const cost = (data.cost?.total_cost_usd || 0).toFixed(2);
  const ctxPct = Math.round(data.context_window?.used_percentage || 0);
 
  // Get git branch
  let gitBranch = "";
  try {
    const branch = execSync("git branch --show-current", {
      encoding: "utf8",
      timeout: 2000,
    }).trim();
    if (branch) gitBranch = ` | ${branch}`;
  } catch (e) {}
 
  console.log(
    `[${model}] ${currentDir}${gitBranch} | $${cost} | Ctx:${ctxPct}%`,
  );
});

Kontext-Auslastung verfolgen

Das Kontextfenster im Auge zu behalten ist einer der praktischsten Gründe, eine Status-Zeile zu betreiben. Wenn es sich füllt, komprimiert Claude Code das Gespräch und Details gehen verloren. Zu sehen, wo du stehst, hilft dir zu entscheiden, wann du neu anfangen oder selbst komprimieren willst.

Einfacher Ansatz mit dem vorberechneten Prozentsatz:

#!/bin/bash
input=$(cat)
 
MODEL=$(echo "$input" | jq -r '.model.display_name')
PERCENT_USED=$(echo "$input" | jq -r '.context_window.used_percentage // 0')
 
echo "[$MODEL] Context: ${PERCENT_USED}%"

Erweiterter Ansatz mit manueller Berechnung aus rohen Token-Zahlen:

#!/bin/bash
input=$(cat)
 
MODEL=$(echo "$input" | jq -r '.model.display_name')
CONTEXT_SIZE=$(echo "$input" | jq -r '.context_window.context_window_size')
USAGE=$(echo "$input" | jq '.context_window.current_usage')
 
if [ "$USAGE" != "null" ]; then
    CURRENT_TOKENS=$(echo "$USAGE" | jq '.input_tokens + .cache_creation_input_tokens + .cache_read_input_tokens')
    PERCENT_USED=$((CURRENT_TOKENS * 100 / CONTEXT_SIZE))
    echo "[$MODEL] Context: ${PERCENT_USED}% (${CURRENT_TOKENS}/${CONTEXT_SIZE} tokens)"
else
    echo "[$MODEL] Context: 0%"
fi

Die erweiterte Version zeigt die rohen Token-Zahlen neben dem Prozentsatz. Nützlich, wenn du das genaue verbleibende Token-Budget wissen willst, besonders wenn du zwischen Modellen mit unterschiedlichen Kontextgrößen wechselst.

Sitzungskosten verfolgen

cost.total_cost_usd aktualisiert sich in Echtzeit. Es in der Status-Zeile anzuzeigen hält die Ausgaben sichtbar, ohne einen Blick ins Dashboard zu werfen:

#!/bin/bash
input=$(cat)
 
MODEL=$(echo "$input" | jq -r '.model.display_name')
COST=$(echo "$input" | jq -r '.cost.total_cost_usd // 0')
COST_FMT=$(printf '%.2f' "$COST")
 
echo "[$MODEL] Session: \$${COST_FMT}"

Für alle mit einem Budget oder Kostentracking pro Feature zahlt sich diese Transparenz sofort aus. Kombiniere es mit Modellauswahlstrategien und du tauschst Modelle, sobald eine Aufgabe keine Opus-Qualität mehr erfordert.

Fehlerbehebung

Status-Zeile erscheint gar nicht

Eine fehlende Ausführungsberechtigung an der Skriptdatei ist der häufigste Grund. Behebe es mit:

chmod +x ~/.claude/statusline.sh

Skript läuft, aber Ausgabe ist leer

Dein Skript schreibt möglicherweise auf stderr statt auf stdout. Nur die erste Zeile von stdout erreicht die Status-Zeile. Füge kurz echo "test" ein, um die Ausgabe zu bestätigen, dann baue darauf auf.

Skript manuell testen

Du kannst testen ohne Claude Code zu starten, indem du Mock-JSON direkt in das Skript leitest:

echo '{"model":{"display_name":"Test"},"workspace":{"current_dir":"/test"},"cost":{"total_cost_usd":0.5},"context_window":{"used_percentage":25}}' | ~/.claude/statusline.sh

Wenn das die erwartete Zeile ausgibt, ist das Skript in Ordnung. Wenn nichts kommt, liegt das Problem im Parsing.

jq nicht gefunden

Hol es dir aus deinem Paketmanager:

# macOS
brew install jq
 
# Ubuntu/Debian
sudo apt install jq
 
# Windows (via scoop)
scoop install jq

Kreative Status-Zeilen-Ideen

Wenn die Basics laufen, ein paar Ideen, um die Status-Zeile weiterzuentwickeln:

  • Zeilen-Änderungs-Tracker: Gib +hinzugefügt/-entfernt aus, um die Produktivität der Sitzung im Blick zu behalten
  • Sitzungsdauer: Leite die verstrichene Zeit aus total_duration_ms ab
  • Modell-ID anzeigen: Zeige den vollständigen Modell-Identifier beim Testen verschiedener Modellkonfigurationen
  • Projekt- vs. aktuelles Verzeichnis: Zeige beides, wenn Claude Code in Unterverzeichnisse wechselt
  • Kosten pro Minute: Teile total_cost_usd durch total_duration_ms und sieh die echte Verbrauchsrate
  • Kontextfenster-Balken: Tausche den Prozentsatz gegen einen visuellen Balken wie [========--]
  • Bedingte Warnungen: Wechsle Farben, wenn der Kontext 80% überschreitet oder die Kosten einen Schwellenwert überschreiten

Die Status-Zeile führt jedes Skript aus, das du ihr gibst. Bash, Python, Node.js, alles was du schreiben kannst, wird auf dem Bildschirm dargestellt.

Was du als Nächstes ausprobieren kannst

Deine Status-Zeile läuft. Natürliche nächste Schritte:

  • Kontext proaktiv verwalten: Nutze den Kontext-Prozentsatz zusammen mit Kontext-Puffer-Verwaltungsstrategien
  • Terminal-Umgebung einrichten: Lerne Terminal-Steuerungstechniken für einen vollständigen Claude Code Workspace
  • Projekteinstellungen konfigurieren: Verankere deine Konfigurationsgrundlagen, damit jede Sitzung mit dem richtigen Kontext startet

Continue in Extensions

  • KI-SEO und GEO-Optimierung
    Ein Überblick über Generative Engine Optimization: Wie du dafür sorgst, dass deine Inhalte in ChatGPT-, Claude- und Perplexity-Antworten zitiert werden, statt nur bei Google zu ranken.
  • Claude Code vs Cursor in 2026
    Ein direkter Vergleich von Claude Code und Cursor in 2026: Agentenmodelle, Kontextfenster, Preisstufen und welches Tool zu welchem Entwickler-Workflow passt.
  • Claude Code VS Code Extension
    Anthropics VS Code Extension bringt Claude Code als Spark-Icon-Panel in die Editor-Seitenleiste, mit Inline-Diffs, Plan-Modus, Subagenten und MCP-Unterstützung.
  • Claude Code Keybindings
    Belege Claude Code-Shortcuts über keybindings.json neu. 17 Kontexte, Tastenkombinations-Syntax, Chord-Sequenzen, Modifier-Stacks, Standard-Bindings deaktivieren, kopierfertige Konfigurationen.
  • OpenClaw vs Claude Code
    OpenClaw vs Claude Code: ein Lebensassistent in Messaging-Apps versus ein Terminal-Coding-Agent, der dein Repo liest. Wann jedes Tool einen Platz im Workflow verdient.

More from Toolkit

  • Tastenkürzel
    Claude Code keybindings.json konfigurieren: 17 Kontexte, Tastenkombinations-Syntax, Chord-Sequenzen, Modifier-Kombinationen und wie du jeden Standard-Shortcut sofort deaktivierst.
  • Status Line Guide
    Richte eine Claude Code Status Line ein, die Modellname, Git-Branch, Sitzungskosten und Kontextnutzung anzeigt. settings.json-Konfiguration, JSON-Eingabe, Bash-, Python- und Node.js-Skripte.
  • Claude Code Setup-Hooks
    Verknüpfe Skripte, Agenten und Docs in Claude Code Setup-Hooks. Ein Befehl führt ein deterministisches Skript aus, übergibt die Ausgabe an einen diagnostizierenden Agenten und protokolliert lebendige Dokumentation.
  • Kontext-Backup-Hooks für Claude Code
    Ein StatusLine-gesteuerter Claude Code Kontext-Backup-Hook. Schreibt strukturierte Snapshots alle 10K Tokens, damit die Auto-Komprimierung nie Fehler, Signaturen und Entscheidungen verschluckt.

Hören Sie auf zu konfigurieren. Fangen Sie an zu bauen.

SaaS-Builder-Vorlagen mit KI-Orchestrierung.

On this page

Was die Status-Zeile anzeigt
Schnellstart mit /statusline
Manuelle Einrichtung via settings.json
Wie die Status-Zeilen-Engine funktioniert
Die JSON-Eingabe, die dein Skript erhält
Status-Zeilen-Skripte zum Kopieren
Einfache Bash Status-Zeile
Git-fähige Bash Status-Zeile
Vollständige Bash Status-Zeile
Bash mit ANSI-Farben
Hilfsfunktionen für komplexere Skripte
Python Status-Zeile
Node.js Status-Zeile
Kontext-Auslastung verfolgen
Sitzungskosten verfolgen
Fehlerbehebung
Kreative Status-Zeilen-Ideen
Was du als Nächstes ausprobieren kannst

Hören Sie auf zu konfigurieren. Fangen Sie an zu bauen.

SaaS-Builder-Vorlagen mit KI-Orchestrierung.