Claude Code Statusline einrichten: Script zum Download

Eine Claude-Code-Session kann lange sauber laufen und später Details übersehen, die am Anfang noch präsent waren. Das Modell blieb gleich. Sein Arbeitskontext hat sich verändert.

Genau dafür habe ich mir eine eigene Statusline gebaut. Sie zeigt mir während der Arbeit, wie voll der Context ist, welches Modell läuft, auf welchem Git-Branch ich arbeite und wann meine Rate Limits zurückgesetzt werden.

So sieht sie in einer laufenden Session aus:

[Sonnet 5] | 🌿 main | 🧠 ███████░░░ 72% | 🔢 143820 tok | 💰 $1.8420 | ⏱️ 48m 12s
Rate Limits: 📊 5h: 64% ↺ 17:30 24.07.2026 | 7d: 37% ↺ 17:30 31.07.2026

Die Installation dauert etwa zwei Minuten. Das Script läuft lokal, benötigt kein jq und verbraucht selbst keine API-Tokens.

Was zeigt die Claude Code Statusline?

Die Statusline fasst die Daten zusammen, die ich während einer Coding-Session regelmäßig brauche:

Die Anzeige aktualisiert sich nach Ereignissen in Claude Code, zum Beispiel nach einer neuen Antwort oder nach /compact. Anthropic führt die möglichen Trigger und alle verfügbaren JSON-Felder in der offiziellen Statusline-Dokumentation auf.

Warum ist die Context-Auslastung die wichtigste Zahl?

Anthropic beschreibt den Context als Arbeitsgedächtnis des Modells. Darin liegen der Gesprächsverlauf, gelesene Dateien, Tool-Ausgaben, Systemanweisungen, CLAUDE.md-Inhalte und geladene Skills.

Mehr Context liefert dem Modell mehr Material. Gleichzeitig sinken bei sehr langen Kontexten oft Genauigkeit und Erinnerungsvermögen. Anthropic verwendet dafür den Begriff „Context Rot“ und erklärt die Ursachen im Beitrag Effective context engineering for AI agents.

Claude Code räumt selbst auf, sobald das Context Window an seine Grenze kommt. Ältere Tool-Ausgaben werden entfernt. Bei Bedarf fasst Claude Code anschließend den bisherigen Verlauf zusammen.

Diese Verdichtung ist hilfreich, aber sie kann Details aus frühen Anweisungen verlieren. Anthropic empfiehlt deshalb, dauerhafte Projektregeln in CLAUDE.md zu speichern und bei einem Themenwechsel mit /clear einen frischen Context zu öffnen. Mehr dazu steht in den offiziellen Seiten Explore the context window und Best practices for Claude Code.

Wie lese ich die Context-Ampel?

Mein Script teilt die Auslastung in drei Bereiche ein. Die Grenzen sind meine Arbeitsregel und keine offizielle Empfehlung von Anthropic.

Bei Gelb nutze ich bei Bedarf einen fokussierten Compact:

/compact focus on the authentication bug, the chosen fix and all open tests

Der Zusatz hilft Claude Code dabei, die passende Information in die Zusammenfassung zu übernehmen. Bei einem fachlich neuen Task nutze ich /clear. So muss das Modell alten Gesprächsverlauf nicht bei jeder weiteren Antwort erneut verarbeiten.

Die Prozentzahl sagt wenig über die Qualität einzelner Tokens aus. Ein sauberer Context mit 75 Prozent kann besser funktionieren als ein chaotischer Context mit 40 Prozent. Die Anzeige ist ein Frühwarnsystem, kein Qualitätsmesser.

Welche Vorteile bringt die Statusline im Alltag?

1. Der Context wird sichtbar

Ohne Statusline merke ich einen überfüllten Context häufig erst an den Symptomen: Claude liest dieselbe Datei erneut, vergisst eine Entscheidung oder zieht eine alte Anforderung heran. Die Prozentanzeige zeigt mir früher, wann ich die Session aufräumen sollte.

2. Modell und Branch stehen direkt nebeneinander

Bei mehreren Terminal-Tabs ist schnell unklar, welche Session zu welchem Branch gehört. Die Statusline liest den aktuellen Git-Branch aus dem Arbeitsverzeichnis und setzt ihn neben den Modellnamen.

3. Rate Limits werden planbar

Pro- und Max-Abonnenten erhalten nach der ersten API-Antwort Daten zum 5-Stunden- und 7-Tage-Fenster. Das Script zeigt die Nutzung samt Reset-Zeitpunkt. Fehlen diese Daten, blendet es die zweite Zeile aus.

4. Kosten und Laufzeit bekommen einen Platz

total_cost_usd ist eine clientseitige Schätzung und kann von der späteren Abrechnung abweichen. Bei einem Claude.ai-Abo kann der Wert fehlen oder bei null bleiben. Für API-Sessions hilft er trotzdem dabei, ein Gefühl für den Verbrauch einer langen Session zu entwickeln.

5. Das Script braucht kein jq

Viele Statusline-Beispiele verwenden jq zum Lesen des JSON-Inputs. Meine Variante nutzt Python und erkennt automatisch python3 oder python. Das ist auch in Git Bash praktisch, wo python3 manchmal nur auf den Windows Store verweist.

Wie installiere ich die Statusline?

Schritt 1: Script herunterladen

statusline Script kostenlos herunterladen (als .txt Datei)

und speichere sie unter:

~/.claude/statusline.sh

Auf macOS und Linux steht ~ für dein Home-Verzeichnis. Unter Windows funktioniert das Script am einfachsten in Git Bash, sofern Python installiert und über python oder python3 erreichbar ist.

Schritt 2: Script ausführbar machen

chmod +x ~/.claude/statusline.sh

Schritt 3: Claude Code konfigurieren

Ergänze in ~/.claude/settings.json den Eintrag statusLine:

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

Wenn deine Datei bereits weitere Einstellungen enthält, ergänzt du nur das Feld statusLine. Achte auf die Kommata zwischen den vorhandenen JSON-Einträgen.

Schritt 4: Nächste Interaktion abwarten

Claude Code lädt Änderungen an den Settings automatisch. Die Anzeige erscheint nach der nächsten Interaktion. Rate-Limit-Daten stehen bei Pro und Max erst nach der ersten API-Antwort der Session bereit.

Claude Code kann über den Befehl /statusline auch selbst eine einfache Statusleiste erzeugen. Das Script aus diesem Artikel enthält bereits die farbige Context-Ampel, Git-Branch, Tokenanzeige, Laufzeit und beide Rate-Limit-Fenster.

Wie funktioniert das Script?

Claude Code übergibt bei jeder Aktualisierung ein JSON-Objekt über stdin. Das Script liest diesen Input ein und zerlegt die benötigten Felder mit Python.

input=$(cat)

Danach sucht es nach einer erreichbaren Python-Version:

if python3 -c "import sys" >/dev/null 2>&1; then
    PY=python3
elif python -c "import sys" >/dev/null 2>&1; then
    PY=python
else
    PY=""
fi

Der Python-Teil liest unter anderem diese Werte:

Seit Claude Code 2.1.132 sind total_input_tokens und total_output_tokens keine kumulierten Session-Werte mehr. Sie beschreiben den aktuellen Context aus der jüngsten API-Antwort. Das Script addiert beide Werte für die kompakte Tokenanzeige.

Der Fortschrittsbalken besteht aus zehn Segmenten. Jedes Segment steht für zehn Prozent. ANSI-Farbcodes färben Balken und Rate Limits grün, gelb oder rot.

Der vollständige Code für statusline.sh

#!/usr/bin/env bash
#
# Claude Code status line by Obvious Works
# Documentation: https://code.claude.com/docs/en/statusline
#
# Installation:
#   1. Copy this file to ~/.claude/statusline.sh
#   2. Make it executable: chmod +x ~/.claude/statusline.sh
#   3. Add this to ~/.claude/settings.json:
#      "statusLine": {
#        "type": "command",
#        "command": "~/.claude/statusline.sh"
#      }
#
# The script uses Python for JSON parsing, so jq is not required.

input=$(cat)

# On Git Bash, python3 can be a Windows Store stub. Fall back to python.
if python3 -c "import sys" >/dev/null 2>&1; then
    PY=python3
elif python -c "import sys" >/dev/null 2>&1; then
    PY=python
else
    PY=""
fi

if [ -n "$PY" ]; then
    JSON=$(printf '%s' "$input" | "$PY" -c "
import json
import sys
from datetime import datetime

d = json.load(sys.stdin)
m = d.get('model', {})
cw = d.get('context_window', {})
c = d.get('cost', {})
rl = d.get('rate_limits', {})

model = m.get('display_name', 'unknown')
cwd = d.get('workspace', {}).get('current_dir', '') or d.get('cwd', '')
cost = float(c.get('total_cost_usd', 0) or 0)
pct = int(float(cw.get('used_percentage', 0) or 0))
dur = int(c.get('total_duration_ms', 0) or 0)
tok_in = int(cw.get('total_input_tokens', 0) or 0)
tok_out = int(cw.get('total_output_tokens', 0) or 0)

rl_5h = rl.get('five_hour', {}).get('used_percentage')
rl_7d = rl.get('seven_day', {}).get('used_percentage')
rl_5h_s = f'{rl_5h:.0f}' if rl_5h is not None else ''
rl_7d_s = f'{rl_7d:.0f}' if rl_7d is not None else ''

def fmt_ts(ts):
    if ts is None:
        return ''
    return datetime.fromtimestamp(int(ts)).strftime('%H:%M %d.%m.%Y')

rl_5h_ra = fmt_ts(rl.get('five_hour', {}).get('resets_at'))
rl_7d_ra = fmt_ts(rl.get('seven_day', {}).get('resets_at'))

print(
    f'{model}|{cwd}|{cost:.4f}|{pct}|{dur}|'
    f'{tok_in}|{tok_out}|{rl_5h_s}|{rl_7d_s}|{rl_5h_ra}|{rl_7d_ra}'
)
" 2>/dev/null)

    IFS='|' read -r MODEL DIR COST PCT DURATION_MS TOK_IN TOK_OUT \
        RL_5H RL_7D RL_5H_RA RL_7D_RA <<< "$JSON"
fi

MODEL=${MODEL:-unknown}
DIR=${DIR:-}
COST=${COST:-0.0000}
PCT=${PCT:-0}
DURATION_MS=${DURATION_MS:-0}
TOK_IN=${TOK_IN:-0}
TOK_OUT=${TOK_OUT:-0}

# Keep malformed or unexpected percentages inside the progress-bar range.
[ "$PCT" -lt 0 ] 2>/dev/null && PCT=0
[ "$PCT" -gt 100 ] 2>/dev/null && PCT=100

CYAN='\033[36m'
GREEN='\033[32m'
YELLOW='\033[33m'
RED='\033[31m'
RESET='\033[0m'

if [ "$PCT" -ge 90 ]; then
    BAR_COLOR="$RED"
elif [ "$PCT" -ge 70 ]; then
    BAR_COLOR="$YELLOW"
else
    BAR_COLOR="$GREEN"
fi

FILLED=$((PCT / 10))
EMPTY=$((10 - FILLED))
[ "$FILLED" -gt 0 ] && printf -v FILL "%${FILLED}s" || FILL=""
[ "$EMPTY" -gt 0 ] && printf -v PAD "%${EMPTY}s" || PAD=""
BAR="${FILL// /█}${PAD// /░}"

MINS=$((DURATION_MS / 60000))
SECS=$(((DURATION_MS % 60000) / 1000))

BRANCH=""
if [ -n "$DIR" ] && git -C "$DIR" rev-parse --git-dir >/dev/null 2>&1; then
    GIT_BRANCH=$(git -C "$DIR" branch --show-current 2>/dev/null)
    [ -n "$GIT_BRANCH" ] && BRANCH=" | 🌿 $GIT_BRANCH"
fi

# Since Claude Code v2.1.132, these token values describe the current context
# window from the latest API response, not cumulative session usage.
TOK_TOTAL=$((TOK_IN + TOK_OUT))
COST_FMT=$(printf '$%.4f' "$COST")

printf "%b\n" \
    "${CYAN}[$MODEL]${RESET}${BRANCH} | 🧠 ${BAR_COLOR}${BAR}${RESET} ${PCT}% | 🔢 ${TOK_TOTAL} tok | 💰 ${YELLOW}${COST_FMT}${RESET} | ⏱️ ${MINS}m ${SECS}s"

# Anthropic currently exposes rate_limits for Claude.ai Pro/Max subscribers
# after the first API response. Either window can be absent.
if [ -n "$RL_5H" ] || [ -n "$RL_7D" ]; then
    RL_LINE=""

    if [ -n "$RL_5H" ]; then
        if [ "$RL_5H" -ge 90 ]; then
            RL_5H_COLOR="$RED"
        elif [ "$RL_5H" -ge 70 ]; then
            RL_5H_COLOR="$YELLOW"
        else
            RL_5H_COLOR="$GREEN"
        fi

        RL_5H_RESET=""
        [ -n "$RL_5H_RA" ] && RL_5H_RESET=" ↺ ${RL_5H_RA}"
        RL_LINE="📊 5h: ${RL_5H_COLOR}${RL_5H}%${RESET}${RL_5H_RESET}"
    fi

    if [ -n "$RL_7D" ]; then
        if [ "$RL_7D" -ge 90 ]; then
            RL_7D_COLOR="$RED"
        elif [ "$RL_7D" -ge 70 ]; then
            RL_7D_COLOR="$YELLOW"
        else
            RL_7D_COLOR="$GREEN"
        fi

        RL_7D_RESET=""
        [ -n "$RL_7D_RA" ] && RL_7D_RESET=" ↺ ${RL_7D_RA}"
        [ -n "$RL_LINE" ] && RL_LINE="${RL_LINE} | "
        RL_LINE="${RL_LINE}7d: ${RL_7D_COLOR}${RL_7D}%${RESET}${RL_7D_RESET}"
    fi

    printf "%b\n" "Rate Limits: ${RL_LINE}"
fi

Was sollte ich bei den angezeigten Werten beachten?

Die Cost-Anzeige ist eine Schätzung. Anthropic weist ausdrücklich darauf hin, dass total_cost_usd von der Rechnung abweichen kann.

Die Rate Limits erscheinen laut aktueller Dokumentation nur bei Claude.ai Pro und Max und erst nach der ersten API-Antwort. Jedes der beiden Zeitfenster kann einzeln fehlen.

Der Context-Prozentwert wird aus den Input-Tokens berechnet. Output-Tokens fließen laut Anthropic nicht in used_percentage ein. Die danebenstehende Tokenzahl addiert Input und Output, weshalb sich beide Anzeigen nicht exakt ineinander umrechnen lassen.

Die Statusline läuft oft. Teure Befehle wie git diff oder große Repository-Scans gehören daher nicht hinein. Das Script liest nur den Branch und bleibt auch in größeren Projekten leicht.

Wie passe ich die Statusline an?

Alle sichtbaren Teile stehen in den letzten printf-Befehlen. Du kannst Emojis entfernen, Farben ändern oder weitere JSON-Felder ausgeben.

Die aktuelle Anthropic-Dokumentation führt zum Beispiel Session-Name, Claude-Code-Version, Effort-Level, Vim-Modus, Pull-Request-Status und Worktree-Daten auf. Prüfe vor einer Erweiterung, ob das Feld in deinem Tarif und deiner Claude-Code-Version vorhanden ist.

Für eine schmalere Anzeige reicht zum Beispiel:

printf "%b\n" \
    "${CYAN}[$MODEL]${RESET}${BRANCH} | ${BAR_COLOR}${BAR}${RESET} ${PCT}%"

Quellen und weiterführende Anthropic-Dokumentation

1. Customize your status line, Claude Code Docs
2. Explore the context window, Claude Code Docs
3. Best practices for Claude Code, Claude Code Docs
4. Effective context engineering for AI agents, Anthropic Engineering
5. Context windows, Claude Platform Docs

FAQ zur Claude Code Statusline

Verbraucht die Statusline zusätzliche Tokens?

Nein. Anthropic bestätigt in der Dokumentation, dass das Script lokal läuft und selbst keine API-Tokens verbraucht.

Brauche ich jq?

Nein. Das Script liest den JSON-Input mit Python. Es sucht zuerst nach python3 und verwendet bei Bedarf python.

Funktioniert das Script unter Windows?

Ja, am einfachsten in Git Bash mit installiertem Python. Für PowerShell zeigt Anthropic eigene Beispiele in der offiziellen Statusline-Dokumentation.

Warum zeigt die Statusline 0 Dollar?

Bei Claude.ai-Abos stehen direkte API-Kosten nicht immer bereit. Auch in einer neuen Session kann der Wert zunächst fehlen. Das Script setzt fehlende Kosten auf $0.0000.

Warum sehe ich keine Rate Limits?

Das Feld rate_limits wird laut Anthropic nur für Claude.ai Pro und Max nach der ersten API-Antwort geliefert. Bei API-basierten Setups oder vor der ersten Antwort bleibt die zweite Zeile leer.

Ersetzt die Statusline den Befehl /context?

Nein. Die Statusline zeigt die Auslastung kompakt. /context liefert eine Aufschlüsselung nach Kategorien und Hinweise dazu, welche Inhalte Platz belegen.

Matthias ist mit Herz, Seele und Verstand dabei. Er macht dich, dein Team und deine Firma fit für die Zukunft mit KI!

Zu Matthias Trainerprofil
Zu seinem LinkedIn Profil