Claude Code Vazou: Arquitetura Interna Revelada

No dia 31 de março de 2026, um desenvolvedor da Solayer Labs descobriu algo que a Anthropic gostaria que permanecesse privado: o código-fonte completo do Claude Code, sua ferramenta de IA para engenharia de software, estava acessível publicamente. Não foi um ataque sofisticado. Não foi um hacker infiltrado. Foi um erro humano simples — um arquivo .map deixado acidentalmente em um pacote npm — que expôs 512 mil linhas de TypeScript para qualquer pessoa com conhecimento técnico básico.

O que torna esse vazamento particularmente interessante não é apenas o fato de que aconteceu, mas o que ele revela sobre como a Anthropic constrói suas ferramentas de IA. Dentro daquele código estão decisões arquiteturais, padrões de design e soluções técnicas que definem a experiência de milhares de desenvolvedores usando Claude Code diariamente. Para CTOs e engenheiros que trabalham com IA em produção, esse vazamento é uma aula gratuita sobre como construir sistemas agentic escaláveis. Neste artigo, vamos dissecar o que foi vazado, o que isso significa para a segurança de suas ferramentas de IA e quais lições práticas você pode aplicar imediatamente no seu próprio código.

O Que Exatamente Vazou e Por Quê?

O Claude Code é a ferramenta de linha de comando oficial da Anthropic que permite aos desenvolvedores interagir com Claude diretamente do terminal para tarefas de engenharia de software. Você pode editar arquivos, executar comandos bash, buscar em codebases, gerenciar workflows git — tudo através de linguagem natural. É, essencialmente, um pair programmer de IA que vive no seu terminal.

No dia 31 de março, o desenvolvedor Chaofan Shou descobriu que o arquivo .map do Claude Code estava disponível publicamente no npm registry. Para quem não está familiarizado, source maps são arquivos que funcionam como um 'dicionário de tradução'. Quando você publica um pacote npm, o código é comprimido e combinado em arquivos menores (minificação e bundling). O source map mapeia esse código comprimido de volta ao código original legível — essencial para debugging. Apesar de serem essenciais durante o desenvolvimento, nunca — absolutamente nunca — devem ser incluídos em pacotes de produção publicados.

A Anthropic confirmou que o vazamento foi causado por erro humano na configuração de build. Alguém esqueceu de adicionar .map ao arquivo .npmignore, ou deixou de configurar corretamente o campo files no package.json. Em poucas horas, o código foi replicado em repositórios públicos do GitHub e analisado por milhares de programadores. Hoje, qualquer pessoa pode clonar o repositório e estudar a arquitetura completa do Claude Code.

A Anthropic afirmou que nenhum dado sensível foi exposto — sem chaves de API, sem dados de clientes, sem segredos. Tecnicamente, isso é verdade. Mas o código-fonte em si é um ativo valioso, e sua exposição levanta questões importantes sobre segurança de supply chain e como empresas de IA gerenciam seus ativos proprietários.

A Arquitetura Revelada: Como Claude Code Realmente Funciona

O que torna esse vazamento "educacionalmente" valioso é o que ele revela sobre as decisões arquiteturais da Anthropic. O código vazado contém aproximadamente 1.900 arquivos TypeScript e 512 mil linhas de código. Não é um projeto simples. É um sistema de produção pesado, altamente arquitetado, que qualquer engenheiro respeitaria estudar.

A primeira coisa que salta aos olhos é a escolha de runtime. A Anthropic não usa Node.js. Usa Bun, um runtime JavaScript mais recente que oferece inicialização mais rápida e melhor eliminação de código morto através de feature flags. Para uma ferramenta de CLI que precisa responder instantaneamente quando você digita um comando, essa escolha faz sentido. Cada milissegundo importa quando você está esperando que um agente de IA execute uma tarefa.

A interface de usuário no terminal é construída com React e Ink, uma biblioteca que permite escrever componentes React que renderizam no terminal em vez de no navegador. Isso significa que a UI do Claude Code é component-based, com gerenciamento de estado, assim como uma aplicação web moderna. É uma escolha arquitetural ousada que mostra como a Anthropic pensa sobre experiência do usuário mesmo em ambientes de linha de comando.

Mas a parte mais interessante está no sistema de ferramentas. O Claude Code implementa uma arquitetura baseada em plugins com aproximadamente 40 ferramentas discretas. Cada ferramenta — ler arquivo, executar bash, buscar na web, integração com LSP (Language Server Protocol), integração com MCP (Model Context Protocol) — é uma unidade independente com suas próprias permissões e contexto de execução. O arquivo de definição base de ferramentas tem 29 mil linhas de TypeScript. Isso não é um wrapper simples ao redor de uma API. É um sistema de permissões sofisticado.

O motor de query, que orquestra todas as chamadas à API do Claude e gerencia streaming, caching e orquestração, tem 46 mil linhas. É o cérebro da operação. Ele decide como quebrar tarefas complexas, como cachear resultados, como fazer retry de falhas, como gerenciar contexto através de múltiplas interações. Esse módulo sozinho é maior que muitos projetos inteiros de startups.

Talvez o mais revelador seja o sistema de memória persistente. O Claude Code armazena contexto sobre você, seus projetos e suas preferências em um diretório de memória baseado em arquivos. Isso permite que o agente "lembre" de decisões anteriores, padrões de código que você prefere, estruturas de projeto que você usa. É uma abordagem elegante para manter estado sem depender de um banco de dados centralizado. Quando você volta ao Claude Code dias depois, ele sabe exatamente em que contexto você estava trabalhando.

E há suporte para multi-agent orchestration. O Claude Code pode spawnar sub-agentes — eles chamam de "swarms" — para lidar com tarefas complexas e paralelizáveis. Cada agente roda em seu próprio contexto com permissões específicas de ferramentas. Isso permite que o sistema decomponha problemas grandes em problemas menores que podem ser resolvidos em paralelo, acelerando significativamente a execução de tarefas complexas.

Implicações de Segurança: O Que Isso Significa Para Você

Agora, a pergunta prática: por que você deveria se importar com a arquitetura interna do Claude Code? Porque entender como um sistema funciona internamente é o primeiro passo para entender como explorá-lo ou defendê-lo.

Com acesso ao código-fonte, um agente mal-intencionado pode estudar exatamente como o Claude Code valida inputs, como executa comandos, como gerencia permissões. Pode procurar por edge cases, por brechas lógicas, por formas de contornar as proteções de segurança. Pode tentar injetar prompts maliciosos que exploram comportamentos específicos do sistema. Pode estudar como o sistema de memória funciona e tentar envenenar esse contexto com dados maliciosos.

Isso não significa que o Claude Code é inseguro. Significa que a superfície de ataque é agora conhecida. A Anthropic terá que ser mais cuidadosa em futuras atualizações, sabendo que qualquer vulnerabilidade será descoberta rapidamente por pesquisadores de segurança — ou por atores maliciosos. É como publicar o mapa de uma fortaleza: você não está necessariamente fraco, mas agora todos sabem onde estão as portas.

Para você como desenvolvedor ou CTO, a lição é diferente. Se você está usando Claude Code em produção, você deveria estar ciente de que o código que roda localmente é agora público. Isso não é necessariamente um problema — muitas ferramentas open source são públicas — mas muda o cálculo de risco. Se você está usando Claude Code para tarefas sensíveis, você deveria considerar sandboxing adicional, auditoria de logs, e monitoramento de quais comandos estão sendo executados.

Lições de DevSecOps: Como Isso Não Deveria Ter Acontecido

O vazamento do Claude Code é um case study perfeito em como build pipelines podem falhar silenciosamente. A Anthropic é uma empresa de IA de ponta, com engenheiros brilhantes, com bilhões em funding. E ainda assim, um arquivo .map foi publicado acidentalmente. Isso não é uma crítica pessoal — é uma crítica ao estado atual da engenharia de software em 2026, onde confiamos demais em automação sem verificação humana.

A lição número um é simples: source maps são código-fonte. Nunca, absolutamente nunca, inclua-os em pacotes de produção. Se você está usando npm, configure seu .npmignore explicitamente. Não confie em defaults. Aqui está o que você deveria ter:

.map
*.map
.env
.env.local
.git
.gitignore
node_modules
dist
build
src
tests

Melhor ainda, use o campo files no package.json para fazer uma whitelist explícita do que deve ser incluído. Isso é mais seguro que uma blacklist, porque você está dizendo exatamente o que DEVE estar lá, em vez de tentar adivinhar o que NÃO deve estar.

{
  "files": [
    "dist",
    "package.json",
    "README.md"
  ]
}

A lição número dois é: audite seus publishes. Antes de publicar um pacote npm, rode npm pack --dry-run. Isso mostra exatamente o que será incluído no pacote. Leia a lista. Procure por arquivos que não deveriam estar lá. Se você vir .map, .ts, .env, ou qualquer coisa que pareça código-fonte, pare e corrija. Cinco minutos de trabalho manual que teria evitado o vazamento da Anthropic.

A lição número três é: automatize essas verificações. Adicione um hook de pre-publish no seu CI/CD que verifica se há source maps, se há arquivos .env, se há código-fonte. Falhe o build se encontrar algo suspeito. A Anthropic provavelmente teria evitado esse vazamento se tivesse um script simples que verificava a saída do build antes de publicar. Aqui está um exemplo básico:

#!/bin/bash
if find dist -name "*.map" | grep -q .; then
  echo "❌ Erro: Source maps encontrados no build!"
  exit 1
fi
echo "✅ Verificação de segurança passou"

A lição número quatro é: mantenha humanos no loop. Mesmo com automação perfeita, alguém deveria revisar manualmente o que está sendo publicado. Não é paranoia. É profissionalismo. A Anthropic tinha automação, mas ninguém verificou manualmente antes de publicar.

O Que Você Pode Aprender Com a Arquitetura do Claude Code

Além das lições de segurança, o código vazado oferece insights valiosos sobre como construir ferramentas de IA escaláveis. Se você está construindo um agente de IA, um wrapper ao redor de um LLM, ou qualquer sistema que orquestra chamadas a modelos, há padrões aqui que valem a pena estudar.

O sistema de ferramentas discretas com permissões é particularmente elegante. Em vez de dar ao agente acesso irrestrito a tudo, cada ferramenta é uma unidade com seu próprio escopo de permissões. Isso reduz a superfície de ataque e torna mais fácil auditar o que o sistema pode fazer. Se você está construindo um agente que roda em produção, considere implementar algo similar. Você ganha segurança, auditabilidade e controle fino sobre o que o agente pode fazer.

O sistema de memória persistente baseado em arquivos é outra lição valiosa. Não é um banco de dados complexo. Não é Redis. É arquivos no disco. Mas funciona. Permite que o agente mantenha contexto entre sessões sem depender de infraestrutura centralizada. Para muitos casos de uso, isso é suficiente e muito mais simples que alternativas mais sofisticadas. Você ganha simplicidade operacional sem sacrificar funcionalidade.

A escolha de usar Bun em vez de Node.js é uma decisão pragmática sobre performance. Se você está construindo ferramentas de CLI que precisam ser rápidas, considere alternativas ao Node.js. Bun, Deno, ou até linguagens compiladas como Go ou Rust podem ser mais apropriadas. A Anthropic escolheu Bun porque cada milissegundo importa quando você está esperando que um agente execute uma tarefa.

O uso de Zod para validação em todo o codebase mostra uma abordagem rigorosa a type safety. Não é apenas TypeScript — é validação em runtime de todos os inputs. Isso reduz bugs e torna o sistema mais robusto. Se você está construindo APIs ou sistemas que recebem dados de múltiplas fontes, considere fazer o mesmo.

O Que Vem Depois

A Anthropic confirmou que está implementando medidas para evitar que isso volte a acontecer. Provavelmente significa auditorias mais rigorosas de build pipelines, verificações automatizadas, e talvez até mudanças na forma como publicam pacotes npm. Eles aprenderam a lição cara.

Para o resto de nós, a lição é clara: invista em segurança. É muito importante. Seu código-fonte é um ativo valioso. Proteja-o. Audite seus builds. Automatize suas verificações. E se você está usando ferramentas de IA em produção, entenda como elas funcionam internamente — porque em algum momento, alguém mais vai entender também.

📚 Referências Bibliográficas

Tecnoblog - Anthropic vaza acidentalmente o código-fonte do Claude Code

DEV Community - Claude Code's Entire Source Code Was Just Leaked via npm Source Maps

Fortune - Anthropic left details of unreleased AI model in unsecured database

The Hacker News - Claude Code Flaws Allow Remote Code Execution and API Key Exfiltration

GitHub - Claude Code Unofficial Source Extraction

Se você quer fazer parte dessa discussão sobre segurança, arquitetura e o futuro da IA em produção, inscreva-se na nossa newsletter. Somos um grupo de CTOs e engenheiros que pensam profundamente sobre como construir sistemas de IA escaláveis e seguros.