O terminal do Claude Code é mais potente do que a app?

O motor é o mesmo, mas o terminal expõe funções que a app esconde ou não tem: sessões em paralelo com git worktrees, flags para automatizar (--print, --output-format), modo headless para o meter em scripts, e um controlo bem mais fino sobre permissões e contexto. A app é perfeita para rever mudança a mudança; o terminal é para quando trabalhas em volume ou queres encadear o Claude com outras ferramentas.

Preciso de saber muito de terminal para dar o salto?

O mínimo. Tens de estar à vontade com cd, ls, executar comandos e perceber o que é um branch de git. Não é preciso ser especialista em bash: 90 % do tempo escreves em linguagem natural, tal como na app. O que há de novo a aprender são quatro comandos do Claude (os slash commands) e o conceito de worktree.

O que são as sessões em paralelo e porque é que importam tanto?

São várias instâncias do Claude Code a correr ao mesmo tempo, cada uma na sua própria cópia do projeto (um git worktree) e no seu próprio branch. Enquanto uma refatora, outra escreve testes e outra documenta, sem se atrapalharem. É o fluxo que transforma o Claude Code de assistente em equipa, e é praticamente impossível de replicar com uma única janela da app.

É perigoso usar o terminal? Perco a rede de segurança do visualizador de mudanças?

Não a perdes: no terminal o Claude também te pede aprovação antes de tocar em ficheiros ou executar comandos. A diferença é que podes ajustar as permissões (autoaprovar o que é seguro, exigir confirmação no que é destrutivo) e, se quiseres, dar-lhe mais autonomia. Mais poder e mais responsabilidade: configura as permissões antes de lhe atirares tarefas grandes.

Quando é que NÃO vale a pena o terminal?

Se os teus pedidos são pontuais, revê-los com calma um a um e não precisas de paralelismo nem de automação, a app chega e sobra. O salto compensa quando notas três coisas: que repetes as mesmas instruções, que gostarias de lançar duas tarefas ao mesmo tempo, ou que gostavas de meter o Claude dentro de um script. Se não sentires nenhuma, fica na app sem complexos.

Claude Code no terminal: o salto avançado que multiplica a tua potência

Há semanas que usas a app do Claude Code e já lhe apanhaste o jeito: pedidos claros, rever o visualizador, aprovar. Funciona. Mas começas a sentir o teto: gostarias de lançar duas coisas ao mesmo tempo, repetes as mesmas instruções em cada sessão, e ocorrem-te tarefas que seriam um script se pudesses chamar o Claude a partir da linha de comandos.

Esse teto tem nome: é a altura de descer ao terminal. Não porque seja «mais pro», mas porque desbloqueia um punhado de coisas que a app, por desenho, não te dá. Este guia é o salto: o que ganhas de verdade, como o instalar, os comandos que importam e os fluxos que mudam a tua forma de trabalhar.

Nota

O motor é o mesmo na app e no terminal. Não vais «aprender outro Claude Code». Vais destapar as funções avançadas que a interface visual mantém fora de vista: paralelismo, automação e controlo fino de permissões.

O que ganhas ao descer ao terminal (e o que não)

Sejamos honestos para não te fazer perder tempo. O terminal não te torna melhor nem os resultados mais inteligentes. O que muda é a forma de trabalhar. Ganhas quatro coisas concretas:

Sessões em paralelo. Várias instâncias a trabalhar ao mesmo tempo em branches diferentes. É a razão número um para dar o salto.
Automação. Flags como --print e --output-format transformam o Claude num comando a mais, encadeável com |, grep ou um cron.
Modo headless. Meter o Claude dentro de um script ou de um pipeline de CI sem que ninguém esteja a olhar para o ecrã.
Controlo de permissões. Decides o que autoaprova (ler, listar) e o que exige o teu OK (apagar, executar, push).

O que não muda: a rede de segurança continua lá. O Claude pede-te aprovação antes de tocar em qualquer coisa, tal como na app. Só que agora és tu que decides onde pôr a fasquia.

Instalação: cinco minutos

Se já tens a app, já cumpres os requisitos (Node e, quase de certeza, Git). O terminal instala-se como um pacote global:

Instalar o Claude Code (terminal)

# Com npm (o mais comum)
npm install -g @anthropic-ai/claude-code

# Confirma que está e vê a versão
claude --version

# Inicia sessão na primeira vez (usa a mesma conta da app)
claude

A primeira vez que executas claude dentro de uma pasta, pede-te login e arranca uma sessão interativa nesse diretório. A partir daí falas com ele em linguagem natural, exatamente como na app. A diferença está no que podes fazer à volta dessa conversa.

Dica

Arranca sempre o Claude dentro da pasta do projeto (cd meu-projeto && claude). O diretório de onde o lanças é a sua zona de trabalho e onde procura o CLAUDE.md. Lançá-lo a partir do home por engano é o primeiro tropeção clássico.

Os comandos que realmente importam

Esquece decorar cem atalhos. Na prática, o dia a dia são seis. Os comandos que começam por / escrevem-se dentro da sessão do Claude:

/clear — esvazia o contexto e começa limpo. O teu melhor amigo: uma sessão, um objetivo. Quando mudares de tarefa, limpa-o.
/init — analisa o projeto e gera-te um primeiro CLAUDE.md. O ponto de partida para o contexto permanente.
/agents — gere os subagentes (exploramo-los mais abaixo).
/permissions — ajusta o que autoaprova e o que não.
/resume — retoma uma sessão anterior com todo o seu contexto. Fechas o portátil e amanhã continuas de onde ficaste.
# no início de uma frase — guarda essa instrução no CLAUDE.md sem abrir o ficheiro. Atalho de ouro.

E duas flags que se usam ao lançar claude a partir de fora, não de dentro:

claude -p "o teu pedido" (ou --print) — executa uma tarefa e devolve o resultado pela saída padrão, sem sessão interativa. A porta para a automação.
--output-format json — devolve a resposta estruturada para que outro programa a processe.

O verdadeiro salto: sessões em paralelo com git worktrees

Aqui está o verdadeiro motivo para descer ao terminal. Na app trabalhas com uma conversa de cada vez. No terminal podes ter três Claudes a trabalhar em paralelo, cada um no seu branch, sem se atrapalharem.

O truque é o git worktree: cria cópias do repositório que partilham o mesmo histórico mas vivem em pastas e branches diferentes. Abres um terminal por worktree, lanças um claude em cada um, e repartem o trabalho.

Três sessões em paralelo

# A partir da raiz do projeto, cria três worktrees em branches novos
git worktree add ../projeto-feature -b feature-pagamentos
git worktree add ../projeto-tests   -b add-tests
git worktree add ../projeto-docs    -b update-docs

# Em três separadores/janelas de terminal diferentes:
cd ../projeto-feature && claude   # «implementa o fluxo de pagamentos»
cd ../projeto-tests   && claude   # «escreve testes para o módulo de auth»
cd ../projeto-docs    && claude   # «atualiza o README com os novos endpoints»

# Quando um branch estiver pronto, fazes o merge e limpas o seu worktree
git worktree remove ../projeto-docs

Isto é o que a app não te dá e o que, depois de experimentares, já não largas. Enquanto uma sessão refatora, outra documenta e outra testa. O teu trabalho passa de «esperar que o Claude acabe» para «supervisionar três frentes». É o passo de assistente a equipa.

Atenção

Paralelismo não é barra livre. Cada sessão segue o seu objetivo e nada mais: um worktree, uma tarefa. Se misturas temas dentro da mesma sessão, tiras-lhe precisão, exatamente como na app. E revê cada branch antes de fazer o merge; três agentes produzem o triplo de mudanças para aprovar.

CLAUDE.md e slash commands: o teu sistema operativo pessoal

Se na app o CLAUDE.md já era útil, no terminal é imprescindível. É o contexto permanente que o Claude lê ao arrancar em cada sessão: o que é o projeto, como trabalhas, que regras respeitar. Com várias sessões em paralelo, é o que mantém todas alinhadas sem que o repitas a cada uma.

O segundo nível são os slash commands personalizados: ficheiros Markdown em .claude/commands/ que se transformam em atalhos. Escreves um prompt longo uma vez e invoca-lo com /nome para sempre.

Slash command próprio (.claude/commands/revisa.md)

Revê o código que acabei de mudar à procura de:

- Bugs de lógica e casos-limite por cobrir.
- Problemas de segurança (inputs sem validação, segredos em claro).
- Inconsistências com as convenções deste projeto.

Não reescrevas nada por enquanto. Lista as descobertas por gravidade
e espera pelo meu OK antes de tocar em ficheiros.

A partir desse ficheiro, escreves /revisa dentro de qualquer sessão e o Claude executa essa revisão completa. Multiplica isto pelas tuas tarefas recorrentes (commits, changelog, auditoria) e deixas de escrever o mesmo todos os dias.

Modo headless: o Claude dentro dos teus scripts

O último fluxo avançado é o que quase ninguém usa e mais rende. Com claude -p metes o Claude em qualquer script, cron ou pipeline de CI. Deixa de ser uma janela de chat e passa a ser uma peça da tua automação.

O Claude num script

# Gera a mensagem de commit a partir do diff staged
git commit -m "$(git diff --cached | claude -p 'Resume estas mudanças numa mensagem de commit concisa, no imperativo')"

# Triagem automática: classifica um issue novo pela saída padrão
echo "$ISSUE_BODY" | claude -p 'Classifica este issue: bug / feature / pergunta. Responde só a etiqueta.' --output-format json

É aqui que o Claude Code deixa de ser uma ferramenta que abres e passa a ser infraestrutura que corre sozinha. Começa com pedidos delimitados e deterministas (resumos, classificação, formatação), não com tarefas destrutivas sem supervisão.

Quando dar o salto (e quando não)

Não desças ao terminal por estatuto. Fá-lo quando sentires pelo menos um destes três sinais:

Repetes instruções. Se copias o mesmo prompt em cada sessão, precisas de slash commands e de um CLAUDE.md bem afinado.
Gostarias de lançar duas tarefas ao mesmo tempo. Isso são worktrees. A razão número um.
Ocorrem-te scripts. Se pensas «isto devia correr sozinho», queres o modo headless.

Se não sentires nenhuma —os teus pedidos são pontuais e revê-los com calma— fica na app sem complexos. É igualmente potente para esse uso e não tem atrito.

A regra para escalar é a de sempre: aos poucos. Instala o terminal, habitua-te aos seis comandos, e só então experimenta um worktree. O paralelismo e os scripts chegam quando o anterior já te sai naturalmente. O salto não é técnico, é de volume: assim que tiveres três sessões a produzir ao mesmo tempo e um par de slash commands feitos, não vais querer voltar atrás.