Show HN: I Put My Claude Code Rate-Limit Burndown in the Status Line

Claude Code · June 2026

What My Claude Code Status Line Tells Me

Claude Code lets you replace the status line with any command you like. Mine packs the four things I actually glance at into two rows — so I always know how much runway I have before something runs out.

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

The easy way: let Claude Code do it

Paste this page's URL into Claude Code and say "install this status line for me":

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

Claude will read the steps below and set everything up. The rest of this section is written so it (or you) can follow along.

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

1. Make it executable:

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

1. 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.

← Back to the blog

Stay in the loop

Drop your email or WhatsApp to get notified when I'm in your city, drop a new video, or release new tools.