Limites do Claude Code em 2026: 8 regras para não esgotar os tokens

Documentação de referência da Ailoot: ailoot.ai/docs/.

Como funcionam os limites do Claude Code em 2026 e porque é que os esgota?#

A 20 de maio de 2026, os planos pagos do Claude Code funcionam assim:

Valores da página oficial da Anthropic. Além da janela de 5 horas, existe também um limite semanal, que começa a afetar a experiência dos utilizadores intensivos por volta de sexta-feira.

O que significou a duplicação de 6 de maio?

Na conferência Code with Claude SF, a 6 de maio de 2026, a Anthropic anunciou um acordo com a SpaceX Colossus 1: 220 000 placas gráficas NVIDIA, 300 MW de capacidade, disponíveis no prazo de um mês. De imediato:

• Os limites de 5 horas duplicaram em todos os planos pagos.
• Foi removido o limite diário nas horas de ponta, que anteriormente reduzia as quotas durante esses períodos.
• Para a API: o máximo de tokens de entrada por minuto para o Opus subiu de 30K para 500K (+1500%) e o máximo de tokens de saída subiu de 8K para 80K.

Está também em vigor uma promoção temporária de 13 de maio a 13 de julho: +50% nos limites semanais para Pro / Max / Team. Após 13 de julho, as quotas semanais voltarão aos níveis anteriores.

Quanto usa realmente um vibe coder?

A Anthropic apresenta valores de referência na sua documentação oficial:

• Os programadores gastam em média 13 $ / dia, 150-250 $ / mês.
• 90% dos utilizadores ficam abaixo dos 30 $ / dia.
• As equipas de agentes em Plan Mode consomem cerca de 7 vezes mais tokens do que uma sessão normal.

O tamanho da janela de contexto depende do modelo. Segundo a documentação da Anthropic, em setembro de 2026, o Opus 4.7 e posteriores, o Sonnet 5 e os modelos Fable têm uma janela de 1M tokens em qualquer plano, incluindo o Pro, e a compactação automática (auto-compact) é acionada por predefinição por volta dos 967K. O Opus 4.6 e o Sonnet 4.6 sem contexto alargado têm uma janela de 200K, e a compactação é acionada no limite dos 200K. Pode definir o seu próprio limiar com o comando /autocompact, por exemplo /autocompact 500k. Quando enfia meio dia de trabalho num único chat, o contexto incha, o Claude perde o fio à meada, começa a voltar a ler os mesmos ficheiros e os tokens são consumidos 1,5 a 2 vezes mais depressa.

Na experiência descrita pelo autor, a subscrição de 200 $ é suficiente graças às 8 regras apresentadas abaixo. Sem elas, até o Max 20x se esgota antes da hora de almoço.

Regra 1. Porque é que «uma tarefa — uma conversa» poupa mais tokens?#

A regra não significa «abrir 5 chats em paralelo», mas sim «não ir buscar o chat anterior para o usar na tarefa seguinte».

Na abordagem descrita, funciona assim. A cada mensagem, o Claude vê não só o novo pedido, mas também toda a conversa anterior. Se de manhã falou de uma página de destino, depois passou para uma campanha de correio eletrónico e, a seguir, pediu-lhe para corrigir uma instrução de workshop, todo o histórico fica incluído no contexto aquando do terceiro pedido. Os tokens são gastos a «lembrar a página de destino», apesar de já se ter esquecido dela.

Porque é que «limpar a cabeça» funciona?

Feche o chat assim que a tarefa estiver concluída. Nem sequer se trata dos tokens — é uma forma de libertar a atenção.

Se a tarefa estiver mesmo concluída, não mantenha o chat aberto «para o caso de voltar a precisar dele». Abra um novo. Pode encontrar o antigo com claude --resume ou /resume, usando qualquer indicador (nome da branch, ID do PR, etiqueta).

O que deve fazer se uma tarefa se prolongar por dois dias?

Se for mesmo necessário continuar, não deixe o chat «pendurado». Antes de o fechar, peça ao Claude que escreva um prompt para um chat vizinho (ver Regra 7). Isto comprime 50K tokens de histórico num prompt de 500 tokens — e, no dia seguinte, o novo chat retoma o contexto sem ter de reescrever tudo.

Regra 2. Mantenha o CLAUDE.md com 200 linhas, não 500#

O CLAUDE.md é o primeiro ficheiro que o Claude lê quando inicia uma sessão. Esta secção trata especificamente da poupança de tokens.

Quantas linhas são normais?

Porque é que um CLAUDE.md longo torna o agente menos inteligente?

A explicação é simples: o /init descreve o repositório «de volta ao modelo», acrescentando ao contexto informação que o modelo já conhece ou consegue descobrir por si ao observar a estrutura. Esta duplicação consome tokens e dispersa a atenção.

A regra da densidade: cada palavra altera o comportamento

Se puder remover uma linha do CLAUDE.md sem alterar o comportamento do Claude, essa linha é desnecessária. Use este teste:

1. Abra o CLAUDE.md e leia cada parágrafo.
2. Pergunte a si próprio: «Se remover isto, o Claude começará a cometer erros?»
3. Se não, apague-o ou passe-o para uma Skill.

Todas as regras que só se aplicam em situações específicas devem ficar nas skills (.claude/skills/<name>/SKILL.md). O CLAUDE.md destina-se apenas ao que é necessário em todos os momentos.

Regra 3. Porque manter o plano do Claude Code num ficheiro separado?#

O Plan Mode é um modo do Claude Code ativado com Shift+Tab. Neste modo, o Claude explora a base de código, lê ficheiros e faz perguntas antes da implementação. No fluxo abaixo, separe as edições do repositório: reveja o plano proposto e guarde-o manualmente em plans/, ou saia explicitamente do Plan Mode e autorize a escrita desse ficheiro antes de iniciar um chat novo.

Porque é que um plano num ficheiro é melhor do que um plano na cabeça do Claude?

Tenho uma pasta plans/ em cada projeto. Quando começo uma tarefa:

1. Peço ao Claude, em Plan Mode, que investigue e sugira uma abordagem.
2. Revejo o plano e guardo o texto pessoalmente em plans/YYYY-MM-DD-task-name.md; em alternativa, saio do Plan Mode e autorizo o Claude a escrever esse ficheiro. Verifico o conteúdo guardado antes de fechar o chat.
3. Fecho o chat.
4. Num chat novo, digo: «lê plans/YYYY-MM-DD-...md e implementa a fase 1».

O que ganho:

• O plano fica registado — o Claude não «se esquece» do que decidimos há uma hora.
• Posso editar o plano à mão — vejo 5 passos, percebo que o passo 3 é desnecessário, apago-o e avanço.
• O plano sobrevive a um reinício — volto no dia seguinte, abro o ficheiro e continuo.
• Posso passá-lo a agentes sequencialmente — um chat escreve o plano, outro implementa-o e um terceiro revê-o.

O Plan Mode não quebra a cache

Um pormenor importante: o Plan Mode invalida apenas a cache da conversa (mensagens), enquanto o prompt de sistema e o contexto do projeto (CLAUDE.md) permanecem quentes. Isso significa que alternar para Plan Mode e voltar custa quase nada em tokens — ao contrário de mudar o modelo com /model, o que quebra a cache por 90% do preço de entrada e obriga a recalcular todo o prefixo.

A engenharia de contexto também consiste em guardar o plano num local onde perdure, e não num chat que desaparece em 5 horas.

Regra 4. As Skills são carregadas quando acionadas, não no início de uma sessão#

As Skills são carregadas em três níveis:

1. Metadados sempre — no início da sessão, o Claude vê apenas name e description de cada skill. Orçamento: ~100 tokens por skill.
2. Instruções quando acionadas — quando o utilizador diz algo relevante, o Claude carrega o corpo do SKILL.md. Orçamento: até 5000 tokens.
3. Recursos a pedido — os ficheiros incluídos (exemplos, modelos) só são carregados quando o próprio modelo os procura.

Como muda a economia dos tokens?

No exemplo descrito, as regras para escrever instruções educativas, as regras de envio de mensagens e as regras de revisão de código estavam no CLAUDE.md. O ficheiro cresceu até às 500 linhas e, no início de cada sessão, pagava por todas as 500 linhas, mesmo quando a conversa era sobre uma página de destino.

Neste exemplo, o CLAUDE.md contém 200 linhas de navegação e princípios básicos. Os 4 conjuntos de regras estão nas skills:

.claude/skills/
├── write-tutorial/SKILL.md         # trigger: “write a guide”
├── deploy-checklist/SKILL.md       # trigger: “check before publishing”
├── send-broadcast/SKILL.md         # trigger: “send a mailing”
└── debug-payment-webhook/SKILL.md  # trigger: “check the payment”

O Claude vê apenas os cabeçalhos no arranque — 400 tokens. Quando digo «escreve um guia», carrega o SKILL.md correspondente e segue-o. Quando digo «envia uma mensagem», carrega outro.

Uma citação das regras para escrever skills na documentação oficial da Anthropic:

Se uma skill parecer suspeita, não a instale

As Skills são instruções executáveis com acesso direto aos seus ficheiros e chaves de API. Antes de instalar a coleção de outra pessoa, abro todos os ficheiros SKILL.md e leio-os. Se houver blocos bash: com ligações a URLs externas, é um sinal de alerta; não a instalo.

Regra 5. Quando deve passar uma tarefa para um subagente em vez de a deixar na sessão principal?#

Da documentação oficial:

Que tarefas podem ser delegadas a subagentes?

• Pesquisar uma base de código extensa. Um subagente lê 30 ficheiros e responde «a função relevante está em src/lib/payment/cloudpayments.ts:142». Não vejo o conteúdo dos 30 ficheiros no contexto principal.
• Executar testes e analisar registos. Um subagente executa npm test, capta 200 linhas de resultados e responde «3 testes falharam em X, Y, Z por este motivo».
• Refatoração em vários ficheiros. Um subagente por ficheiro — em paralelo.
• Verificar ligações num guia. Um subagente visita 30 URLs através do WebFetch e responde «5 ligações devolvem 404».

Em maio de 2026, a Anthropic anunciou oficialmente a Multi-Agent Orchestration como funcionalidade de primeira classe. Anteriormente, só era possível iniciar subagentes em código através do SDK; agora podem ser iniciados diretamente no Claude Code através de comandos slash.

Onde é que os subagentes falham

Por isso, nunca deixo os subagentes sem supervisão durante meio dia. A regra é: quanto mais delegar em paralelo, mais frequentemente deve verificar os resultados intermédios. Em tarefas grandes, ativo o Plan Mode separadamente para cada subagente.

Regra 6. Como escolher um modelo Claude (Opus / Sonnet / Haiku) para uma tarefa?#

Preços da API (por milhão de tokens):

Fonte: página oficial da Anthropic. Os preços não são visíveis numa subscrição, mas a proporção é a mesma. O Opus 4.7 tem uma ressalva: comparado com o Opus 4.6, o seu novo tokenizer pode usar até +35% mais tokens para o mesmo texto. O preço por token não aumentou, mas o custo efetivo por pedido aumentou. Se processar tudo com Opus sem pensar, o seu limite esgota-se 5 vezes mais depressa do que se usar Sonnet ou Haiku em metade das tarefas.

Exemplo de escolha de modelo

Mude de modelo com o comando /model. Mas mudar de modelo invalida a cache. Se mudar de Sonnet para Opus a meio de uma sessão, o pedido seguinte recalcula todo o prefixo de raiz ao preço integral de entrada (não ao preço em cache). É melhor escolher o modelo no início, em vez de alternar constantemente.

/effort — uma definição menos agressiva

Em abril de 2026, a Anthropic lançou /effort — 5 níveis de profundidade de raciocínio: minimal / low / medium / high / xhigh. O Claude Code com Opus 4.7 funciona com xhigh por predefinição.

O que faço:

• Para classificação, extração de dados e resumos curtos: /effort low. Isto poupa 30-70% nos tipos de tarefa que não exigem raciocínio profundo.
• Para tarefas de programação simples: /effort medium.
• Para arquitetura complexa, mantenho xhigh.

/effort não altera o modelo, apenas a profundidade do raciocínio. A cache mantém-se intacta.

Regra 7. Passe um prompt para um chat novo em vez de usar /compact#

/compact é um comando oficial do Claude Code que substitui o histórico por um resumo. Se o executar logo após a última mensagem, enquanto a cache está quente (o TTL da subscrição é de 1 hora), o resumo fica em cache e é lido a 10% do preço normal. Se o executar ao fim de uma hora, a cache está fria e paga o preço total.

O /compact pode ser personalizado:

/compact Focus on code samples and API usage

Ou pode especificar o foco predefinido do resumo no CLAUDE.md:

# Compact instructions
When you are using compact, please focus on test output and code changes

Mas costumo fazer de outra maneira.

Passar um prompt para um chat vizinho: exemplo

Passos:

1. No chat atual, quando vejo que o contexto ultrapassou os 50%, digo: «Escreve-me um prompt para um chat vizinho que continue o trabalho sem perder o sentido. Inclui: em que estávamos a trabalhar, o que já foi feito, o que falta, os ficheiros e as constantes principais.»
2. O Claude dá-me um prompt de 300-800 tokens.
3. Fecho o chat atual com /clear ou simplesmente abro um novo.
4. Colo o prompt e começo com um CLAUDE.md e contexto do projeto quentes, mas com a memória da conversa limpa.

O que ganho em comparação com /compact:

• Controlo o que passa para o novo chat. O /compact resume segundo a sua própria interpretação; posso editar o prompt à mão antes de começar.
• Posso guardar o prompt num ficheiro plans/ e voltar a ele no dia seguinte.
• O novo chat começa com uma cache de conversa limpa — depois, trabalha-se ao preço de entrada em cache.

Quando é que o /compact é melhor?

• Quando está em Plan Mode e não quer perder o plano atual.
• Quando a tarefa é uniforme e o contexto é consistente (por exemplo, traduzir um documento longo).
• Quando o /compact é executado imediatamente após a resposta do Claude — assim, o resumo entra na cache quente e custa 10%.

/clear — último recurso

O /clear apaga tudo, incluindo o contexto do projeto. Só o uso quando passo para um tema completamente diferente e não quero conservar nada do que vinha de trás. Após o /clear, o pedido seguinte paga o preço total para carregar novamente o CLAUDE.md.

Regra 8. O que invalida a cache do Claude Code e porque é que paga por isso?#

Numa subscrição, o TTL da cache é de 1 hora (é prolongado sempre que há um acesso). Na API, o valor predefinido é de 5 minutos. Isto significa que, se regressar ao trabalho ao fim de 40 minutos, a cache continua ativa e o pedido seguinte custa cêntimos em tokens de entrada. Ao fim de 1 hora, a cache expira e paga o preço total.

O que quebra a cache (evite estas ações a meio de uma tarefa)

1. /model — mudar o modelo a meio da sessão. Cada modelo tem a sua própria cache. Depois de /model opus, o pedido seguinte recalcula todo o prefixo para o Opus de raiz.
2. Ativar o Plan Mode com a definição opusplan. Neste modo, o Plan Mode usa Opus e o modo normal usa Sonnet. Cada Shift+Tab = mudança de modelo = cache inválida.
3. Ligar / desligar um servidor MCP. Incluindo a reconexão automática após uma falha temporária. Se o servidor MCP for instável, paga duas vezes.
4. Regras de recusa com nomes simples (Bash, WebFetch) — alteram as definições das ferramentas no prompt de sistema.
5. /compact — invalida a camada da conversa (por definição).
6. Atualizar o Claude Code para uma nova versão — uma nova versão significa um novo prompt de sistema e uma nova cache.

O que NÃO quebra a cache?

• Editar ficheiros no repositório (são lidos quando necessário).
• Editar o CLAUDE.md a meio da sessão (mas as alterações só se aplicam após reiniciar — ver Regra 2).
• Alterar o estilo de saída.
• Alterar o modo de permissões (se opusplan não estiver envolvido).
• Invocar Skills / commands (adicionados à camada da conversa).
• /recap (um novo comando que cria um resumo sem invalidar a cache).
• /rewind (voltar a um prefixo já aquecido).
• Iniciar um subagente (a cache do agente principal não é afetada).

Como tirar partido da cache

• Não mude de /model sem motivo. Escolha o modelo no início da tarefa.
• Não ative 10 servidores MCP «por precaução». Cada um acrescenta conteúdo ao prompt de sistema e quebra a cache quando volta a ligar-se.
• Não edite o CLAUDE.md entre tarefas — faça todas as alterações de uma vez e reinicie depois.
• Use /recap em vez de /compact quando só precisa de consultar um resumo, e não de libertar contexto.

O que aconteceu à proposta de créditos para automatização de 15 de junho?#

A divisão proposta da subscrição em fundos interativo e programático foi suspensa. A atualização do apoio da Anthropic indica que Agent SDK, claude -p e aplicações de terceiros podem continuar a usar os limites da subscrição. Não some os valores abandonados da proposta como uma segunda fatura obrigatória.

Os créditos API mensais separados introduzidos em outubro para planos Max e Team elegíveis são um valor incluído numa organização Console associada. Não substituem os limites interativos do plano. O guia atual de créditos API distingue o início de sessão da subscrição do trabalho com chave API e identifica as interfaces de lançamento não abrangidas.

Antes de orçamentar uma tarefa agendada, registe a autenticação, a interface de lançamento, o modelo e a utilização real. Um comando claude -p, por si só, não estabelece que saldo consome. A utilização API paga adicional depende da faturação da organização. Para a explicação e calculadora atuais, consulte a faturação da automatização no Claude Code.

Um dia na vida de um vibe coder que usa o Claude Code#

Um exemplo de dia:

1. 9:00. Abro a tarefa n.º 1 — editar um modelo de email. Abro um chat novo, uso Plan Mode e peço ao Claude que investigue. O plano fica pronto em 3 minutos; passo para a aceitação automática e a edição demora 10 minutos. Fecho o chat.
2. 9:30. Tarefa n.º 2 — escrever um guia educativo. Abro um chat novo, onde é acionada a minha skill para escrever guias. Carrega 4000 tokens de metodologia. Trabalho com base nela e o guia fica pronto em 40 minutos. Concluído.
3. 11:00. Tarefa n.º 3 — um problema de arquitetura complexo. /model opus, Plan Mode, discussão. Revejo o plano, guardo-o manualmente em plans/2026-05-20-...md (ou autorizo a escrita depois de sair do Plan Mode), verifico o ficheiro e fecho o chat.
4. 12:00. Chat novo: «lê plans/2026-05-20-...md e implementa a fase 1». 6 subagentes trabalham em paralelo — um por ficheiro. A fase 1 fica pronta em 45 minutos. Fecho o chat.
5. 14:00. Tarefa n.º 4 — editar uma página de destino. /model sonnet. Chat novo. O planeamento e a implementação demoram 30 minutos. Fecho o chat.
6. 15:00. Tarefa n.º 5 — depurar a produção. /model opus, Plan Mode; é preciso aprofundar. Após uma hora de discussão, peço-lhe que escreva um prompt para um chat vizinho, com a causa identificada e a solução proposta. Copio-o para um chat novo e implemento a solução em 20 minutos.

No fim do dia: 6 tarefas, 8 chats fechados, nem um único /compact. O limite está utilizado entre 40-60%. Chega perfeitamente.

O limite esgota-se a quem:

• Enfia uma tarefa inteira num chat que já tem 50% do contexto utilizado.
• Mantém o CLAUDE.md com 600 linhas porque «pode dar jeito».
• Muda para /model opus para cada edição simples.
• Ativa 8 servidores MCP por precaução.
• Nunca usa subagentes e arrasta tudo para a conversa principal.

O limite não se esgota para quem constrói um segundo cérebro nos ficheiros do projeto e trabalha com o Claude como se fosse um engenheiro da equipa — atribui-lhe tarefas claras, não despeja tudo numa conversa e usa ferramentas diferentes para tarefas diferentes.

Pode continuar a explorar a Ailoot em ailoot.ai.