Claude Code Statuszeile: Modell, Kontext, Kosten und Grenzen in einer Zeile

1. Mai 2026

• KI
• Claude Code
• Programmieren
⌇ Verbinden ↗

Die Claude Code-Statuszeile ist ein Shell-Skript, das bei jedem Tool-Aufruf und jedem Benutzerzugriff am unteren Rand Ihres Terminals angezeigt wird. Standardmäßig zeigt sie fast nichts an. Sie können sie auf ein Skript verweisen und beliebige Informationen anzeigen lassen, um Ihr aktuelles Modell, die Kontextnutzung, die Sitzungskosten und die Plan-Limits darzustellen.

Was ich während der Arbeit tatsächlich wissen musste: Wie voll ist mein Kontextfenster und wie weit bin ich in meiner Sitzung fortgeschritten? Beides ist entscheidend für die Nutzung des Tools. Eine Sitzung mit 12 % Kontext und noch 4 Stunden verbleibender Ratenbegrenzung ist eine ganz andere Situation als eine mit 78 % Kontext und nur noch 20 Minuten verbleibender Zeit. Ohne diese sichtbaren Informationen agiert man blind – man gibt Tokens für die falschen Dinge aus, stößt an Limits, die man nicht kommen sah, oder startet eine neue Sitzung, obwohl das gar nicht nötig war.

Diese Statusleiste macht all das passiv bei jedem Schritt sichtbar.

Das zeigt meine:

repo ⎇ branch/…name-here*↑2 | Opus 4.7 | ctx:█░░░░░░░░░ 12% 121k/1M | ⏱ 25m33s · $4.83 | 5h: ███░░░░░░░ 28% · 4h24m left | 7d: 47% · $513.54 · 1d12h left

Von links nach rechts:

• Projekt + Zweig — Markierung für „Dirty Tree“, Anzahl der vor- und nachgelagerten Commits
• Modell — aktueller Modellname, ohne Klammern
• Kontext — 10-Zellen-Balken + Prozentangabe + verwendete Token im Vergleich zur Fenstergröße
• Sitzung — verstrichene Zeit + Kosten in USD
• Nutzung des 5-Stunden-Tarifs — entspricht genau der von Anthropic Benutzeroberfläche , mit Zeit bis zum Zurücksetzen
• Nutzung des 7-Tage-Tarifs — dasselbe, plus fortlaufende API-äquivalente Ausgaben

Die Balken färben sich rot, wenn die letzten 10 % eines Limits erreicht sind.

Einrichtung

1. Öffne Claude Code und gib /statusline
2. Füge den Befehl am Ende dieses Beitrags ein
3. Starte Claude Code neu

Claude Code schreibt das Skript und aktualisiert ~/.claude/settings.json automatisch. Benutzer-global – dein Repo bleibt unberührt.

Voraussetzungen

• jq —brew install jq/apt install jq
• bun oder node für den 7-Tage-Dollarwert (abgerufen über bunx/npx auf Abruf abgerufen, keine globale Installation erforderlich – falls fehlend, funktioniert alles andere weiterhin)

Ein paar Anmerkungen

• Die 7-Tage-Kosten werden (usage loading…) beim ersten Durchlauf kurz angezeigt, während ccusage zwischenspeichert. Dauert etwa 10 Sekunden.
• Die Prozentsätze für 5h und 7d stammen direkt aus Claude Codes nativer Statuszeile JSON — sie stimmen bis auf den Prozentpunkt mit der Nutzungsseite von Anthropic überein.
• Außerhalb eines Git-Repos versteckt sich das Zweigsegment stillschweigend.

Die Eingabeaufforderung

Geben Sie /statusline in Claude Code ein und fügen Sie dann diesen gesamten Block ein:

Set up a global Claude Code statusline at ~/.claude (user-global, not a project's .claude/ directory).

Layout:
   ⎇ (*)(↑N)(↓N) |  | ctx: % / | ⏱  · $ | 5h:  % ·  | 7d: % · $ · 

Data sources — statusline input JSON on stdin; ccusage only for the 7-day dollar total (everything else is in the native input):
- .workspace.project_dir / .workspace.current_dir / .cwd
- .model.display_name (strip any trailing parenthetical)
- .context_window.used_percentage / .context_window.context_window_size
- .context_window.current_usage.{input,output,cache_creation_input,cache_read_input}_tokens (sum for real context token count)
- .cost.total_cost_usd / .cost.total_duration_ms
- .rate_limits.five_hour.{used_percentage,resets_at}
- .rate_limits.seven_day.{used_percentage,resets_at}
- ccusage (bunx or npx) daily total for the 7d dollar figure, cached 5 min

Behavior:
- Bars: 10 unicode cells, full (█) / empty (░) only — no partial sub-cells. Round to nearest cell; show at least 1 cell when pct > 0.
- Context bar color: green " with yellow "*" for dirty tree, green "↑N" ahead, red "↓N" behind. Skipped silently outside a repo / with no upstream configured.
- Time-left for 5h/7d computed from resets_at unix timestamp.
- 7d dollar cost: refreshed in the background when cache is >300s old, served from cache file. Fire-and-forget — never blocks the render.
- Render time should stay /dev/null 2>&1; then
  branch=$(git -C "$current_dir" symbolic-ref --short HEAD 2>/dev/null || git -C "$current_dir" rev-parse --short HEAD 2>/dev/null || true)
  if ( -n "$(git -C "$current_dir" status --porcelain 2>/dev/null | head -n 1)" ); then dirty="*"; fi
  ab=$(git -C "$current_dir" rev-list --left-right --count '@{u}...HEAD' 2>/dev/null)
  if ( -n "$ab" ); then
    behind=$(printf '%s' "$ab" | awk '{print $1}')
    ahead=$(printf '%s' "$ab" | awk '{print $2}')
  fi
fi

fmt_tokens() {
  n=$1
  if ( "$n" -ge 1000000 ); then awk -v n="$n" 'BEGIN { printf "%.1fM", n/1000000 }'
  elif ( "$n" -ge 1000 ); then awk -v n="$n" 'BEGIN { printf "%dk", n/1000 }'
  else printf '%d' "$n"
  fi
}
fmt_duration_ms() {
  total_sec=$(( $1 / 1000 ))
  h=$(( total_sec / 3600 )); m=$(( (total_sec % 3600) / 60 )); s=$(( total_sec % 60 ))
  if ( "$h" -gt 0 ); then printf '%dh%02dm' "$h" "$m"
  elif ( "$m" -gt 0 ); then printf '%dm%02ds' "$m" "$s"
  else printf '%ds' "$s"
  fi
}
fmt_time_until() {
  now=$(date +%s)
  diff=$(( $1 - now ))
  ( "$diff" -lt 0 ) && diff=0
  d=$(( diff / 86400 )); h=$(( (diff % 86400) / 3600 )); m=$(( (diff % 3600) / 60 ))
  if ( "$d" -gt 0 ); then printf '%dd%dh' "$d" "$h"
  elif ( "$h" -gt 0 ); then printf '%dh%dm' "$h" "$m"
  else printf '%dm' "$m"
  fi
}
session_len=$(fmt_duration_ms "$duration_ms")

cache_dir="${XDG_CACHE_HOME:-$HOME/.cache}/claude-statusline"
cache_file="$cache_dir/7d-cost.txt"
refresh_lock="$cache_dir/7d-cost.lock"
mkdir -p "$cache_dir" 2>/dev/null
cache_age=999999
if ( -f "$cache_file" ); then
  now=$(date +%s)
  mtime=$(stat -f %m "$cache_file" 2>/dev/null || stat -c %Y "$cache_file" 2>/dev/null || echo 0)
  cache_age=$(( now - mtime ))
fi
if ( "$cache_age" -gt 300 ); then
  if mkdir "$refresh_lock" 2>/dev/null; then
    (
      since=$(date -v-6d +%Y%m%d 2>/dev/null || date -d '6 days ago' +%Y%m%d 2>/dev/null)
      runner=""
      if command -v bunx >/dev/null 2>&1; then runner="bunx"
      elif command -v npx >/dev/null 2>&1; then runner="npx -y"
      fi
      if ( -n "$runner" ); then
        cost=$($runner ccusage daily --since "$since" --json 2>/dev/null | jq -r '(.daily().totalCost) | add // 0' 2>/dev/null)
        printf '%s\n' "${cost:-0}" > "$cache_file.tmp" && mv "$cache_file.tmp" "$cache_file"
      fi
      rmdir "$refresh_lock" 2>/dev/null
    ) >/dev/null 2>&1 &
  fi
fi
weekly_cost=""
( -f "$cache_file" ) && weekly_cost=$(cat "$cache_file" 2>/dev/null)

RESET='\033(0m'; DIM='\033(37m'; GREEN='\033(32m'; YELLOW='\033(33m'
RED='\033(31m'; CYAN='\033(36m'; MAGENTA='\033(35m'; BLUE='\033(34m'; BOLD='\033(1m'
SEP=" $(printf "${DIM}|${RESET}") "

pct_color_ctx() {
  v=$(printf '%.0f' "$1" 2>/dev/null || echo 0)
  if ( "$v" -ge 80 ); then printf '%s' "$RED"
  elif ( "$v" -ge 50 ); then printf '%s' "$YELLOW"
  else printf '%s' "$GREEN"
  fi
}
pct_color_plan() {
  v=$(printf '%.0f' "$1" 2>/dev/null || echo 0)
  if ( "$v" -ge 90 ); then printf '%s' "$RED"
  else printf '%s' "$BLUE"
  fi
}
render_bar() {
  v=$(printf '%.0f' "$1" 2>/dev/null || echo 0)
  ( "$v" -lt 0 ) && v=0; ( "$v" -gt 100 ) && v=100
  w=10
  full=$(( (v + 5) / 10 ))
  ( "$v" -gt 0 ) && ( "$full" -eq 0 ) && full=1
  empty=$(( w - full ))
  bar=""
  i=0; while ( $i -lt $full ); do bar="${bar}█"; i=$((i+1)); done
  i=0; while ( $i -lt $empty ); do bar="${bar}░"; i=$((i+1)); done
  printf '%s' "$bar"
}

line=""
( -n "$project_name" ) && line="$(printf "${BOLD}${BLUE}%s${RESET}" "$project_name")"
if ( -n "$branch" ); then
  br_piece=$(printf "${CYAN}⎇ %s${RESET}" "$branch")
  ( -n "$dirty" ) && br_piece="${br_piece}$(printf "${YELLOW}*${RESET}")"
  ( "$ahead" -gt 0 ) 2>/dev/null && br_piece="${br_piece}$(printf "${GREEN}↑%s${RESET}" "$ahead")"
  ( "$behind" -gt 0 ) 2>/dev/null && br_piece="${br_piece}$(printf "${RED}↓%s${RESET}" "$behind")"
  line="${line} ${br_piece}"
fi
( -n "$model" ) && line="${line}${SEP}$(printf "${MAGENTA}%s${RESET}" "$model")"

if ( -n "$ctx_pct" ); then
  ctx_int=$(printf '%.0f' "$ctx_pct")
  color=$(pct_color_ctx "$ctx_int")
  bar=$(render_bar "$ctx_int")
  tok_suffix=""
  if ( -n "$ctx_used" ) && ( -n "$ctx_size" ); then
    tok_suffix=$(printf " ${DIM}%s/%s${RESET}" "$(fmt_tokens "$ctx_used")" "$(fmt_tokens "$ctx_size")")
  fi
  line="${line}${SEP}ctx:$(printf "${color}%s${RESET} ${color}%s%%${RESET}%s" "$bar" "$ctx_int" "$tok_suffix")"
fi

sess_piece="$(printf "${DIM}⏱ %s${RESET}" "$session_len")"
if ( -n "$session_cost" ); then
  cost_fmt=$(printf '%.2f' "$session_cost")
  sess_piece="${sess_piece} $(printf "${DIM}· \$%s${RESET}" "$cost_fmt")"
fi
line="${line}${SEP}${sess_piece}"

if ( -n "$fh_pct" ); then
  fh_int=$(printf '%.0f' "$fh_pct")
  color=$(pct_color_plan "$fh_int")
  bar=$(render_bar "$fh_int")
  remain=""
  ( -n "$fh_reset" ) && remain=" $(printf "${DIM}·${RESET} ${YELLOW}%s left${RESET}" "$(fmt_time_until "$fh_reset")")"
  line="${line}${SEP}$(printf "${YELLOW}5h:${RESET} ${color}%s${RESET} ${color}%s%%${RESET}%s" "$bar" "$fh_int" "$remain")"
fi

if ( -n "$sd_pct" ); then
  sd_int=$(printf '%.0f' "$sd_pct")
  color=$(pct_color_plan "$sd_int")
  piece="$(printf "${YELLOW}7d:${RESET} ${color}%s%%${RESET}" "$sd_int")"
  if ( -n "$weekly_cost" ) && ( "$weekly_cost" != "0" ) && ( "$weekly_cost" != "null" ); then
    wk_fmt=$(printf '%.2f' "$weekly_cost")
    piece="${piece} $(printf "${DIM}· \$%s${RESET}" "$wk_fmt")"
  fi
  if ( -n "$sd_reset" ); then
    piece="${piece} $(printf "${DIM}·${RESET} ${YELLOW}%s left${RESET}" "$(fmt_time_until "$sd_reset")")"
  fi
  line="${line}${SEP}${piece}"
fi

printf '%b\n' "$line"

2. Merge this into ~/.claude/settings.json (preserve any existing keys):
   {
     "statusLine": {
       "type": "command",
       "command": "sh \"$HOME/.claude/statusline-command.sh\""
     }
   }

3. Requires jq. The 7-day dollar figure also needs bun or node available for ccusage via bunx/npx — no install required, auto-downloaded.

4. Restart Claude Code. The five-hour and seven-day percentages will match Anthropic's plan UI exactly. The 7d dollar appears after ccusage first runs (~10s).

Verbinden

Treffen wir uns auf der Plattform, die Ihrem gewünschten Ergebnis am besten dient. Meine digitale Identität umfasst alle Plattformabsichten. Bevorzugen Sie E-Mail? Versuchen Sie es mit contact@julianpaul.me.

Möchten Sie auf dem Laufenden bleiben? RSS ↗ und/oder abonnieren Sie E-Mail-Updates. ↓

Vernetzen Sie sich mit mir: LinkedIn | Instagram |
GitHub |
𝕏 |
Lebenslauf