# Claude Code em 2026: 11 dicas, atalhos e comandos > Experimente no Claude Code atalhos de teclados como Shift+Tab e Esc Esc, além de flags da CLI e comandos para gerir modos, contexto e tokens. Source: https://ailoot.ai/blog/pt-pt/claude-code-tips/ Canonical: https://ailoot.ai/blog/pt-pt/claude-code-tips/ Language: pt-PT Publisher: Ailoot (https://ailoot.ai/) Translation: guide-001 Revision: sha256-ee1ea681d3492fa31ef51f348f4552cd55fce898dc86de8addcd3391847e80be Para obter instruções adicionais sobre como trabalhar com o Ailoot, consulte a [documentação](https://ailoot.ai/docs/). ## O que fazem estas 11 dicas e porque precisa de táticas em vez de teoria?
Ideias principais Esta não é uma lista das «melhores funcionalidades do Claude Code» nem uma recontagem da documentação da Anthropic. São 11 técnicas de seis meses de trabalho diário: 5 táticas (atalhos, opções e /commands) e 6 estratégicas (como dividir um plano, como gerir 5 janelas e como detetar pontos cegos). Basta uma noite para criar 11 hábitos.
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](https://ailoot.ai/blog/pt-pt/claude-md-template/), [Plan Mode](https://ailoot.ai/blog/pt-pt/claude-code-plan-mode/), [engenharia de contexto](https://ailoot.ai/blog/pt-pt/context-engineering/), [Skills](https://ailoot.ai/blog/pt-pt/claude-code-skills-library/), [Subagents](https://ailoot.ai/blog/pt-pt/claude-code-subagents/), [MCP](https://ailoot.ai/blog/pt-pt/mcp-servers-claude-code/), [/rewind](https://ailoot.ai/blog/pt-pt/claude-code-undo-changes/), [limites](https://ailoot.ai/blog/pt-pt/claude-code-token-limits-saving/), [segundo cérebro](https://ailoot.ai/blog/pt-pt/claude-code-second-brain/). 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](https://ailoot.ai/blog/pt-pt/claude-md-template/) e depois volte aqui. ## Como alternar entre os modos do Claude Code: o atalho Shift+Tab
Ideias principais Shift+Tab percorre os modos de permissão: `default`, `acceptEdits`, `plan` e quaisquer modos ativados (`auto`, `bypassPermissions`). Antes de uma tarefa complexa, percorra os modos até ao [Plan Mode](https://ailoot.ai/blog/pt-pt/claude-code-plan-mode/) e verifique o indicador antes de enviar a tarefa. Para trabalho de rotina, selecione `acceptEdits` e confirme essa indicação; o número de toques depende do modo inicial e dos modos ativados.
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. ```bash # 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.
Shift+Tab percorre os modos de permissão. Os modos disponíveis dependem do que ativou nas definições.
— Documentação da Anthropic, https://code.claude.com/docs/en/interactive-mode
## Como anular a última ação sem perder o contexto: Esc Esc
Ideias principais Esc Esc é uma forma rápida de anular a última ação do Claude sem recorrer a um `/rewind` completo. Se o campo de entrada estiver vazio, abre-se o menu de pontos de controlo. Se houver algo no campo, o texto é apagado, mas fica guardado no histórico (a seta para cima recupera-o). Isto resolve, em 80% dos casos, o receio de «estraguei isto e não consigo anular»; não precisa de recorrer ao git.
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). ```bash # 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](https://ailoot.ai/blog/pt-pt/claude-code-undo-changes/), que também aborda a combinação com o git para reversões profundas.
Cada prompt do utilizador cria um novo ponto de controlo. Os pontos de controlo são guardados entre sessões, pelo que pode voltar a eles em conversas retomadas.
— Documentação da Anthropic, https://code.claude.com/docs/en/checkpointing
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?
Ideias principais `/clear` repõe completamente a sessão, deixando uma janela de contexto limpa. `/compact [hint]` pede ao LLM que comprima o histórico da conversa num resumo, preservando o significado do trabalho anterior. A regra é simples: terminou a tarefa - `/clear`. Vai continuar a mesma tarefa, mas a janela está cheia - `/compact`. Se os confundir, ou perde o contexto ou atinge o limite.
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. ```bash # 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.
No Claude Code, por exemplo, fazemos isto enviando o histórico de mensagens ao modelo, para resumir e comprimir a informação mais importante.
— Engenharia da Anthropic, https://www.anthropic.com/engineering/effective-context-engineering-for-ai-agents
Para conhecer toda a teoria sobre a janela de contexto, consulte o guia de [engenharia de contexto](https://ailoot.ai/blog/pt-pt/context-engineering/). 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
Ideias principais `/cost` mostra as despesas atuais em dólares e tokens. `/statusline` acrescenta a mesma informação à barra de estado - pode ver sempre o modelo, a pasta, a percentagem de contexto e o custo sem executar um comando. A principal forma de lidar com o receio de «gastar tudo num dia» é manter as despesas sempre visíveis.
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**. ```bash /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»](https://ailoot.ai/blog/pt-pt/claude-code-token-limits-saving/), 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](https://ailoot.ai/blog/pt-pt/context-engineering/)** — é 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?
Ideias principais A opção `--model` substitui o modelo apenas na sessão atual. Regra básica: Haiku para scripts e alterações rápidas, Sonnet para raciocínio aprofundado de rotina, Opus para arquitetura e depuração complexa. Segundo entrevistas públicas, a própria equipa do Claude Code usa Opus com pensamento «para tudo», mas essa é uma opção para quem paga uma subscrição sem se preocupar com tokens. Para um empreendedor, a regra é diferente: comece por algo mais barato e pague mais quando precisar.
```bash 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: | Tarefa | Modelo | Motivo | |----|----|----| | Mudar o nome de uma variável/função | Haiku | Operação inequívoca; não é preciso «pensar» | | Refatoração simples (extrair uma função) | Sonnet | Padrão, económico, preciso | | Adicionar uma funcionalidade nova com arquitetura | Opus | É preciso raciocínio aprofundado | | Depurar um erro estranho que o Sonnet não encontrou em 3 tentativas | Opus | Menos orientação, maior probabilidade de sucesso | | Ler e resumir registos longos | Haiku | Categorização simples e mais económica | 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
Ideias principais O trabalho em paralelo no Claude Code depende de 2 coisas: `--resume` (continuar uma sessão com nome) e `git worktree` (um diretório separado para cada ramo). Na prática, tenho 5-10 janelas do Claude abertas ao mesmo tempo, cada uma a trabalhar na sua própria microtarefa. Os contextos não se sobrepõem e não se desperdiçam tokens com «tudo numa janela».
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. ```bash # 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
Ideias principais Em vez de escrever «analisa o projeto e encontra auth.ts», escreva `@src/lib/auth.ts` e o Claude carregará diretamente o ficheiro, sem o procurar. Isto poupa tokens (não é preciso percorrer a árvore) e elimina uma fonte de alucinações (o Claude não tem de adivinhar o caminho; já lhe indicou o caminho). O mesmo se aplica aos comandos: `!git status` é executado sem chamada de ferramenta e o resultado é incluído no contexto.
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`. ```bash # 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 `!`: ```bash > !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](https://ailoot.ai/blog/pt-pt/claude-md-template/). ## Como evitar perder o progresso em tarefas longas: planos por fases com \[ \] / \[x\]
Ideias principais Qualquer tarefa que exija mais de 30 minutos de trabalho precisa de um plano num ficheiro separado, `plans/YYYY-MM-DD-name.md`, com fases e caixas de verificação `[ ]` / `[x]`. O plano pertence a um ficheiro, não à conversa. Isto permite que janelas paralelas assumam fases diferentes sem interferirem entre si e facilita acompanhar o progresso, em vez de o «recordar» a partir da conversa.
Este é o modelo de ficheiro de plano que uso em todos os projetos: ```markdown # 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](https://ailoot.ai/blog/pt-pt/claude-code-second-brain/). ## Como detetar antecipadamente onde o Claude vai falhar: autocrítica com 10 motivos
Ideias principais Antes de começar uma funcionalidade complexa, coloque o Claude em modo adversarial: «Imagine que o projeto falhou. Daqui a um ano, perdi tempo e energia. Indique 10 motivos. Não me poupe; seja duro.» Isto interrompe o otimismo inicial e revela pontos cegos que o Claude nunca apontaria no modo «vamos implementar».
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
Ideias principais Antes de começar a trabalhar numa funcionalidade, inicie 5 agentes de pesquisa em paralelo através de subagentes. Cada um se concentra na sua área: redes profissionais, código aberto, aceleradoras, concorrentes e comparações. As respostas chegam em 10-20 minutos. Depois, um agente de síntese separado reúne tudo num único relatório. Isto poupa horas e reduz o viés de confirmação.
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»](https://ailoot.ai/blog/pt-pt/claude-code-subagents/). 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
Ideias principais Ligue o Claude Code ao seu bot de Telegram através do plugin oficial. No computador (com a suspensão desativada), o Claude Code funciona num terminal associado ao projeto. Pode enviar-lhe mensagens de qualquer lugar através do bot: «consulta os commits mais recentes», «qual foi a receita dos recibos desta semana», «lê todas as perguntas de suporte desta noite». O bot responde com todo o contexto do projeto — código, histórico de commits, toda a estrutura `business/`. Um agente ativo na sua base de código que vê e recorda tudo.
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](https://github.com/anthropics/claude-plugins-official)). 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
Ideias principais Não tente implementar as 11 dicas num só dia — vai esgotar-se e elas não se tornarão hábitos. Roteiro de 7 dias: dias 1-2 - atalhos (1-3), dias 3-4 - comandos (4-5), dias 5-6 - trabalho em paralelo (6-7), dia 7 - planeamento e pré-mortem (8-9). Os subagentes em paralelo e o bot de Telegram (10-11) ficam para a segunda semana, quando já dominar as primeiras 9.
| Dia | O que vamos implementar | Quanto tempo demora | |----|----|----| | 1 | Shift+Tab + Esc Esc | 30 minutos de prática | | 2 | Familiarizar-se com Shift+Tab + Esc Esc | trabalhar durante meio dia | | 3 | /compact + /cost | 30 minutos + 1-2 sessões de trabalho | | 4 | --model haiku/sonnet/opus | 30 minutos + alguma experimentação | | 5 | --resume para sessões com nome | 30 minutos | | 6 | git worktrees - se gerir 3 ou mais tarefas em paralelo | 1 hora | | 7 | Plano em `plans/` + o prompt «10 motivos pelos quais vou falhar» | 1-2 horas, uma vez | | 8-14 (segunda semana) | Subagentes para pesquisa + bot de Telegram | 3-4 horas para configurar e ganhar prática | 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](https://ailoot.ai/blog/pt-pt/context-engineering/)**. 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.
### Fontes - [Referência da CLI do Claude Code - code.claude.com](https://code.claude.com/docs/en/cli-reference) - [Modo interativo do Claude Code (atalhos) - code.claude.com](https://code.claude.com/docs/en/interactive-mode) - [Comandos de barra do Claude Code - code.claude.com](https://code.claude.com/docs/en/slash-commands) - [Pontos de controlo do Claude Code - code.claude.com](https://code.claude.com/docs/en/checkpointing) - [Memória e /compact do Claude Code - code.claude.com](https://code.claude.com/docs/en/memory) - [Engenharia de contexto eficaz para agentes de IA - Engenharia da Anthropic](https://www.anthropic.com/engineering/effective-context-engineering-for-ai-agents) - [GitHub: anthropics/claude-code (CHANGELOG)](https://github.com/anthropics/claude-code/blob/main/CHANGELOG.md)
Para continuar a trabalhar com modelos, pode aceder ao [Ailoot](https://ailoot.ai/). ## Perguntas frequentes ### Como sei que estou no Plan Mode? Use Shift+Tab para percorrer os modos e leia o indicador antes de enviar a tarefa. Pare quando mostrar `plan`; um número fixo de toques não é fiável porque o modo inicial e os modos ativados podem diferir. ### Devo usar /clear ou /compact quando o contexto enche? Use `/compact` para continuar a mesma tarefa, indicando o plano e as decisões a preservar. Use `/clear` quando a tarefa terminar e a seguinte precisar de contexto novo; guarde primeiro os progressos importantes no ficheiro do plano. ## Ailoot · A empresa e a sua carteira de projetos A Ailoot assenta numa experiência operacional consolidada, numa ampla base de clientes, num serviço estável e no acompanhamento contínuo dos KPI. A empresa e a sua carteira de projetos: milhões de clientes; vendas mensais na ordem dos milhares de milhões. A Ailoot aplica essa experiência operacional ao acesso por API a funcionalidades de IA nos produtos dos clientes, agentes, aplicações e automatizações.