Arquitetura ~/.claude com mais de 200 skills: como manter o system prompt em 50 mil tokens e pagar $0,15 por sessão

• Tamanho do prefixo do sistema: 40-50K tokens (CLAUDE.md 8K + rules 20-30K + descrições 15K)
• Economia com prompt caching: 10 vezes ($0,15 por sessão em vez de $1,50 sem cache)
• Velocidade de entrega da apresentação: 6 minutos e 14 segundos para 12 slides (3,8 MB em PPTX)
• Proteção contra injeções de prompt: 5 perímetros isolados e 3 bloqueios rígidos de PreToolUse

Na primavera de 2025, quando o termo "vibe coding" tinha acabado de surgir e as instalações do Claude Code ainda não tinham passado de quinze milhões, eu estava resolvendo um problema puramente de gestão. Como CPO da AlpinaGPT, eu me afogava todos os dias em dezenas de chamadas, threads de e-mail e chats de trabalho: os acordos se perdiam nas costuras entre os canais. Eu precisava de um cérebro digital funcionando 24 horas sobre uma única base vetorial, capaz de conectar por conta própria promessas feitas no Zoom a e-mails e de avisar com antecedência sobre prazos — o protótipo daquilo que mais tarde se transformou na arquitetura OpenClaw.

Um agente de terminal puro, logo ao sair da caixa, só sabe realizar operações básicas de leitura e escrita de arquivos. Para transformá-lo numa engenharia completa, ao longo de um ano de experimentos construí no diretório `~/.claude/` um sistema modular de sete camadas: um `CLAUDE.md` de navegação, regras permanentes em `rules/`, skills carregadas sob demanda em `skills/`, subagentes isolados em `agents/`, comandos slash explícitos em `commands/`, conectores externos via `mcp.json` e hooks de eventos em `hooks/`.

Por que uma biblioteca com mais de 200 skills não transborda a janela

de contexto nem explode o gasto com tokens?

O maior erro ao configurar um agente é empilhar todas as instruções no `CLAUDE.md` raiz, inchando-o até 4.000 linhas. Qualquer edição nesse monólito zera o cache de prefixo da Anthropic, obrigando a pagar o preço integral a cada etapa do diálogo. Na minha configuração, o tamanho da biblioteca de skills no disco e o tamanho do contexto ativo estão completamente desacoplados.

No início da sessão, só é carregado na memória um mapa compacto do terreno: um `CLAUDE.md` raiz de 200-300 linhas (cerca de 8K tokens), de 20 a 25 arquivos de regras básicas em `rules/` (20-30K tokens) e anotações curtas de skills e servidores MCP (outros 15K). Todo o prefixo inicial cabe em 40 a 50 mil tokens, enquanto o grosso das instruções e scripts, com cerca de 300K tokens, aguarda sua vez no disco.

Como o prefixo permanece inalterado de uma requisição para outra, o prompt caching entra em ação: a sessão sai por $0,15 em vez de $1,50, e a resposta leva de 1 a 2 segundos. A regra de ouro da operação é nunca editar arquivos em `rules/` no meio de um diálogo em andamento, e comprimir o histórico com o comando `/compact` em vez de apagá-lo por completo.

Como funciona o roteamento via routing.md e a auto-replicação de skills?

O elo que conecta toda a configuração é a tabela de roteamento `rules/routing.md`, com mais de 300 linhas, que funciona segundo o princípio "gatilho-chave → ferramenta específica". Se uma tarefa surge menos de uma vez por dia, ela não tem lugar nas regras permanentes — é empacotada como um módulo separado em `~/.claude/skills/<nome>/SKILL.md`, com scripts de trabalho dentro.

Um exemplo claro é o gerador de apresentações `manus-slides`. Quando digito no terminal um pedido de pitch para investidores com 12 slides no estilo quadro branco (`whiteboard`), o roteador identifica o gatilho com 0,94 de confiança, carrega 4,2K tokens de instrução e dispara o pipeline. O Claude monta a estrutura, envia em paralelo 12 requisições ao `gemini-3.1-flash-image-preview` e, via scripts Python, monta o arquivo final `presentation.pptx`, com 3,8 MB. O ciclo completo leva 6 minutos e 14 segundos em vez de um dia inteiro de trabalho.

Pelo mesmo princípio funciona um wrapper sobre o Telethon (`tg_client.py`, com mais de 50 comandos) para exportar analytics e menções de canais do Telegram para CSV, além do meta-skill `skill-creator`. Basta pedir uma vez ao agente para montar uma skill de leitura de extratos bancários em PDF: ele mesmo cria a pasta, escreve o frontmatter YAML com os gatilhos, coloca o script correspondente e registra a linha em `routing.md`. É exatamente essa arquitetura de máquina pessoal de IA que detalhamos na prática na [Hamidun Academy](https://academy.hamidun.com) e continuamos desenvolvendo dentro da comunidade de engenharia [Vibe Club](https://hamidun.com/club).

Como proteger um agente autônomo em modo bypassPermissions contra a

exclusão do banco de dados e injeções de prompt?

Eu trabalho no modo `bypassPermissions`, sem confirmação manual a cada passo, porque a segurança foi transferida para o nível do ambiente de execução. Quando o agente lê e-mails de terceiros, páginas da web ou código, os dados externos são sempre tratados como conteúdo não confiável, nunca como comandos.

A segurança se apoia em cinco linhas de defesa: 1. Isolamento físico das chaves: todos os segredos ficam em `~/.claude/.

credentials.master.env`, fora do repositório, e são passados aos scripts via `os.

getenv()` — o modelo nunca vê os valores reais de `TELEGRAM_API_ID` ou das chaves de pagamento no diálogo. 2. Hooks rígidos de PreToolUse: o `settings.

json` registra três interceptadores leves que retornam imediatamente `exit 1` em qualquer tentativa de chamar `rm -rf`, `DROP DATABASE` ou `DROP TABLE`. 3. Perímetro somente leitura para revisores: os subagentes de auditoria de código e segurança recebem na whitelist apenas `Read`, `Glob` e `Grep`, sem permissão de escrita nem de chamar shell.

4. Sanitização do fluxo de entrada: antes de passar o texto de um e-mail para o modelo, o script `gmail_search.py` remove construções como "ignore previous instructions", substituindo-as pela marca `[REDACTED:injection]`.

5. Testes de aceitação adversariais e delegação: antes de lançar um novo bot, eu o submeto a um conjunto de testes de ataque, e divido as tarefas entre subagentes do Nível 0 (fazer eu mesmo) ao Nível 3 (orquestrador mais workers em `git worktree`, com indicação exata de arquivo e linha).