Claude Code statusline: zo doe je het, stap voor stap

Wat heb je nodig

Wat heb je nodig voor een Claude Code statusline?

De statusline (in het Nederlands de statusregel) is een functie van Claude Code zelf, dus je hoeft niets extra af te nemen. Omdat de regel uit een script op je eigen computer komt, heb je wel een paar kleine programma's nodig. Heb je Claude Code nog niet draaien, begin dan bij Claude Code installeren. Welk plan je nodig hebt, staat op de Claude-abonnementen.

jq installeren

Op macOS: brew install jq. Op Debian en Ubuntu: sudo apt-get install jq. Op Windows: winget install jqlang.jq. Open daarna een nieuwe terminal, zodat je systeem het nieuwe programma vindt. Gebruik je alleen /statusline of de PowerShell-variant, dan kun je jq overslaan.

Hoe het werkt

Hoe werkt de statusline in Claude Code?

Claude Code draait jouw script en geeft het de gegevens van de sessie mee als JSON, via stdin (de invoer die een programma binnenkrijgt). Wat je script naar stdout print, de gewone uitvoer, staat als regel onder je invoerveld. Het script draait bij het starten of hervatten van een sessie, na elk nieuw antwoord van Claude, na /compact, als je de permissiemodus wisselt en als je het commando in je settings verandert. Snelle wijzigingen worden gebundeld: Claude Code wacht 300 milliseconden en draait het script dan één keer. De statusregel draait lokaal en kost geen tokens.

Wat er niet in de JSON staat

De git-branch en het aantal gewijzigde bestanden krijgt je script niet mee. Wil je die zien, dan vraagt je script ze zelf aan git, zoals in het eerste script hieronder. Dat kost bij elke update een fractie van een seconde, en in een grote repository merk je dat. Alleen in een worktree-sessie staat de branch wel in de JSON, onder worktree.branch.

Statusline, /status, /usage en /context: het verschil

De statusline is een regel die altijd zichtbaar is, met wat jij kiest. /status opent het tabblad Status in de instellingen, met je versie, model, account en verbinding: handig om één keer te controleren, niet om bij te houden. /usage (ook bereikbaar als /cost en /stats) toont je sessiekosten, je planlimieten en activiteit. /context laat in een kleurenraster zien wat je contextvenster vult, met tips om ruimte te maken. Hoe je /usage en /status gebruikt als je tegen een limiet loopt, lees je bij Claude Code limiet bereikt. En de pagina Claude status gaat over storingen bij Anthropic; die heeft niets met deze statusregel te maken.

Waar je de statusline instelt

~/.claude/settings.json geldt voor al je projecten, alleen op jouw computer; de tilde staat voor je gebruikersmap. Daar hoort een statusregel bijna altijd, want het is een persoonlijke voorkeur. Je kunt hem ook in .claude/settings.json van een project zetten. Die waarde wint dan van je persoonlijke, en elke collega die het project opent, draait jouw script. Doe dat alleen als het team dat bewust wil.

Snelste route: /statusline

De snelste route: /statusline laat Claude Code het script schrijven

Wil je vooral snel iets zien, laat Claude Code het werk dan doen. Het commando /statusline neemt een beschrijving in gewone taal, schrijft een script in ~/.claude/ en past je settings aan.

/statusline zonder beschrijving

Typ je alleen /statusline, dan maakt Claude Code een statusregel op basis van je shellprompt, de regel die je terminal toont voor elk commando. Handig als je prompt al laat zien wat je belangrijk vindt.

Weer uitzetten

Typ /statusline delete of /statusline remove it. Je kunt ook zelf het blok "statusLine" uit ~/.claude/settings.json halen. Het script blijft dan staan, maar Claude Code draait het niet meer.

Script 1: model, map, branch

Je eigen Claude Code statusline-script: model, map en git-branch

Zelf een script maken kost een kwartier en je weet daarna precies wat er draait. Dit eerste script toont het model, de naam van de map en de git-branch. Het werkt op macOS, Linux en op Windows met Git Bash.

Het script: ~/.claude/statusline.sh

#!/bin/bash
# Statusregel 1: model, map en git-branch
input=$(cat)
MODEL=$(echo "$input" | jq -r '.model.display_name')
DIR=$(echo "$input" | jq -r '.workspace.current_dir')
BRANCH=$(git -C "$DIR" branch --show-current 2>/dev/null)

if [ -n "$BRANCH" ]; then
  echo "[$MODEL] ${DIR##*/} | branch: $BRANCH"
else
  echo "[$MODEL] ${DIR##*/}"
fi

De configuratie in ~/.claude/settings.json

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

Wat het script doet

input=$(cat) leest de JSON die Claude Code meegeeft. jq -r haalt er één veld uit als gewone tekst. De constructie met twee hekjes achter DIR houdt alleen het laatste deel van het pad over, dus de mapnaam. git -C vraagt de branch op in de map waar Claude werkt, en 2>/dev/null zorgt dat je buiten een git-repository geen foutmelding krijgt maar gewoon een regel zonder branch. In de configuratie betekent "type": "command" dat Claude Code een shellcommando draait; "padding": 1 geeft één teken extra ruimte aan de linkerkant.

Twee nuttige opties

"refreshInterval": 5 draait je script ook elke vijf seconden, ook als er niets gebeurt. Dat heb je nodig voor een klok, of als subagents op de achtergrond de git-status veranderen terwijl jij wacht. Het minimum is 1. Laat de optie weg als je regel alleen na een antwoord hoeft te veranderen. Wil je je regel aanpassen aan de breedte van je venster, lees dan $COLUMNS uit; tput cols werkt in een statusline-script niet, omdat Claude Code de uitvoer opvangt.

Script 2 en 3: context en limieten

Claude Code statusline met contextgebruik, limieten en kosten

Model en map zijn handig, maar de meeste mensen willen vooral weten hoe vol de context zit en hoeveel van hun limiet nog over is. Vervang daarvoor de inhoud van ~/.claude/statusline.sh door een van de twee scripts hieronder. Je settings hoef je niet aan te passen; de wijziging verschijnt bij het volgende antwoord.

Script 2: contextgebruik als gekleurde balk

#!/bin/bash
# Statusregel 2: contextgebruik als gekleurde balk
input=$(cat)
MODEL=$(echo "$input" | jq -r '.model.display_name')
PCT=$(echo "$input" | jq -r '.context_window.used_percentage // 0' | cut -d. -f1)
[ "$PCT" -gt 100 ] && PCT=100

GROEN='\033[32m'; GEEL='\033[33m'; ROOD='\033[31m'; RESET='\033[0m'
if [ "$PCT" -ge 80 ]; then KLEUR=$ROOD
elif [ "$PCT" -ge 60 ]; then KLEUR=$GEEL
else KLEUR=$GROEN; fi

GEVULD=$((PCT / 10)); LEEG=$((10 - GEVULD))
BALK=""
for ((i = 0; i < GEVULD; i++)); do BALK="${BALK}█"; done
for ((i = 0; i < LEEG; i++)); do BALK="${BALK}░"; done

printf '%b\n' "[$MODEL] ${KLEUR}${BALK}${RESET} ${PCT}% context"

Wat script 2 doet

Met 67 procent context zie je [Opus] ██████░░░░ 67% context, met een gele balk. // 0 zet een leeg veld om in 0, want aan het begin van een sessie is het percentage nog leeg. cut -d. -f1 knipt de decimalen eraf, omdat Bash alleen met hele getallen rekent. De codes zoals \033[32m zijn ANSI-kleurcodes: 32 is groen, 33 geel, 31 rood, 0 zet de kleur terug. printf '%b' zorgt dat die codes als kleur verschijnen en niet als tekst. De grenzen 60 en 80 procent zijn onze keuze: geel is het seintje om na deze taak /compact te doen of een nieuwe sessie te starten, rood betekent dat nu doen. Pas ze aan op hoe jij werkt.

Script 3: limieten op een abonnement, kosten met een API-key

#!/bin/bash
# Statusregel 3: planlimieten (abonnement) of geschatte kosten (API)
input=$(cat)
export LC_ALL=C  # punt als decimaalteken, ook op een Nederlands ingestelde computer
MODEL=$(echo "$input" | jq -r '.model.display_name')
VIJF_UUR=$(echo "$input" | jq -r '.rate_limits.five_hour.used_percentage // empty')
WEEK=$(echo "$input" | jq -r '.rate_limits.seven_day.used_percentage // empty')
KOSTEN=$(echo "$input" | jq -r '.cost.total_cost_usd // 0')
DUUR_MS=$(echo "$input" | jq -r '.cost.total_duration_ms // 0')

REGEL="[$MODEL] $((DUUR_MS / 60000)) min"
if [ -n "$VIJF_UUR" ]; then
  REGEL="$REGEL | 5 uur: $(printf '%.0f' "$VIJF_UUR")%"
  [ -n "$WEEK" ] && REGEL="$REGEL | week: $(printf '%.0f' "$WEEK")%"
else
  REGEL="$REGEL | ca. \$$(printf '%.2f' "$KOSTEN")"
fi
echo "$REGEL"

Wat script 3 doet

Op Pro of Max zie je bijvoorbeeld [Opus] 30 min | 5 uur: 24% | week: 41%. Werk je met een API-key, dan ontbreken die limietvelden en toont het script de geschatte kosten, zoals [Sonnet] 2 min | ca. $1.57. // empty geeft niets terug als een veld ontbreekt, zodat het script zelf kan kiezen wat het laat zien. Op Team en Enterprise krijg je de limietvelden niet mee, en dan zie je het dollarbedrag; lees bij Ons oordeel waarom je dat niet als je rekening moet lezen.

Waarom die regel met LC_ALL=C erin staat

Dit is een valkuil die je in Engelstalige voorbeelden niet tegenkomt. Staat je computer op Nederlandse getalnotatie, dan verwacht printf een komma als decimaalteken. Het bedrag 1.5678 uit de JSON geeft dan de melding printf: 1.5678: invalid number, en je regel toont $0,00. We hebben dat getest op een Mac met Nederlandse instellingen. export LC_ALL=C zet het script op de neutrale notatie met een punt, en dan klopt het bedrag weer. Gebruik deze regel niet in script 2: dan worden de blokjes van de balk onleesbaar.

Twee regels tegelijk

Elke echo in je script wordt een eigen regel. Wil je script 1 en script 3 combineren, laat het script dan twee keer echo doen: eerst model, map en branch, daarna de limieten. Houd het wel kort. Op een smal venster kapt Claude Code de regel af, en meldingen zoals een MCP-fout delen de rij met je statusregel.

Windows

Claude Code statusline op Windows: PowerShell of Git Bash

Op Windows draait Claude Code je statusline-commando via Git Bash als dat geïnstalleerd is, en anders via PowerShell. Met Git Bash werken de scripts hierboven zoals ze er staan. Zonder Git Bash gebruik je het PowerShell-script hieronder, dat model, map, branch en contextgebruik toont.

Het script: statusline.ps1

# Statusregel voor Windows: map, model en contextgebruik
$data = $input | Out-String | ConvertFrom-Json
$model = $data.model.display_name
$map = Split-Path $data.workspace.current_dir -Leaf
$pct = [math]::Floor([double]$data.context_window.used_percentage)
$branch = git -C $data.workspace.current_dir branch --show-current 2>$null

$regel = "[$model] $map"
if ($branch) { $regel += " | branch: $branch" }
$regel += " | $pct% context"
Write-Output $regel

De configuratie voor Windows

{
  "statusLine": {
    "type": "command",
    "command": "powershell -NoProfile -ExecutionPolicy Bypass -File C:/Users/jouwnaam/.claude/statusline.ps1"
  }
}

Waarom -ExecutionPolicy Bypass

Het officiële voorbeeld van Anthropic heeft deze toevoeging niet. Wij zetten hem erbij, omdat Windows op een pc waar niemand iets heeft ingesteld het uitvoeren van PowerShell-scripts blokkeert. De optie geldt alleen voor dit ene proces en verandert niets aan de instellingen van je computer. Op een bedrijfslaptop kan IT scripts via Group Policy blokkeren; die regel gaat altijd voor. Werkt het daardoor niet, gebruik dan de route via Git Bash of vraag je beheerder.

Liever Git Bash?

Installeer Git for Windows en jq (winget install jqlang.jq). Zet het Bash-script in C:\Users\jouwnaam\.claude\statusline.sh en gebruik als commando ~/.claude/statusline.sh; de tilde werkt ook op Windows en wijst naar je gebruikersmap. Dan kun je dezelfde scripts gebruiken als je collega's op een Mac.

Werkt het?

Werkt het? Zo test je je Claude Code statusline

Een statusline-script dat faalt, toont niets. Claude Code geeft dan geen foutmelding; de regel blijft gewoon leeg. Test daarom eerst los, en laat Claude daarna meekijken.

De controle: test met nep-JSON

Draai in je terminal:

echo '{"model":{"display_name":"Opus"},"workspace":{"current_dir":"/tmp/test"},"context_window":{"used_percentage":72},"cost":{"total_cost_usd":0.5,"total_duration_ms":600000}}' | ~/.claude/statusline.sh; echo "exitcode: $?"

Je ziet één nette regel en daarna exitcode: 0. Claude Code toont de uitvoer alleen als het script met exitcode 0 eindigt. Doe daarna in Claude Code de echte test: stuur een bericht en kijk of de regel klopt met je map en model. Wissel met /model van model; na het volgende antwoord hoort de naam in je regel mee te veranderen.

De eerste prompt om te plakken

Lees ~/.claude/settings.json en het script waar "statusLine" naar wijst.
1. Voer het script uit met deze test-JSON en laat de uitvoer en de exitcode zien: {"model":{"display_name":"Opus"},"workspace":{"current_dir":"/tmp/test"},"context_window":{"used_percentage":72}}
2. Doe hetzelfde met een JSON zonder context_window: {"model":{"display_name":"Opus"},"workspace":{"current_dir":"/tmp/test"}}
3. Meet hoe lang één run duurt, en zeg of dat in een grote repository een probleem wordt.
4. Pas nog niets aan. Stel alleen verbeteringen voor, met de reden erbij.

Waarom deze prompt werkt

Stap 2 vangt de fout die je in het begin van elke sessie raakt: velden die nog leeg zijn. Een script dat daarop crasht, laat je statusregel leeg tot het eerste antwoord, of langer. Stap 3 gaat over snelheid: je script draait na elk antwoord, en een trage git-opdracht maakt je regel achterlopend. Stap 4 houdt jou aan het stuur. Je leest eerst, daarna pas past Claude iets aan.

Problemen

Claude Code statusline werkt niet? Meldingen en oplossingen

Zoek je symptoom in de eerste kolom. Kom je er niet uit, start Claude Code dan met claude --debug. Dan logt Claude Code bij elke update wat je script naar stderr schrijft, en bij de eerste run ook de exitcode.

Ons oordeel

Ons oordeel: wanneer een Claude Code statusline de moeite waard is

In onze trainingen zien we dat een statusregel vooral helpt bij twee dingen die beginners niet zien aankomen: een context die volloopt, en een limiet die midden in een klus op is. Voor die twee is een halfuur instellen snel terugverdiend. Voor de rest is het vooral prettig.

Wanneer wel

Je werkt dagelijks met Claude Code, in meerdere projecten of sessies tegelijk, en je wilt in één oogopslag zien waar je zit. Je zit op Pro of Max en loopt weleens tegen je 5-uurslimiet aan; met het percentage in beeld plan je een grote klus vóór je limiet in plaats van erdoorheen. Of je laat Claude lange taken doen en wilt zien wanneer de context zo vol raakt dat je beter een nieuwe sessie start.

Wanneer niet, of nog niet

Je gebruikt Claude Code een paar keer per week voor korte vragen. Dan is /usage af en toe genoeg. Werk je vooral in de VS Code-extensie of de desktop-app, dan heb je er minder aan: de documentatie beschrijft de statusregel voor Claude Code in de terminal. Leer als beginner eerst plan mode en een goede CLAUDE.md; die leveren meer op dan een mooie regel onderaan.

De fout die we het vaakst zien: het dollarbedrag lezen als je rekening

Wie de kosten in zijn statusregel zet, schrikt soms van een bedrag van een paar dollar na een middag werken. Op Pro en Max betaal je dat niet: je abonnement dekt je gebruik, en Anthropic schrijft zelf dat het sessiebedrag voor abonnees niet relevant is voor de rekening. Het bedrag is een schatting tegen catalogusprijs, in dollars, en begint na /clear weer bij nul. Op Pro en Max zet je dus beter je 5-uurs- en weekpercentage in de regel, zoals script 3 doet. Alleen met een API-key zegt het bedrag iets over wat je betaalt, en ook dan is de Usage-pagina in de Console leidend. Hoe abonnement en API zich verhouden, lees je bij de kosten van Claude Code.

Kant-en-klare statuslines van anderen

De documentatie noemt twee communityprojecten: ccstatusline en starship-claude. ccstatusline heeft op 29 oktober 2026 ruim 13.400 sterren op GitHub, valt onder de MIT-licentie en start met npx -y ccstatusline@latest, waarna je in een menu kiest wat je wilt zien. Let op twee dingen. Met @latest haalt Claude Code bij elke update de nieuwste versie van npm op en draait die met jouw rechten; de makers raden zelf een vastgezette installatie aan, die je in het menu kiest. En lees wat je installeert, net als bij plugins. Voor de meeste mensen is een eigen script van tien regels genoeg, en dat begrijp je tenminste.

Privacy, de AVG en gedeelde repositories

De statusregel draait lokaal en stuurt zelf niets naar buiten. Dat verandert als je script een externe dienst aanroept, bijvoorbeeld om je verbruik naar een dashboard te sturen: de JSON bevat je mapnamen, je sessie-id en het pad naar het transcript van je gesprek. Behandel zo'n dienst als elke andere verwerker. Pas ook op met een statusLine in .claude/settings.json van een repository die je kloont: dat is een shellcommando dat bij elke update draait. Claude Code draait het pas nadat je de map vertrouwt, dus lees het voordat je ja zegt. Meer over de dataroutes lees je in Claude Code en privacy.

Een voorbeeld uit het MKB

Neem een marketingbureau van acht mensen waar twee collega's met Claude Code landingspagina's en kleine scripts bouwen, allebei op een Max-abonnement. Een werkbare start: iedereen zet script 3 in zijn eigen ~/.claude/settings.json, aangevuld met de mapnaam, zodat zichtbaar is in welk klantproject je zit. Zet de statusregel niet in de repository; de een werkt op een Mac, de ander op Windows, en een gedeeld script zou bij een van beiden falen. Spreek wel af wat je doet bij een vol contextvenster of een hoog limietpercentage, bijvoorbeeld: boven 80 procent context eerst de taak afronden en dan een nieuwe sessie starten.

Wat nu?

Wat doe je na je eerste Claude Code statusline?

Staat je statusregel, dan zijn dit de logische vervolgstappen. Kies er één, niet alles tegelijk.

Je verbruik en je limieten begrijpen

Je ziet nu je percentages, maar wat betekenen ze? Lees Claude Code limiet bereikt voor de 5-uurs- en weekvensters, en de kosten van Claude Code voor abonnement tegenover API. Wat een contextvenster en rate limits zijn, staat in het woordenboek.

Meer automatiseren in Claude Code

De statusregel is familie van hooks: allebei een commando dat Claude Code op een vast moment draait, met dezelfde regels voor vertrouwde mappen. Wil je een melding als Claude op je wacht of een formatter na elke bewerking, volg dan Claude Code hooks. Laat je Claude met subagents werken, dan helpt Claude Code subagents; voor de rij per subagent onder je prompt bestaat een aparte instelling, subagentStatusLine.

Alle commando's op een rij

/statusline, /usage, /status, /context en de rest vind je in Claude Code commands. Werk je in VS Code, lees dan Claude Code in VS Code.

Verder lezen

Hoe je Claude Code in het algemeen goed inzet, lees je in Claude Code gebruiken. Wil je met je team afspraken maken over context, limieten en instellingen, dan behandelen we dat in de Claude Code Masterclass.