Build This Now
Build This Now
Atalhos de TecladoGuia da Status Line
Extensão Claude Code para VS CodeClaude Code vs Cursor em 2026Cursor vs CopilotOpenClaw vs Claude CodeOpenCode vs Claude CodeGemini CLI vs Claude CodeOtimização de SEO e GEO com IAvs GitHub Copilot7 Melhores Alternativas ao Claude Code em 2026Claude Code vs Aider em 2026Claude Code vs Cline em 2026Claude Code vs Devin em 2026Melhores Ferramentas de IA para Programar para Fundadores Solo em 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 CompressionKeybindings do Claude CodeLovable for FoundersSpaceX Buys CursorConfiguração da Linha de Status do Claude Codevs Windsurfvs Lovablevs Bolt
Skills, Subagents, HooksSubagent Sweet SpotCLAUDE.md Best PracticesFix Context Limit
speedy_devvkoen_salo
Blog/Toolkit/Extensions/Status Line Setup

Configuração da Linha de Status do Claude Code

Configure uma linha de status para o Claude Code com modelo, branch do git, custo da sessão e uso do contexto. Config no settings.json, contrato JSON de entrada, scripts em bash, Python e Node.

Pare de configurar. Comece a construir.

Templates SaaS com orquestração de IA.

Veja o que construímos para empresas →
speedy_devvWritten by speedy_devvPublished Feb 24, 2026Toolkit hubExtensions index

Problema: O terminal do Claude Code deixa muita informação útil fora do ecrã. Uma linha de status personalizada mostra o nome do modelo, o branch do git, o custo acumulado da sessão e o uso do contexto mesmo abaixo da interface de chat.

Pensa nisto como o PS1 do Claude Code. Se já alguma vez ajustaste um prompt do shell com Oh-my-zsh ou Starship, a ideia é exatamente a mesma. Uma linha de informação ao vivo que te mantém orientado enquanto trabalhas.

O Que a Linha de Status Mostra

A linha de status fica na parte inferior da interface do Claude Code e atualiza sempre que a conversa muda. O que o teu script imprimir é o que aparece: o modelo atual, o branch ativo do git, quanto a sessão custou até agora, ou quão preenchida está a janela de contexto.

Aqui está um exemplo configurado:

[Opus] my-project | main | $0.42 | Context: 37%

Uma linha. Modelo, pasta do projeto, branch do git, custo acumulado da sessão e a percentagem da janela de contexto em uso. Todos os campos atualizam sozinhos.

Configuração Rápida com /statusline

O comando /statusline está integrado diretamente na CLI. Escreve-o dentro do Claude Code e ele gera um script para ti.

/statusline

O comportamento padrão cria um script de linha de status que replica o teu prompt do terminal. Também podes passar um pedido específico:

/statusline show the model name in orange

/statusline display git branch and session cost

/statusline show context window percentage with color coding

É tudo. O Claude Code escreve o script, configura o settings, e a linha de status aparece. Para controlo total, segue a rota manual abaixo.

Configuração Manual via settings.json

Para configurar à mão, adiciona uma entrada statusLine ao .claude/settings.json do teu projeto (ou ao ~/.claude/settings.json global, se quiseres em todos os projetos):

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

Três campos a conhecer:

  • type: Sempre "command" para linhas de status baseadas em script
  • command: Caminho para o script que gera o output da linha de status
  • padding: Número de linhas vazias acima da linha de status (0 é o típico)

Com essa entrada no lugar, cria o ficheiro de script e marca-o como executável:

touch ~/.claude/statusline.sh
chmod +x ~/.claude/statusline.sh

O passo chmod +x é importante. Se a linha de status nunca aparecer, uma permissão de execução em falta é quase sempre a causa.

Como Funciona o Motor da Linha de Status

Conhecer a mecânica compensa no momento em que depuras ou personalias um script:

  • Gatilho de atualização: A linha de status atualiza sempre que as mensagens da conversa mudam
  • Throttle: As atualizações correm no máximo a cada 300ms para evitar problemas de desempenho
  • Tratamento do output: Apenas a primeira linha do stdout do teu script aparece como texto da linha de status
  • Cores: Suporte total a códigos de cor ANSI para estilização
  • Input: O Claude Code passa um objeto JSON com dados da sessão para o teu script via stdin

Esse último ponto é a chave. O teu script recebe um payload JSON estruturado no stdin com o modelo atual, caminhos do workspace, custo da sessão, estatísticas da janela de contexto, e mais. Faz o parse, formata e imprime uma linha para o stdout.

O JSON que o Teu Script Recebe

Em cada atualização da linha de status, o teu script recebe esta estrutura JSON no 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
    }
  }
}

Os campos que fazem o trabalho real numa linha de status prática:

  • model.display_name: Nome curto do modelo, como "Opus" ou "Sonnet"
  • workspace.current_dir: Onde estás a trabalhar agora
  • cost.total_cost_usd: Custo acumulado da sessão em dólares
  • cost.total_lines_added / total_lines_removed: Acompanha alterações no código
  • context_window.used_percentage: Uso do contexto pré-calculado (0-100)
  • context_window.context_window_size: Capacidade total da janela de contexto

Scripts de Linha de Status Prontos a Usar

Abaixo estão scripts completos e funcionais em várias linguagens. Pega no que encaixar no teu setup.

Linha de Status Simples em Bash

A linha de status mais pequena que vale a pena usar. Nome do modelo mais diretório atual:

#!/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##*/}"

Output: [Opus] my-project

Por trás dos panos, este script usa jq para o parsing de JSON. Se jq não estiver instalado, corre brew install jq no macOS ou sudo apt install jq no Ubuntu.

Linha de Status com Suporte a Git

A informação do branch junta-se à linha, o que ajuda quando estás a gerir vários branches de funcionalidades:

#!/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"

Output: [Opus] my-project | feature/auth

Linha de Status Completa em Bash

Modelo, branch do git, custo da sessão e percentagem de contexto, tudo numa linha:

#!/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}%"

Output: [Opus] my-project | main | $0.42 | Ctx: 37%

Bash com Cores ANSI

O código de cores torna a linha escaneável num relance:

#!/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}"

Abaixo de 50%, a percentagem de contexto fica verde. Entre 50-80%, amarelo. Acima de 80%, vermelho. Um sinal visual rápido de que está na hora de gerir a janela de contexto.

Abordagem com Funções Auxiliares para Scripts Complexos

Quando um script de linha de status cresce, funções auxiliares mantêm-no legível:

#!/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"

Output: [Opus] my-project | $0.42 | Ctx:37% | +156/-23

O +156/-23 no fim acompanha linhas adicionadas e removidas na sessão. Uma leitura rápida de quanto código mudou de facto.

Linha de Status em Python

Para quem prefere Python em vez de 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}%")

Linha de Status em Node.js

Para quem trabalha com JavaScript:

#!/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}%`,
  );
});

Monitorizar o Uso da Janela de Contexto

Ter os olhos postos na janela de contexto é uma das razões mais práticas para usar uma linha de status. Quando fica cheia, o Claude Code compacta a conversa e os detalhes perdem-se. Ver onde estás ajuda-te a decidir quando recomeçar ou compactar nos teus próprios termos.

Abordagem simples usando a percentagem pré-calculada:

#!/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}%"

Abordagem avançada com cálculo manual a partir dos contadores de tokens em bruto:

#!/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

A versão avançada expõe os números de tokens em bruto ao lado da percentagem. Útil quando queres saber o orçamento exato de tokens restantes, especialmente ao escolher entre modelos com diferentes tamanhos de contexto.

Monitorizar o Custo da Sessão

cost.total_cost_usd atualiza em tempo real. Mostrá-lo na linha de status mantém os gastos visíveis sem ir ao dashboard:

#!/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}"

Para quem tem orçamento ou acompanha custo por funcionalidade, essa visibilidade compensa logo. Combina com estratégias de seleção de modelo e trocas de modelo assim que uma tarefa fica abaixo do nível de exigência do Opus.

Resolução de Problemas

A linha de status não aparece de todo

Uma permissão de execução em falta no ficheiro de script é o culpado habitual. Corrige com:

chmod +x ~/.claude/statusline.sh

O script corre mas o output fica vazio

O teu script pode estar a escrever para stderr em vez de stdout. Apenas a primeira linha do stdout chega à linha de status. Adiciona um echo "test" rápido para confirmar o output, depois constrói a partir daí.

Testar o script manualmente

Podes testar sem lançar o Claude Code passando JSON simulado diretamente para o script:

echo '{"model":{"display_name":"Test"},"workspace":{"current_dir":"/test"},"cost":{"total_cost_usd":0.5},"context_window":{"used_percentage":25}}' | ~/.claude/statusline.sh

Se isso imprimir a linha esperada, o script está bem. Se não sair nada, o problema está no parsing.

jq não encontrado

Instala pelo teu gestor de pacotes:

# macOS
brew install jq
 
# Ubuntu/Debian
sudo apt install jq
 
# Windows (via scoop)
scoop install jq

Ideias Criativas para a Linha de Status

Quando o básico funciona, algumas ideias para ir mais longe com a linha de status:

  • Rastreador de linhas alteradas: Imprime +adicionadas/-removidas para acompanhar a produtividade da sessão
  • Duração da sessão: Deriva o tempo decorrido a partir de total_duration_ms
  • Exibição do ID do modelo: Mostra o identificador completo do modelo ao testar diferentes configurações
  • Diretório do projeto vs. atual: Mostra ambos quando o Claude Code entra em subdiretórios
  • Custo por minuto: Divide total_cost_usd por total_duration_ms e vê o ritmo de gasto real
  • Barra de janela de contexto: Troca a percentagem por uma barra visual como [========--]
  • Avisos condicionais: Muda cores quando o contexto passa 80% ou o custo ultrapassa um limite

A linha de status corre qualquer script que lhe deres. Bash, Python, Node.js, tudo o que conseguires escrever aparece no ecrã.

O Que Experimentar a Seguir

A tua linha de status está ativa. Próximos passos naturais:

  • Gerir o contexto de forma proativa: Usa a percentagem de contexto ao lado de estratégias de gestão de buffer de contexto
  • Configurar o ambiente de terminal: Aprende técnicas de controlo do terminal para um workspace completo do Claude Code
  • Configurar definições do projeto: Define as bases da configuração para que cada sessão comece com o contexto certo

Continue in Extensions

  • Otimização de SEO e GEO com IA
    Um resumo sobre Generative Engine Optimization: como fazer com que o teu conteúdo seja citado dentro das respostas do ChatGPT, Claude e Perplexity, em vez de apenas aparecer no Google.
  • Melhores Ferramentas de IA para Programar para Fundadores Solo em 2026
    As melhores ferramentas de IA para programar para fundadores solo em 2026, ordenadas pelo que realmente lança um produto: Claude Code, Cursor, Cline, Aider e um kit de SaaS pré-construído. Escolhas honestas para fundadores técnicos e não técnicos.
  • 7 Melhores Alternativas ao Claude Code em 2026
    As melhores alternativas ao Claude Code em 2026: Cursor, Windsurf, Cline, Aider, GitHub Copilot, Devin e Gemini CLI. Comparação honesta de preço, autonomia e a quem cada uma serve.
  • 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.

Pare de configurar. Comece a construir.

Templates SaaS com orquestração de IA.

Veja o que construímos para empresas →

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

O Que a Linha de Status Mostra
Configuração Rápida com /statusline
Configuração Manual via settings.json
Como Funciona o Motor da Linha de Status
O JSON que o Teu Script Recebe
Scripts de Linha de Status Prontos a Usar
Linha de Status Simples em Bash
Linha de Status com Suporte a Git
Linha de Status Completa em Bash
Bash com Cores ANSI
Abordagem com Funções Auxiliares para Scripts Complexos
Linha de Status em Python
Linha de Status em Node.js
Monitorizar o Uso da Janela de Contexto
Monitorizar o Custo da Sessão
Resolução de Problemas
Ideias Criativas para a Linha de Status
O Que Experimentar a Seguir

Pare de configurar. Comece a construir.

Templates SaaS com orquestração de IA.

Veja o que construímos para empresas →