What My Claude Code Status Line Tells Me

Row 1 — where am I?

~/dev/aimhuge (main) [opus] — the working directory, the git branch, and the model I'm on. Then the session's name (here, the task in flight: "Invert menu order in projects page"). One glance answers "which repo, which branch, which model, doing what."

Row 2 — how much runway?

ctx:65% — how much of the context window is left. Every percentage on this line is a burndown: it starts at 100% and counts down, green while there's room and shading to red as it runs out. When ctx gets low — around 20% on Opus's 1M-token window — a compaction is coming, so it's my cue to wrap up a thread or hand off.

tok:351.5k — total tokens used this session.

+1681/−676 — lines added and removed this session. This is the one I love: it's how much work actually landed — real code churn, not just tokens spent. And the deletions aren't waste — lines removed is often the sign of a good refactor: cutting cruft, collapsing duplication, simplifying. A session that's net-negative can be the most valuable kind.

5hr:95% reset 10pm · 7d:95% — the part I care about most: how much of my 5-hour and weekly rate-limit budget is left, and when the window resets. Green means plenty; it shades to red as I burn it down. No more surprise "you've hit your limit" mid-task.

Row 3 — what can it do without asking?

▸▸ bypass permissions on (shift+tab to cycle) — the current permission mode. Handy to keep visible so "why didn't it ask me?" is never a mystery.

How it works

Claude Code pipes a JSON blob (cwd, model, session, token and cost data) to whatever command you point statusLine at. Mine is a POSIX shell script that reads that JSON with jq and prints two ANSI-colored rows. It colors each percentage by how much budget remains — green when there's room, red when there isn't — so the line reads at a glance without me having to parse numbers.

Install it

https://aimhuge.com/blog/claude-code-status-line

Requirements: jq and git on your PATH (the script degrades gracefully without git). Three steps:

1. Save the script below to ~/.claude/statusline-command.sh (or grab it directly: statusline-command.sh).

#!/bin/sh
# Claude Code status line
# Row 1: ~/dir (branch) [model] session-name
# Row 2: ctx:N% tok:Nk +N/-N  ║  5hr:N% reset Xam · 7d:N% reset day Xpm

input=$(cat)

# --- Helpers ---
col() { printf '\033[%sm%s\033[0m' "$1" "$2"; }
grn() { col 32 "$1"; }
cyn() { col 36 "$1"; }
ylw() { col 33 "$1"; }
wht() { col 97 "$1"; }
mag() { col 35 "$1"; }
red() { col 31 "$1"; }
dim() { col 90 "$1"; }

jv() { echo "$input" | jq -r "$1"; }

# Join parts with double-space separator
row=""
add() { row="${row:+$row  }$1"; }

# Format token count as human-readable
fmt_tok() {
  if [ "$1" -ge 1000000 ]; then
    awk "BEGIN{printf \"%.1fM\",$1/1000000}"
  elif [ "$1" -ge 1000 ]; then
    awk "BEGIN{printf \"%.1fk\",$1/1000}"
  else
    echo "$1"
  fi
}

# Color a percentage by remaining budget: high=green, low=red
pct_color() {
  _remaining=$(printf '%.0f' "$1")
  if [ "$_remaining" -ge 60 ]; then
    col 32 "$2"   # green
  elif [ "$_remaining" -ge 30 ]; then
    col 33 "$2"   # yellow
  else
    col 31 "$2"   # red
  fi
}

# Format rate limit: "LABEL:N% reset TIME" — shows REMAINING, colored
fmt_limit() {
  _label="$1" _used="$2" _at="$3" _datefmt="$4"
  [ -z "$_used" ] && return
  _remaining=$(printf '%.0f' "$(awk "BEGIN{print 100-$_used}")")
  _reset=""
  [ -n "$_at" ] && _reset=$(date -r "$_at" "+$_datefmt" 2>/dev/null | tr '[:upper:]' '[:lower:]')
  _colored_pct=$(pct_color "$_remaining" "${_remaining}%")
  if [ -n "$_reset" ]; then
    printf '%s:%b %s' "$_label" "$_colored_pct" "$(dim "reset $_reset")"
  else
    printf '%s:%b' "$_label" "$_colored_pct"
  fi
}

# --- Extract ---
raw_dir=$(jv '.workspace.current_dir // .cwd // empty')
short_dir=$(echo "$raw_dir" | sed "s|^$HOME|~|")

branch=""
if [ -n "$raw_dir" ] && git -C "$raw_dir" rev-parse --git-dir >/dev/null 2>&1; then
  branch=$(git -C "$raw_dir" --no-optional-locks symbolic-ref --short HEAD 2>/dev/null \
    || git -C "$raw_dir" --no-optional-locks rev-parse --short HEAD 2>/dev/null)
fi

model_id=$(jv '.model.id // empty')
case "$model_id" in
  *opus*)   model="opus" ;;
  *sonnet*) model="sonnet" ;;
  *haiku*)  model="haiku" ;;
  *)        model=$(jv '.model.display_name // empty' | sed 's/Claude //' | tr '[:upper:]' '[:lower:]') ;;
esac

session=$(jv '.session_name // empty')
ctx=$(jv '.context_window.remaining_percentage // empty')
total_tok=$(( $(jv '.context_window.total_input_tokens // 0') + $(jv '.context_window.total_output_tokens // 0') ))
la=$(jv '.cost.total_lines_added // 0')
lr=$(jv '.cost.total_lines_removed // 0')

# --- Row 1: project context ---
row1="$(grn "$short_dir")"
[ -n "$branch" ]  && row1="$row1 $(cyn "($branch)")"
[ -n "$model" ]   && row1="$row1 $(ylw "[$model]")"
[ -n "$session" ] && row1="$row1 $(wht "$session")"

# --- Row 2: session usage  ║  rate limits ---

# Group 1: session usage
[ -n "$ctx" ]                            && add "ctx:$(pct_color "$ctx" "${ctx}%")"
[ "$total_tok" -gt 0 ]                   && add "$(cyn "tok:$(fmt_tok $total_tok)")"
[ "$la" != "0" ] || [ "$lr" != "0" ]     && add "$(grn "+$la")/$(red "-$lr")"

# Separator between groups
usage="$row"
row=""

# Group 2: rate limits (same pattern, different time windows)
# Both show REMAINING — burning down from 100% to 0%
five=$(fmt_limit "5hr" "$(jv '.rate_limits.five_hour.used_percentage // empty')" \
  "$(jv '.rate_limits.five_hour.resets_at // empty')" "%-I%p")
seven=$(fmt_limit "7d" "$(jv '.rate_limits.seven_day.used_percentage // empty')" \
  "$(jv '.rate_limits.seven_day.resets_at // empty')" "%a %-I%p")

[ -n "$five" ]  && add "$five"
[ -n "$seven" ] && add "$seven"
limits="$row"

# Combine with visual separator
row2=""
if [ -n "$usage" ] && [ -n "$limits" ]; then
  row2="$usage  $(dim "│")  $limits"
elif [ -n "$usage" ]; then
  row2="$usage"
elif [ -n "$limits" ]; then
  row2="$limits"
fi

# --- Output ---
if [ -n "$row2" ]; then
  printf '%b\n%b\n' "$row1" "$row2"
else
  printf '%b\n' "$row1"
fi

2. Make it executable:

chmod +x ~/.claude/statusline-command.sh

3. Point Claude Code at it in ~/.claude/settings.json:

// ~/.claude/settings.json
{
  "statusLine": {
    "type": "command",
    "command": "bash ~/.claude/statusline-command.sh"
  }
}

Restart Claude Code (or start a new session) and the two rows show up. It's the cockpit I didn't know I needed.