Build This Now
Build This Now
TastenkürzelStatus Line Guide
speedy_devvkoen_salo
Blog/Toolkit/Status Line Guide

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.

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

SaaS-Builder-Vorlagen mit KI-Orchestrierung.

Published Feb 27, 2026Toolkit hub

Richte eine eigene Claude Code Status Line ein, die Modellname, Git-Branch, Kosten und Kontextnutzung anzeigt. Inklusive kopierfertige Skripte.

Deinem Claude Code Terminal fehlen nützliche Informationen. Die Status Line löst das, indem sie Modellname, Git-Branch, Sitzungskosten und Kontextnutzung direkt am unteren Rand der Oberfläche anzeigt.

Stell es dir wie PS1 für Claude Code vor. Wenn du jemals einen Shell-Prompt mit Oh-my-zsh oder Starship angepasst hast, ist das hier dieselbe Idee. Eine Zeile mit Echtzeitinfos, die dich beim Arbeiten orientiert hält.

Was die Status Line anzeigt

Die Status Line sitzt am unteren Rand der Claude Code Oberfläche und aktualisiert sich jedes Mal, wenn sich die Konversation ändert. Sie kann alles anzeigen, was dein Skript ausgibt: das aktuelle Modell, welchen Git-Branch du gerade nutzt, wie viel die Sitzung bisher gekostet hat oder wie voll dein Kontextfenster ist.

So sieht eine konfigurierte Status Line in der Praxis aus:

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

Diese eine Zeile zeigt dir das Modell, den Projektordner, den Git-Branch, die bisherigen Sitzungskosten und den Prozentsatz des genutzten Kontextfensters. Alles wird automatisch aktualisiert.

Schnelleinrichtung mit /statusline

Der schnellste Weg zu einer funktionierenden Status Line ist der eingebaute /statusline-Befehl. Gib ihn direkt in Claude Code ein, und er generiert ein Skript für dich.

/statusline

Claude Code erstellt standardmäßig ein Status Line-Skript, das deinen Terminal-Prompt widerspiegelt. Du kannst aber auch konkrete Anweisungen geben:

/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 schon. Claude Code schreibt das Skript, konfiguriert die Einstellungen, und die Status Line erscheint. Wenn du mehr Kontrolle möchtest, lies weiter zur manuellen Einrichtung.

Manuelle Einrichtung über settings.json

Für volle Kontrolle füge einen statusLine-Eintrag in die .claude/settings.json deines Projekts ein (oder in die globale ~/.claude/settings.json für alle Projekte):

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

Drei Felder, die du kennen musst:

  • type: Immer "command" für skriptbasierte Status Lines
  • command: Pfad zum Skript, das die Status Line-Ausgabe erzeugt
  • padding: Anzahl leerer Zeilen über der Status Line (0 ist typisch)

Erstelle danach 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 Line nicht erscheint, liegt es fast immer an einer fehlenden Ausführungsberechtigung.

Wie die Status Line Engine funktioniert

Das Verständnis der Mechanik hilft beim Debuggen oder beim Erstellen eigener Skripte:

  • Auslöser für Updates: Die Status Line aktualisiert sich, wenn sich Konversationsnachrichten ändern
  • Drosselung: Updates laufen höchstens alle 300ms, um Performance-Probleme zu vermeiden
  • Ausgabeverarbeitung: Nur die erste Zeile der stdout-Ausgabe deines Skripts wird der Status Line-Text
  • Farben: Volle Unterstützung für ANSI-Farbcodes zum Styling
  • Eingabe: Claude Code leitet ein JSON-Objekt mit Sitzungsdaten über stdin in dein Skript

Der letzte Punkt ist der Schlüssel. Dein Skript bekommt strukturiertes JSON mit dem aktuellen Modell, Workspace-Pfaden, Sitzungskosten, Kontextfenster-Statistiken und mehr. Parse es, formatiere es, gib eine Zeile auf stdout aus.

Das JSON, das dein Skript empfängt

Bei jedem Status Line-Update bekommt dein Skript diese JSON-Struktur über 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 für praktische Status Lines am wichtigsten sind:

  • 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 Kontextnutzung (0-100)
  • context_window.context_window_size: Gesamtkapazität des Kontextfensters

Status Line-Skripte zum Kopieren

Hier sind vollständige, ausführbare Skripte in mehreren Sprachen. Nimm das, das zu deinem Setup passt.

Einfache Bash Status Line

Die einfachste nützliche Status Line. Zeigt Modellname und 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

Dieses Skript nutzt jq zum JSON-Parsen. Wenn du es nicht installiert hast, führe brew install jq unter macOS oder sudo apt install jq unter Ubuntu aus.

Git-fähige Bash Status Line

Fügt den aktuellen Git-Branch hinzu, was 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 Line

Modell, Git-Branch, Kosten und Kontextprozentsatz 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

Farbkodierte Ausgabe macht Informationen auf einen Blick erfassbar:

#!/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}"

Der Kontextprozentsatz wird unter 50% grün, zwischen 50-80% gelb und über 80% rot. Du siehst sofort, wann es Zeit ist, dein Kontextfenster zu verwalten.

Hilfsfunktions-Ansatz für komplexe Skripte

Wenn dein Status Line-Skript wächst, halten Hilfsfunktionen es übersichtlich:

#!/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

Das +156/-23 zeigt hinzugefügte und entfernte Zeilen in der Sitzung. Ein schneller Weg, um zu sehen, wie viel Code sich verändert hat.

Python Status Line

Wenn du Python gegenüber Bash bevorzugst:

#!/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 Line

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}%`,
  );
});

Kontextfensternutzung verfolgen

Dein Kontextfenster im Blick zu behalten ist eine der praktischsten Verwendungen für die Status Line. Wenn der Kontext voll ist, komprimiert Claude Code die Konversation und du verlierst Details. Zu wissen, wo du stehst, hilft dir zu entscheiden, wann du neu starten oder strategisch komprimieren solltest.

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

Der manuelle Ansatz zeigt dir rohe Token-Zahlen neben dem Prozentsatz. Nützlich, wenn du genau wissen willst, wie viele Tokens du noch hast, besonders wenn du zwischen verschiedenen Modellen mit unterschiedlichen Kontextgrößen wählst.

Sitzungskosten verfolgen

Das Feld cost.total_cost_usd aktualisiert sich in Echtzeit. Es in deiner Status Line anzuzeigen, macht Ausgaben sichtbar, ohne das Dashboard zu öffnen:

#!/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}"

Wenn du ein Budget hast oder Kosten pro Feature verfolgst, ist das sofort nützlich. Kombiniere es mit Modellauswahlstrategien, um auf günstigere Modelle zu wechseln, wenn eine Aufgabe die teuerste Option nicht braucht.

Fehlerbehebung

Status Line erscheint gar nicht

Die häufigste Ursache ist eine fehlende Ausführungsberechtigung für die Skriptdatei. Behebe das mit:

chmod +x ~/.claude/statusline.sh

Skript läuft, aber Ausgabe ist leer

Dein Skript schreibt vielleicht auf stderr statt auf stdout. Die Status Line liest nur die erste Zeile von stdout. Füge ein einfaches echo "test" hinzu, um die Ausgabe zu prüfen, und baue dann von dort aus.

Dein Skript manuell testen

Du kannst ohne laufendes Claude Code testen, indem du Mock-JSON in dein Skript pipest:

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 Ausgabe druckt, funktioniert das Skript. Wenn nicht, liegt das Problem im Parsen.

jq nicht gefunden

Installiere es mit deinem Paketmanager:

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

Kreative Status Line-Ideen

Sobald die Grundlagen funktionieren, hier ein paar Ideen, um deine Status Line nützlicher zu machen:

  • Geänderter-Zeilen-Tracker: Zeige +hinzugefügt/-entfernt, um die Sitzungsproduktivität zu überwachen
  • Sitzungsdauer: Berechne die verstrichene Zeit aus total_duration_ms
  • Modell-ID-Anzeige: Zeige den vollständigen Modellbezeichner beim Testen verschiedener Modellkonfigurationen
  • Projekt- vs. aktuelles Verzeichnis: Zeige beides, wenn Claude Code in Unterverzeichnisse navigiert
  • Kosten pro Minute: Teile total_cost_usd durch total_duration_ms, um die Verbrauchsrate zu sehen
  • Kontextfenster-Balken: Ersetze den Prozentsatz durch einen visuellen Balken wie [========--]
  • Bedingte Warnungen: Zeige eine Farbe an, wenn der Kontext 80% überschreitet oder die Kosten einen Schwellenwert erreichen

Die Status Line führt ein Skript aus, das du kontrollierst. Wenn du es in Bash, Python oder Node.js schreiben kannst, kannst du es anzeigen. Wenn du das Scripting lieber überspringst, kommt ClaudeFasts Code Kit mit einem vorgefertigten statusline-monitor.mjs, das Kontextnutzung, API-Budget und Backup-Status sofort anzeigt.

Was du als nächstes ausprobieren kannst

Deine Status Line ist eingerichtet. Hier sind natürliche nächste Schritte:

  • Kontext proaktiv verwalten: Nutze deine Kontextprozentsatz-Anzeige zusammen mit Kontextpuffer-Verwaltungsstrategien
  • Terminalumgebung einrichten: Lerne Terminal-Kontrollechniken für einen vollständigen Claude Code Workspace
  • Projekteinstellungen konfigurieren: Stelle sicher, dass deine Konfigurationsgrundlagen solide sind, damit jede Sitzung mit dem richtigen Kontext startet

More in Toolkit

  • Tastenkürzel
    Claude Code keybindings.json konfigurieren: 17 Kontexte, Tastenkombinations-Syntax, Chord-Sequenzen, Modifier-Kombinationen und wie du jeden Standard-Shortcut sofort deaktivierst.
  • 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.

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

SaaS-Builder-Vorlagen mit KI-Orchestrierung.

Tastenkürzel

Claude Code keybindings.json konfigurieren: 17 Kontexte, Tastenkombinations-Syntax, Chord-Sequenzen, Modifier-Kombinationen und wie du jeden Standard-Shortcut sofort deaktivierst.

Hooks-Leitfaden

Claude Code Hooks von Grund auf: Exit-Codes, JSON-Ausgabe, asynchrone Befehle, HTTP-Endpunkte, PreToolUse- und PostToolUse-Matcher, Produktionsmuster.

On this page

Was die Status Line anzeigt
Schnelleinrichtung mit /statusline
Manuelle Einrichtung über settings.json
Wie die Status Line Engine funktioniert
Das JSON, das dein Skript empfängt
Status Line-Skripte zum Kopieren
Einfache Bash Status Line
Git-fähige Bash Status Line
Vollständige Bash Status Line
Bash mit ANSI-Farben
Hilfsfunktions-Ansatz für komplexe Skripte
Python Status Line
Node.js Status Line
Kontextfensternutzung verfolgen
Sitzungskosten verfolgen
Fehlerbehebung
Kreative Status Line-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.