Meu Setup do Claude Code

Neste post irei falar sobre os seguintes tópicos:

1. Status line — o script que uso para customizar a barra de status do Claude.
2. settings.json — modelo, permissões e ajustes de segurança.
3. Plugins — quais uso no dia a dia e para que serve cada um.
4. RTK — um proxy que comprime a saída dos comandos antes dela chegar ao contexto.

1 A Status Line (barra de status)

A barra que uso fica da seguinte forma:

Ela mostra, da esquerda para a direita:

O Claude Code permite uma status line do tipo command: ele executa um script a cada atualização e envia um JSON via stdin com o estado da sessão (diretório, modelo, uso de contexto, etc.). O script imprime a linha já formatada (com cores ANSI).

1.1 Passo a passo para configurar do zero

Siga na ordem:

Passo 1 — Instalar o jq (o script depende dele para ler o JSON):

brew install jq           # macOS
# sudo apt install jq     # Ubuntu/Debian
# sudo pacman -S jq       # Arch

Passo 2 — Criar o script em ~/.claude/statusline-command.sh. Abra o arquivo no editor de sua preferência:

nano ~/.claude/statusline-command.sh   # ou vim, code, etc.

E cole o conteúdo abaixo (salve e saia):

#!/usr/bin/env bash

input=$(cat)

raw_dir=$(echo "$input" | jq -r '.workspace.current_dir // .cwd')
model=$(echo "$input" | jq -r '.model.display_name // "Claude"')
used_pct=$(echo "$input" | jq -r '.context_window.used_percentage // empty')
window_size=$(echo "$input" | jq -r '.context_window.context_window_size // empty')

# Shorten the home directory to ~
dir="${raw_dir/#$HOME/\~}"

# Git branch (skip optional locks for safety with agents)
git_branch=""
if git -C "$raw_dir" rev-parse --is-inside-work-tree --no-optional-locks 2>/dev/null | grep -q true; then
    branch=$(git -C "$raw_dir" symbolic-ref --short HEAD 2>/dev/null || git -C "$raw_dir" rev-parse --short HEAD 2>/dev/null)
    if [ -n "$branch" ]; then
        git_branch=$(printf " \033[35m|\033[0m \033[35m%s\033[0m" "$branch")
    fi
fi

# Context usage indicator
ctx_info=""
if [ -n "$used_pct" ]; then
    used_int=$(printf "%.0f" "$used_pct")
    if [ -n "$window_size" ]; then
        total_k=$(echo "$window_size" | awk '{printf "%dk", $1/1000}')
        ctx_info=$(printf " \033[35m|\033[0m \033[36mctx:%s%% of %s\033[0m" "$used_int" "$total_k")
    else
        ctx_info=$(printf " \033[35m|\033[0m \033[36mctx:%s%%\033[0m" "$used_int")
    fi
fi

printf "\033[34m%s\033[0m%s \033[35m|\033[0m \033[32m%s\033[0m%s" \
    "$dir" "$git_branch" "$model" "$ctx_info"

Passo 3 — Dar permissão de execução:

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

Passo 4 — Testar o script manualmente (simulando o JSON que o Claude envia):

echo '{"workspace":{"current_dir":"'"$HOME"'/Workspace/my-app"},"model":{"display_name":"Opus 4.8"},"context_window":{"used_percentage":5,"context_window_size":1000000}}' | bash ~/.claude/statusline-command.sh

Deve imprimir algo como seuusuario | ~/Workspace/my-app | git:(main) | Opus 4.8 | ctx:5% of 1000k.

Passo 5 — Registrar no settings.json. No arquivo ~/.claude/settings.json, use o caminho absoluto do script, com seu usuário real:

{
  "statusLine": {
    "type": "command",
    "command": "bash /Users/SEU_USUARIO/.claude/statusline-command.sh"
  }
}

Atalho: dentro do Claude Code também dá para usar o comando /statusline para ajudar a configurar.

2 Outras configurações úteis do settings.json

Além da status line, vale destacar alguns ajustes do meu settings.json:

{
  "model": "opus",
  "effortLevel": "xhigh",
  "env": {
    "DISABLE_TELEMETRY": "1",
    "DISABLE_ERROR_REPORTING": "1"
  },
  "permissions": {
    "allow": [
      "Bash(npm run lint)",
      "Bash(npm run test *)",
      "Read(~/.zshrc)"
    ],
    "deny": [
      "Bash(curl *)",
      "Read(**/.env)",
      "Read(**/.env.*)",
      "Read(**/secrets/**)"
    ]
  }
}

• model — modelo padrão (opus).
• effortLevel — nível de esforço de raciocínio.
• DISABLE_TELEMETRY — desliga analytics de uso anônimo (quais comandos você roda, frequência, métricas de feature).
• DISABLE_ERROR_REPORTING — desliga relatórios automáticos de crash/erro; os stack traces ficam na sua máquina.
• permissions.allow — comandos pré-aprovados (sem precisar confirmar toda vez).
• permissions.deny — bloqueios de segurança: nunca ler .env/secrets nem rodar curl.

O Claude Code lê o settings.json na inicialização, então a sessão em execução mantém as regras antigas — ela ainda vai ler o seu .env. Feche o Claude Code e abra de novo para a nova lista de deny valer.

3 Plugins que eu uso

Os plugins ficam habilitados em enabledPlugins no settings.json e são instalados a partir de marketplaces. Eu uso 4:

3.1 Configuração dos plugins no settings.json

{
  "enabledPlugins": {
    "context7@claude-plugins-official": true,
    "code-review@claude-plugins-official": true,
    "code-simplifier@claude-plugins-official": true,
    "caveman@caveman": true
  },
  "extraKnownMarketplaces": {
    "caveman": {
      "source": {
        "source": "github",
        "repo": "JuliusBrussee/caveman"
      }
    }
  }
}

• enabledPlugins — liga cada plugin pelo formato nome@marketplace.
• extraKnownMarketplaces — registra marketplaces extras além do oficial. Aqui o caveman vem direto de um repositório GitHub.

3.2 Instalando plugins na prática

Os plugins podem ser gerenciados pela interface do Claude Code (comando de plugins) ou aparecem em ~/.claude/plugins/config.json depois de instalados. Para um marketplace externo como o caveman, basta tê-lo registrado em extraKnownMarketplaces e marcar o plugin como true em enabledPlugins.

4 RTK — proxy CLI otimizado para tokens

Além dos plugins, eu uso o RTK (rtk-ai/rtk): um proxy de linha de comando que filtra e comprime a saída dos comandos antes dela chegar ao contexto do LLM, reduzindo o consumo de tokens em 60–90%.

4.1 O que faz

• Processa a saída de 100+ comandos (git, cargo, npm, docker, AWS, etc.).
• Aplica 4 estratégias: filtragem inteligente, agrupamento, truncamento e deduplicação.
• Binário único em Rust, sem dependências externas, overhead de ~10ms por comando.

4.2 Comandos principais

4.3 Instalação

brew install rtk
# ou
cargo install --git https://github.com/rtk-ai/rtk

4.4 Setup no Claude Code

rtk init -g

Isso instala o hook de auto-rewrite, que converte os comandos bash em equivalentes RTK de forma transparente, sem precisar mudar o jeito de trabalhar. Junto com o plugin caveman, forma uma dupla de economia de contexto: o caveman comprime a comunicação, o RTK comprime a saída das ferramentas.

5 Conclusão

Esse é o setup que venho usando no dia a dia. Tem agregado bastante ao meu fluxo de desenvolvimento.