Build This Now
Build This Now
TastenkürzelStatus Line Guide
Claude Code VS Code ExtensionClaude Code vs Cursor in 2026Cursor vs CopilotOpenClaw vs Claude CodeOpenCode vs Claude CodeGemini CLI vs Claude CodeKI-SEO und GEO-Optimierungvs GitHub Copilot7 beste Claude Code Alternativen 2026Claude Code vs Aider 2026Claude Code vs Cline 2026Claude Code vs Devin 2026Beste KI-Coding-Tools für Solo-Gründer 2026Claude Code vs Kirovs Ampvs Augment Codevs Zedvs Roo Codevs WarpBest AI SaaS StackBolt, Lovable, v0Claude Code BoilerplateClaude Code Starter Kitvs Antigravityvs CodexCursor vs Codexvs JunieShipFast vs Makerkitvs v0Cursor vs Windsurfvs Grok BuildHeadroom CompressionClaude Code KeybindingsLovable for FoundersSpaceX Buys CursorClaude Code Status-Zeile einrichtenvs Windsurfvs Lovablevs Bolt
Skills, Subagents, HooksSubagent Sweet SpotCLAUDE.md Best PracticesFix Context Limit
speedy_devvkoen_salo
Blog/Toolkit/Extensions/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.

Sehen Sie, was wir für Unternehmen bauen →
speedy_devvWritten by speedy_devvPublished 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.
  • Beste KI-Coding-Tools für Solo-Gründer 2026
    Die besten KI-Coding-Tools für Solo-Gründer 2026, gereiht danach, was wirklich ein Produkt ausliefert: Claude Code, Cursor, Cline, Aider und ein vorgebautes SaaS-Kit. Ehrliche Empfehlungen für nicht-technische und technische Gründer.
  • 7 beste Claude Code Alternativen 2026
    Die besten Claude Code Alternativen 2026: Cursor, Windsurf, Cline, Aider, GitHub Copilot, Devin und Gemini CLI. Ehrlicher Vergleich von Preis, Autonomie und wofür jede passt.
  • The Best Stack for an AI SaaS in 2026 (Next.js, Supabase, Stripe, RLS)
    The best stack for an AI SaaS in 2026: Next.js 16, Supabase, Stripe, Vercel, with pgvector and RLS. Free until you have revenue.
  • Bolt vs Lovable vs v0: Which AI App Builder to Ship With?
    Bolt vs Lovable vs v0 compared: v0 wins on UI, Lovable on fastest full-stack MVP, Bolt on code control and mobile. Plus the honest production caveat.
  • Claude Code Boilerplate vs the Code Kit: Harness, Not Template
    A Claude Code boilerplate is starter code you babysit. A harness tells Claude how to build. Here is the difference and why it changes output quality.

More from Toolkit

  • CLAUDE.md, Skills, Subagents, Hooks: When to Use Which
    Claude Code skills vs subagents vs hooks vs CLAUDE.md: a plain mental model for picking the right primitive, with token costs and examples.
  • Claude Code Subagents: The 3 to 5 Agent Sweet Spot
    Claude code subagents work best at 3-5 concurrent agents. Here is why that ceiling exists, how to set them up, and what to use past it.
  • CLAUDE.md Best Practices: The File That Makes Claude Code Reliable
    CLAUDE.md best practices: keep it under 200 lines, write it by hand, and use hooks when you need real enforcement, not advice.
  • How to Fix Claude Code Running Out of Context
    Claude Code running out of context is a session design problem. Fix it with /compact, lean CLAUDE.md, skills, and subagents, not a bigger window.

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

SaaS-Builder-Vorlagen mit KI-Orchestrierung.

Sehen Sie, was wir für Unternehmen bauen →

SpaceX Buys Cursor

SpaceX's $60B Cursor acquisition ends model-neutral coding. Here is the lock-in risk and how to own your code.

vs Windsurf

Both cost $20/month now. The difference is what they do: Claude Code runs autonomous sessions in your terminal. Windsurf gives you inline completions in an IDE.

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.

Sehen Sie, was wir für Unternehmen bauen →