# Limites do Claude Code em 2026: 8 regras para não esgotar os tokens
> Limites Claude Code Pro e Max em 2026 e 8 regras para poupar tokens: /compact, Plan Mode, um CLAUDE.md conciso, skills, escolha do modelo e poupança de 90% com a cache.
Source: https://ailoot.ai/blog/pt-pt/claude-code-token-limits-saving/
Canonical: https://ailoot.ai/blog/pt-pt/claude-code-token-limits-saving/
Language: pt-PT
Publisher: Ailoot (https://ailoot.ai/)
Translation: guide-129
Revision: sha256-addaf6534b534adac85a6956fa18952ce0a00ae8fa3828c1b062598f22992dfe
Pontos principais
Os limites do Claude Code esgotam-se não por causa da subscrição, mas por causa da metodologia. Na experiência descrita pelo autor, se todas as tarefas do dia forem colocadas num único chat, o contexto transborda à hora de almoço e os tokens são consumidos duas vezes mais depressa. Se iniciar uma conversa nova para cada tarefa, usar um CLAUDE.md conciso, guardar o plano num ficheiro separado e carregar Skills quando necessário, a subscrição Max de 100 $ é suficiente para um dia inteiro de vibe coding. Neste artigo, falo dos planos reais, de 8 regras para poupar tokens e do anúncio suspenso de 15 de junho de 2026 sobre automatização.
Documentação de referência da Ailoot: [ailoot.ai/docs/](https://ailoot.ai/docs/).
## Como funcionam os limites do Claude Code em 2026 e porque é que os esgota?
Pontos principais
O Pro por 20 $ oferece cerca de 45 mensagens numa janela de 5 horas, o Max 5x por 100 $ oferece cinco vezes mais e o Max 20x por 200 $ oferece vinte vezes mais. Os limites são contabilizados separadamente para a janela de 5 horas e para a semana. A Anthropic duplicou as quotas de 5 horas a 6 de maio de 2026. Com os mesmos limites, uma pessoa trabalha 8 horas enquanto outra os esgota antes da hora de almoço — a diferença está toda na metodologia.
A 20 de maio de 2026, os planos pagos do Claude Code funcionam assim:
| Plano | Preço | Janela de 5 horas (aprox.) | Particularidade |
|----|----|----|----|
| Pro | 20 $ / mês | ~45 mensagens ou 44K tokens | Básico, para experimentar |
| Max 5x | 100 $ / mês | ~225 mensagens | Acesso prioritário |
| Max 20x | 200 $ / mês | ~900 mensagens | Acesso antecipado a novos modelos |
| Team Premium | 100 $ / lugar (anual) | Max 5x por lugar | SSO, projetos partilhados |
| Enterprise | contrato | personalizado + conformidade | RBAC, residência dos dados |
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](https://www.anthropic.com/news/higher-limits-spacex): 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](https://code.claude.com/docs/en/costs):
- 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](https://code.claude.com/docs/en/model-config#extended-context), 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?
Pontos principais
A primeira regra para poupar tokens: não despeje três tarefas do dia num único chat. Cada novo tema merece uma janela nova. Quando o contexto está cheio com meio dia de conversa, o Claude volta a ler o que já sabe e gasta tokens a reter informação irrelevante. Um chat = uma tarefa dá uma cabeça limpa ao Claude e a si.
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
Pontos principais
O CLAUDE.md é carregado no início de cada sessão e permanece no contexto até ao fim. Se tiver 500 linhas, paga essas 500 linhas em tokens em todas as sessões. A Anthropic recomenda oficialmente que não ultrapasse 200.
[O CLAUDE.md é o primeiro ficheiro que o Claude lê](https://ailoot.ai/blog/pt-pt/claude-md-template/) quando inicia uma sessão. Esta secção trata especificamente da poupança de tokens.
### Quantas linhas são normais?
| Abordagem | Linhas | Onde funciona |
|----|----|----|
| Recomendação oficial da Anthropic | até 200 | Repositório médio |
| Gerado automaticamente com `/init` | varia | Mais frequentemente piora os resultados do que os melhora |
### 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](https://ailoot.ai/blog/pt-pt/claude-code-skills-library/).
Todas as regras que só se aplicam em situações específicas devem ficar nas skills (`.claude/skills//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?
Pontos principais
O planeamento é uma fase só de leitura: o Claude não escreve código, apenas investiga e propõe uma abordagem. Depois da aprovação, escolho explicitamente o modo de permissões para implementação. Guardo o meu plano num ficheiro separado na pasta `plans/` e forneço-o ao chat como contexto para a implementação. Isto poupa o recurso mais caro — o retrabalho quando a direção inicial estava errada.
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
Pontos principais
As [Claude Code Skills](https://ailoot.ai/blog/pt-pt/claude-code-skills-library/) são pastas com um ficheiro SKILL.md que o Claude só vê quando são relevantes para a tarefa. O CLAUDE.md é sempre carregado; uma skill só é carregada quando a respetiva descrição corresponde ao seu pedido. É por isso que um projeto pode conter dezenas de skills sem sobrecarregar o contexto — o prompt de arranque inclui apenas um pequeno cabeçalho com o nome e a descrição de cada skill.
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.
As instruções completas só são carregadas quando o Claude decide que uma skill é relevante (menos de 5k tokens). Os scripts e ficheiros auxiliares só são carregados quando são explicitamente necessários. Isto significa que pode ter dezenas de skills instaladas sem afetar o desempenho em tarefas não relacionadas.
— Documentação Anthropic Skills, https://code.claude.com/docs/en/skills
### 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](https://code.claude.com/docs/en/skills):
Depois de uma skill ser carregada, o seu conteúdo permanece no contexto nos turnos seguintes, por isso cada linha é um custo recorrente em tokens. Escreva o que fazer, não uma recapitulação do como e do porquê.
— Documentação Anthropic Skills, https://code.claude.com/docs/en/skills
### 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?
Pontos principais
Um subagente é uma sessão Claude separada, com a sua própria janela de contexto, prompt de sistema e conjunto de ferramentas. Só o resultado final regressa ao agente principal — todo o «ruído» de ler 50 ficheiros e analisar 10K linhas de registos permanece no contexto do subagente. Isto poupa até 90% dos tokens nos tipos de tarefa que, de outro modo, encheriam o contexto da sessão principal com pesquisas exploratórias.
Da [documentação oficial](https://code.claude.com/docs/en/costs):
Delegue operações extensas em subagentes para que os respetivos resultados detalhados permaneçam no seu contexto e apenas o resultado regresse à conversa principal.
— Documentação Claude Code, https://code.claude.com/docs/en/costs
### 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](https://claude.com/blog/code-w-claude-sf-2026-sf) 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?
Pontos principais
O Opus 4.7, o Sonnet 4.6 e o Haiku 4.5 diferem no preço cerca de 5-15 vezes. O Opus custa dez vezes mais do que o Haiku, mas não é dez vezes mais inteligente em 90% das tarefas. A regra é simples: use o Opus apenas quando precisar de tomar uma decisão arquitetural profunda ou fazer uma refatoração complexa. O Sonnet é a opção predefinida para o trabalho habitual. O Haiku serve para pesquisas, classificações e consultas simples.
Preços da API (por milhão de tokens):
| Modelo | Entrada | Saída | Entrada em cache |
|------------|-------|--------|--------------|
| Opus 4.7 | 5 $ | 25 $ | 0,50 $ |
| Sonnet 4.6 | 3 $ | 15 $ | 0,30 $ |
| Haiku 4.5 | 1 $ | 5 $ | 0,10 $ |
Fonte: [página oficial da Anthropic](https://platform.claude.com/docs/en/about-claude/pricing). 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
| Tarefa | Modelo | Motivo |
|----|----|----|
| Decisão arquitetural, nova secção de produto | Opus 4.7 | É necessária profundidade |
| Escrever um componente com uma especificação clara | Sonnet 4.6 | Predefinição |
| Corrigir um erro tipográfico, mudar o nome de uma variável | Sonnet 4.6 ou Haiku 4.5 | Edição simples |
| Encontrar um ficheiro a partir de uma descrição, encaminhar ficheiros | Haiku 4.5 | Barato |
| Tradução de texto, classificação, resumo | Haiku 4.5 | Um modelo simples dá conta do trabalho |
| Rever o próprio código | Sonnet 4.6 | Predefinição |
| Investigar um erro complexo que exige raciocínio em várias etapas | Opus 4.7 | São necessárias cadeias de raciocínio |
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`](https://code.claude.com/docs/en/changelog) — 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`
Pontos principais
O `/compact` comprime o histórico do chat num resumo — mas quebra a cache da conversa e consome tokens para gerar o próprio resumo. Tenho um truque melhor: peço ao Claude que escreva um prompt para um chat vizinho com a tarefa e o contexto, copio o prompt para um chat novo e começo com um prefixo quente. Isto comprime 50K tokens de histórico num prompt de 500 tokens.
`/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:
```bash
/compact Focus on code samples and API usage
```
Ou pode especificar o foco predefinido do resumo no CLAUDE.md:
```markdown
# 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?
Pontos principais
O Claude Code aplica um desconto de 90% ao preço de entrada através da cache — os tokens em cache custam 10% do preço normal de entrada. A cache dura 1 hora numa subscrição (5 minutos por predefinição na API). Mas qualquer edição do prompt de sistema ou do contexto do projeto quebra a cache e obriga a recalcular todo o prefixo. Este conhecimento poupa-me dinheiro todos os dias: se vejo que um pedido curto consumiu de repente uma enorme quantidade de tokens, isso significa que quebrei a cache algures pelo caminho.
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.
A maior parte do tempo gasto na compactação é dedicada a gerar o resumo, não a uma falha de cache.
— Documentação Claude Code, https://code.claude.com/docs/en/prompt-caching
### 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](https://support.claude.com/en/articles/15036540-use-the-claude-agent-sdk-with-your-claude-plan) 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](https://support.claude.com/en/articles/17154008-monthly-api-credits-for-max-and-team-plans) 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](https://ailoot.ai/blog/pt-pt/claude-code-pricing-automation-billing/).
## Um dia na vida de um vibe coder que usa o Claude Code
Pontos principais
Se as 8 regras funcionarem em conjunto, a subscrição Max 5x de 100 $ é suficiente para 8-10 horas de vibe coding por dia. O limite não se esgota porque cada chat trata de uma tarefa, o CLAUDE.md é conciso, o plano fica guardado num ficheiro, as skills são carregadas quando necessário, o trabalho pesado é delegado a subagentes, o modelo é escolhido para a tarefa, a transição entre tarefas é feita através da passagem de um prompt e não se muda de /model nem de MCP a meio de uma sessão.
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.
### Fontes
- [Anthropic - Limites mais elevados e acordo com a SpaceX (6 de maio de 2026)](https://www.anthropic.com/news/higher-limits-spacex)
- [Documentação Claude Code - Otimização de custos](https://code.claude.com/docs/en/costs)
- [Documentação Claude Code - Janela de contexto e compactação automática por modelo](https://code.claude.com/docs/en/model-config#extended-context)
- [Documentação Claude Code - Cache de prompts](https://code.claude.com/docs/en/prompt-caching)
- [Documentação Claude Code - Skills](https://code.claude.com/docs/en/skills)
- [Documentação Claude Code - Registo de alterações](https://code.claude.com/docs/en/changelog)
- [Preços da API Anthropic](https://platform.claude.com/docs/en/about-claude/pricing)
- [Anthropic Code with Claude SF 2026 - resumo da apresentação principal](https://claude.com/blog/code-w-claude-sf-2026-sf)
Pode continuar a explorar a Ailoot em [ailoot.ai](https://ailoot.ai/).
## Perguntas frequentes
### Como guardo um plano se ainda estiver em Plan Mode?
Reveja o plano e copie-o manualmente para o ficheiro em `plans/` do projeto, ou saia explicitamente do Plan Mode e autorize essa escrita. Verifique o conteúdo guardado antes de fechar a sessão para que o chat seguinte carregue o ficheiro real.
### O que deve incluir uma passagem de contexto para um chat novo?
Inclua a tarefa, o trabalho concluído e restante, os ficheiros principais e as decisões. Guarde primeiro o plano aprovado ou a passagem de contexto e forneça depois o caminho ao chat novo; um resumo curto só é útil se preservar a informação necessária para continuar.
## 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.