Claude Code em 2026: 11 dicas, atalhos e comandos

Para obter instruções adicionais sobre como trabalhar com o Ailoot, consulte a documentação.

O que fazem estas 11 dicas e porque precisa de táticas em vez de teoria?#

Com a programação por vibração, a questão já não é «o Claude Code funciona?» — a questão é «como trabalhar com ele sem esgotar os seus limites nem provocar alucinações?». Os meus 9 guias anteriores abordam os conceitos: CLAUDE.md, Plan Mode, engenharia de contexto, Skills, Subagents, MCP, /rewind, limites, segundo cérebro. Este guia reúne táticas que os complementam.

Cada dica resolve uma dor de cabeça. Pode lê-las por ordem ou ir diretamente às mais urgentes: para os atalhos, avance para a dica 1; para poupar tokens, consulte as dicas 4 e 5; para trabalhar em paralelo, a dica 6; para as técnicas do autor, as dicas 8-11.

Escrevo para pessoas que já instalaram o Claude Code e passaram pelo menos uma semana a utilizá-lo. Se acabou de o instalar, comece pelo guia do CLAUDE.md e depois volte aqui.

Como alternar entre os modos do Claude Code: o atalho Shift+Tab#

O erro mais comum dos principiantes é ficar em default todo o dia e aprovar manualmente cada alteração. Ao fim de uma hora, torna-se exaustivo e apetece executar --dangerously-skip-permissions (mais sobre isso no final desta dica). Shift+Tab é o meio-termo: escolhe quando precisa de acceptEdits e quando precisa de plan.

Esta é a regra específica que sigo ao alternar:

1. Início de uma tarefa complexa - use Shift+Tab até o indicador mostrar plan. O Claude analisa a tarefa e prepara um plano; não escreve código até eu aprovar.
2. Plano aprovado, início da implementação - percorra os modos até o indicador mostrar acceptEdits. O Claude edita ficheiros sem pedir aprovação, mas continua a pedir aprovação para comandos Bash.
3. Alterações de rotina (mudar nomes, refatoração trivial) - avance diretamente para acceptEdits, sem plano.
4. Zona de perigo (migrações de bases de dados, eliminação de ficheiros) - volto a default com Shift+Tab.

# Modos de permissão comuns (verifique a indicação ativa, não uma contagem fixa de toques):
# default        - pedidos de permissão normais
# acceptEdits    - aceita edições de ficheiros; as outras permissões continuam a aplicar-se
# plan           - investigar e planear antes de implementar
# Os modos adicionais dependem da versão, das definições e da política da organização.

Se Shift+Tab não funcionar na sua versão do Claude Code (claude --version), confirme que tem a versão mais recente. O comando /doctor mostra-lhe tudo sobre a instalação.

Como anular a última ação sem perder o contexto: Esc Esc#

Esc e Esc Esc fazem coisas diferentes, daí a confusão:

• Um Esc - interrompe o Claude naquele momento, enquanto está a fazer algo. Tudo o que conseguiu fazer até então permanece. É útil quando segue na direção errada e quer redirecioná-lo.
• Dois Esc Esc - se o campo de entrada estiver vazio, abre o menu de pontos de controlo (restaurar o código, a conversa ou ambos, ou criar um resumo). Se houver texto no campo, apaga-o e guarda-o no histórico (a seta para cima recupera-o).

# From the Esc Esc menu with an empty field:
# 1. Restore code only            - restore the files, leave the conversation
# 2. Restore conversation only    - restore the conversation, leave the files
# 3. Restore code and conversation - restore both (the most common choice)
# 4. Summarize from here          - summarize the conversation from this point
# 5. Summarize up to here         - summarize up to this point

Os pontos de controlo são criados automaticamente para cada prompt que envia — não precisa de se lembrar de nada e pode sempre voltar atrás. Para uma explicação completa, consulte o guia do /rewind, que também aborda a combinação com o git para reversões profundas.

Esc Esc é uma das primeiras técnicas para principiantes. Quando deixam de recear que vão «estragar isto e não conseguir anular», começam a experimentar com mais ousadia e os resultados melhoram muitas vezes.

Quando deve usar /compact em vez de /clear?#

Eis como o /compact funciona internamente: o Claude recebe todo o histórico de mensagens, processa-o e devolve um resumo breve com os detalhes mais importantes. Um truque útil é dar-lhe uma indicação: /compact keep the coding principles and current plan, discard the CSS discussion. Assim, a compressão será direcionada.

# When to use what:
/clear                              # finished a feature, moving to a new one
/compact                            # long session, context is >50% full
/compact keep the architecture and plan  # targeted compression with a focus

O sinal de que está na altura de usar /compact: o comando /cost ou a barra de estado mostra que está a usar mais de 70% da janela de contexto e a sessão ainda só vai a meio. Se ignorar isto, o Claude começará a «esquecer-se» do início da conversa e perderá tempo a explicar tudo novamente.

Para conhecer toda a teoria sobre a janela de contexto, consulte o guia de engenharia de contexto. Também explica por que razão o contexto é um recurso finito com rendimentos decrescentes.

Como acompanhar os tokens em tempo real: o comando /cost#

O receio de «gastar tudo num dia» é uma das principais preocupações entre quem programa por vibração. A principal forma de lidar com esse receio é tornar as despesas visíveis.

/cost          # shows current session spending (tokens + $)
/statusline    # configures the status bar: model + directory + context % + cost

Uma regra simples: verifique /cost a cada 30-60 minutos. Se gastou menos de um par de dólares numa hora, está tudo bem. Se gastou mais, algo não está certo: talvez se tenha esquecido de usar /compact e o contexto esteja a crescer, talvez tenha escolhido o modelo errado (mais sobre isso na próxima dica) ou talvez o Claude esteja a reler ficheiros grandes 10 vezes.

O guia completo para poupar nos limites é «Como não esgotar os limites do Claude Code num dia», com 8 regras. Aqui, a tática consiste em tornar as despesas visíveis com /cost e /statusline.

Quer não só acompanhar os tokens, mas também criar um sistema em que um agente de IA não ultrapasse os seus limites? /cost é apenas um indicador. A combinação completa — clone de IA + Segundo Cérebro + Engenharia de Contexto — é o que transforma o Claude de um «assistente com limites» numa ferramenta que consegue trabalhar durante muito tempo de forma previsível.

Que modelo do Claude deve escolher para cada tarefa: Haiku, Sonnet ou Opus?#

claude --model haiku   # ~3× cheaper than sonnet, for routine work
claude --model sonnet  # default, balance of price and quality
claude --model opus    # ~1.7× more expensive than sonnet, for complex tasks

Segundo os preços públicos da Anthropic em maio de 2026: Haiku $1/$5 por 1M de entrada/saída, Sonnet $3/$15, Opus $5/$25. Isto significa que o Haiku custa 3 vezes menos do que o Sonnet e o Opus custa 1,7 vezes mais do que o Sonnet.

Como escolho todos os dias:

A questão discutível é se vale a pena usar Sonnet e Haiku quando o Opus acerta, em média, «à primeira». A minha resposta: para um empreendedor que não é programador, Haiku e Sonnet compensam em 70% das tarefas. Vale a pena reservar Opus para os 30% que são realmente difíceis.

Como executar 3-5 tarefas em paralelo: /resume + git worktrees#

A lógica é simples: uma única janela longa do Claude consome contexto. Cada pedido carrega para o modelo tudo o que estava nessa janela — mesmo que agora esteja a falar de algo completamente diferente. 5 janelas curtas para microtarefas lembram-se apenas do seu próprio trabalho. No total, gasta menos.

# Start a named session for a specific task:
claude --resume "auth-refactor"
claude --resume "homepage-redesign"
claude --resume "db-migration"

# Use a worktree to keep git from overlapping:
git worktree add ../my-project-auth feature/auth
cd ../my-project-auth
claude --resume "auth-refactor"

Se perder o fio à meada e deixar de saber o que se passa em cada janela, execute claude --resume sem argumento para ver uma lista das sessões recentes, com os respetivos nomes e horários. Numa sessão ativa, /agents verifica os subagentes em execução.

Quando estou a trabalhar numa funcionalidade com um ciclo de desenvolvimento longo, costumo fazer o seguinte:

1. Janela 1 - plano em plans/YYYY-MM-DD-feature.md. Apenas discussão, sem código.
2. Janela 2 (a seguir ao plano) - implementar a fase 1. No fim da fase, atualizar o plano ([x]).
3. Janela 3 - implementar a fase 2 em paralelo com a janela 2, se as fases não se sobrepuserem.
4. Janela 4 - um agente de síntese verifica os resultados das duas janelas.
5. Janela 5 - uma revisão de segurança após a junção (consulte a dica 8).

Quando não deve usar worktrees: se gerir 1-2 projetos por dia, o trabalho adicional de alternar entre diretórios de worktree anulará a vantagem. Os worktrees começam a compensar a partir de 3 ou mais tarefas paralelas por dia.

Como evitar alucinações: referências a ficheiros com @file#

O preenchimento automático de ficheiros começa com o símbolo @. Comece a escrever um caminho e o Claude apresenta sugestões. Pode referenciar vários ficheiros de uma só vez: @src/lib/auth.ts @src/lib/session.ts @prisma/schema.prisma.

# Prompt without exact paths (bad):
> Look at the auth logic and fix the session bug

# Prompt with @ references (right):
> @src/lib/auth.ts @src/lib/session.ts - fix the bug: after logout the cookie isn't cleared

O segundo truque do mesmo grupo é o modo de shell com !:

> !git status                # runs without calling Claude, output goes into context
> !npm test                  # same
> !cat /var/log/app.log | tail -50  # same

Porquê: não gasta tokens a pedir «Claude, consulta o estado do git» — o Claude obteria a mesma resposta através da ferramenta. ! é mais curto e económico.

Isto está relacionado com o CLAUDE.md: o ficheiro principal deve ter até 200 linhas de regras do projeto. Regras mais específicas (por exemplo, convenções de API) devem ficar em .claude/rules/api-design.md com YAML frontmatter paths: ["src/api/**/*.ts"]. Assim, só são carregadas quando o Claude edita ficheiros em src/api/. Para uma explicação completa, consulte o guia do CLAUDE.md.

Como evitar perder o progresso em tarefas longas: planos por fases com [ ] / [x]#

Este é o modelo de ficheiro de plano que uso em todos os projetos:

# Plan: [feature name]
Creation date: 2026-05-22
Goal: [one sentence on what we want to achieve]

## Phase 1: [short name]
- [ ] Step 1.1: [specific action]
- [ ] Step 1.2: [specific action]
- [ ] Step 1.3: [specific action]

## Phase 2: [short name]
- [ ] Step 2.1
- [ ] Step 2.2

## Outcome
Fill in at the end: fully or partially implemented, and what remains.

A regra é absoluta: todos os agentes têm de atualizar o plano após cada sessão. Por outras palavras, assim que termina uma fase, deve ir ao ficheiro e assinalá-la com [x]. Se não o fizer, a próxima janela não saberá que a fase está concluída e tentará repeti-la.

Quando o plano está num ficheiro, e não na sua cabeça:

• As janelas paralelas (consulte a dica 6) podem assumir fases diferentes.
• Se a tarefa se prolongar por 3 dias, ao voltar 2 dias depois, verá imediatamente onde ficou.
• A verificação final do resultado é rápida (grep -c "\[ \]" no ficheiro = número de tarefas por concluir).

Quando não deve usar esta técnica: uma correção urgente de 5 minutos, uma alteração trivial num ficheiro, ler e resumir um registo. Nem todas as ações precisam de um plano.

Esta técnica faz parte do conceito de Segundo Cérebro. Para uma explicação completa das pastas business/, plans/, ai-clone/, consulte o guia do Segundo Cérebro.

Como detetar antecipadamente onde o Claude vai falhar: autocrítica com 10 motivos#

Eis o modelo de prompt que uso tal como está:

Imagine the idea folder has been put through a methodology where you already think as if the project has completely failed. Name 10 reasons why, a year from now, I will have spent a lot of time and the idea will have turned out to be a failure. Your task is not to spare my feelings, but to be as harsh as possible.

After the 10 reasons - a second round: defend each reason against my counterarguments. Where am I weakest?

Third round: write a plan for what to do so that these problems don't occur.

Aplico-o em três fases:

1. A primeira ideia «está tudo ótimo» - quando tenho a certeza. A autocrítica reduz a ideia em 30-50%.
2. A meio do plano - quando já estou profundamente envolvido no trabalho e perdi alguma perspetiva.
3. Antes do lançamento - um filtro final.

O Claude desafia-nos mesmo em modo adversarial. Na mesma situação, o GPT-5 começa por elogiar a ideia e depois «tenta encontrar melhorias». Reparei nesta diferença após um ano de experiências:

Para mim, a diferença no modo adversarial é esta: o ChatGPT diz «Boa observação, tem toda a razão». Na mesma situação, o Claude diz «Concordo, isso é uma treta completa; vou reformular agora». Quando preciso de críticas, a segunda resposta poupa-me dias de trabalho desperdiçado.

Quando não deve aplicar esta técnica: iterações positivas em interfaces de utilizador e redação publicitária. O modo adversarial não é adequado nesses casos — vai matar a criatividade.

Esta técnica é conhecida como pré-mortem de projeto. Adaptei-a ao trabalho com um agente de IA: em vez de uma equipa de pessoas, faz-se um pré-mortem com o Claude. Ninguém tem medo de dizer «chefe, o projeto vai falhar» — e os pontos cegos surgem em minutos.

Como fazer 5 fontes de pesquisa no tempo de uma: subagentes em paralelo#

Eis o modelo de prompt:

You already have the full context. Find and conduct deep research; launch 5 parallel subagents.

Subagent 1: go through professional networks - who is solving this problem?
Subagent 2: open-source solutions on GitHub - what is popular?
Subagent 3: startup accelerators - who is attracting
            investment in this niche?
Subagent 4: direct competitors' websites - what do they promise and
            at what price?
Subagent 5: comparisons and reviews - what do
            users say in reviews?

When everyone returns, launch a synthesis agent
that cross-references the 5 reports and produces an outline
for my second-brain folder.

O que muda em relação à pesquisa habitual:

• Tempo: 5 fluxos simultâneos em vez de 5 sequenciais. Uma hora de trabalho em 15 minutos.
• Profundidade: cada agente é especializado. O viés de confirmação de um agente não contamina os outros.
• Contexto: cada subagente tem o seu próprio contexto, separado do contexto principal.

Para o guia completo sobre subagentes, consulte «Subagentes do Claude Code em 2026». Também explica a diferença entre Skills e MCP — e quando usar cada um.

Quando não deve aplicar esta técnica: alterações cosméticas, correções de erros e pequenas tarefas técnicas. A pesquisa é excessiva para qualquer tarefa menor do que «uma nova funcionalidade que exige 1 ou mais dias de trabalho».

Como dar tarefas ao Claude pelo telemóvel: um bot de Telegram no bolso#

Como configurar (4 passos):

1. Um computador sempre ligado - desativo a suspensão nas definições do sistema (macOS: Energy Saver → Prevent computer from sleeping).
2. Claude Code em execução num terminal, associado à pasta do projeto.
3. O plugin oficial de Telegram - adicione o marketplace com /plugin marketplace add anthropics/claude-plugins-official e depois instale /plugin install telegram@claude-plugins-official (os passos exatos são atualizados com o tempo - as instruções mais recentes estão no repositório oficial do plugin).
4. O bot está associado a uma sessão - esta é atualmente uma limitação: um bot = um projeto = uma sessão. Se precisar de um segundo, configure outro bot.

O que faço com o bot todos os dias:

• Estou a dar um passeio e tenho uma ideia - envio-a logo ao bot para não me esquecer. O bot acrescenta-a a inbox.md para a processar mais tarde.
• Uma chamada com um potencial cliente - depois da chamada, pergunto ao bot: «com base na transcrição da última chamada, indique os 3 principais pontos problemáticos que nos favorecem». Um minuto depois, tenho uma análise completa na conversa.
• De manhã, num café - «mostra-me os trabalhos de casa pendentes da minha lista». Não preciso de abrir o portátil.

⚠️ Uma limitação: por enquanto, não é possível executar /clear ou /compact através do bot — a sessão do bot é a mesma do terminal e o contexto continua a crescer. Só é possível reiniciá-la manualmente através do terminal.

Para mim, esta é a extensão mais útil do Claude Code das últimas duas semanas. Levou-me de «trabalho com o Claude quando estou à secretária» a «trabalho com o Claude sempre que tenho uma ideia».

O que deve pôr em prática primeiro: um roteiro de 7 dias#

A combinação de técnicas importa mais do que qualquer uma delas isoladamente. Shift+Tab sem Esc Esc torna a experimentação assustadora. /compact sem /cost significa que não sabe quando deve comprimir. Planos em ficheiros sem janelas paralelas são uma complicação sem benefício.

Quando as primeiras 9 dicas se tornarem naturais, avance para o sistema completo: clone de IA + Segundo Cérebro + Engenharia de Contexto. Esta é a metodologia que usei para manter o Claude a funcionar durante seis meses seguidos — sem alucinações, perda de contexto nem interrupções a meio de uma tarefa.

Para continuar a trabalhar com modelos, pode aceder ao Ailoot.