Testei 10 mods do Claude Code: só 3 merecem ficar

Os mods do Claude Code são funções TypeScript dentro de plugins que podem redesenhar a interface do Claude Code ou reescrever o que ele faz. Em um dia após o lançamento, no começo de outubro, três tours em vídeo diferentes mandaram os desenvolvedores instalarem dez deles. Dois desses criadores admitem diante da câmera que alguns mods não economizam nada, e nenhum deles mediu um único mod. Este teste mede: cada um dos dez mods hypados rodou numa semana real de trabalho, com um número para o overhead, para a economia e um veredito de ficar ou apagar. O resultado logo de cara: só três dos dez merecem um lugar na máquina de um desenvolvedor que trabalha de verdade, e um deles gasta tokens em silêncio a cada resposta.

A definição da própria Anthropic cabe num fôlego só: um mod é uma função que se conecta a um evento e pode rodar antes dele, depois dele ou no lugar dele. Um evento é uma chamada de ferramenta, um prompt enviado ou uma parte da interface sendo desenhada. Mods são TypeScript puro, distribuídos dentro de um plugin que você instala como qualquer outro.

O tweet de lançamento passou de quatro milhões de visualizações em cerca de um dia, com vinte mil curtidas e mais favoritos do que respostas e reposts somados. Dois dias após o lançamento, um catálogo da comunidade já havia escaneado mais de mil mods públicos em centenas de repositórios.

O banco de testes é uma semana real de trabalho: 85 sessões em quatro projetos, quase 900 prompts e pouco menos de 6.000 chamadas de ferramenta. Todo mod passou pela auditoria do validador, que lista o que ele conecta e no que pode mexer, e todo mod executou a mesma tarefa contra uma base limpa, na versão atual, na mesma máquina.

A divisão principal: seis dos dez não custam nada mensurável em tempo de execução, três custam tempo ou tokens de verdade, e um quebra a única promessa que faz.

Os seis quietos ficam dentro do ruído da conexão. O medidor de metas, o mapa de calor do repositório, o gravador de voo, o roteador de modelos, os marcadores de sessão e o handoff automático ficam todos entre um quarto de segundo economizado e um quinto de segundo acrescentado, numa tarefa base de cerca de quatro segundos.

Mod	Variação no tempo de execução	Observações
Medidor de metas	dentro do ruído	painel de decoração
Mapa de calor do repositório	dentro do ruído	acende os arquivos conforme são lidos
Gravador de voo	dentro do ruído	linha do tempo ao vivo do turno
Roteador de modelos	dentro do ruído	compensa em subagents, veja o veredito
Marcadores de sessão	dentro do ruído	pegada de capacidades ampla
Handoff automático	~70 ms ocioso	escreve um handoff em um limite de contexto

Eles são ótimos de ver, e nada quebrou: toda execução de toda configuração terminou a tarefa corretamente. Em modo headless não custam nada, porque não há nada para desenhar; num terminal esses painéis se redesenham até trinta vezes por segundo, então o custo honesto da categoria da decoração é atenção, não tokens.

A auditoria do validador é onde a graça acaba. O mod de marcadores pode chamar o modelo, iniciar processos na sua máquina e escrever arquivos, e lê os caminhos da sua configuração a partir do ambiente. Nada disso é escondido e nada é malicioso, mas é muito alcance para um marcador. Quatro mods saem aqui: o medidor de metas, o mapa de calor e o gravador de voo como decoração com benefício medido zero, e o mod de marcadores porque pede mais do que entrega.

O motor de sugestões é o mod que todo vídeo demonstra primeiro: sua resposta termina, três sugestões de prompt aparecem acima do campo de entrada, você aperta um número e o rascunho se preenche sozinho. O mecanismo é documentado pelo próprio autor: quando seu turno termina, ele faz um fork da sessão para pedir essas sugestões a um modelo, e o fork compartilha o prompt cache da sessão, então custa cerca de uma resposta curta. Os tours nunca mencionam essa linha.

Medido no banco de testes, isso dá cerca de 250 tokens de saída extras por resposta qualificada e quase três segundos de tempo real a mais, e uma resposta qualificada é quase toda resposta: qualquer uma com mais de uns oitenta caracteres. O fork também não tem filtro de superfície. As sugestões só são desenhadas num terminal, mas o fork dispara em qualquer lugar, inclusive em execuções headless onde nada pode ser desenhado.

Mod	Custo medido	Quando dispara
Motor de sugestões	~250 tokens de saída + ~2,9 s por resposta qualificada	toda resposta com mais de ~80 caracteres, inclusive headless
Mantenedor de cache	~1,5 s por turno, mais chamadas de modelo no modo de aquecimento	todo turno, aquecendo por horas

O mantenedor de cache tem o mesmo formato: cerca de um segundo e meio por turno, com um modo de aquecimento que gasta pequenas chamadas de modelo durante horas para impedir que seu prompt cache esfrie. Num plano de assinatura a janela de cache já é de uma hora, então você paga pings para resolver um problema que o plano já resolveu em grande parte. Os dois são designs honestos com custos documentados, os dois são impostos cobrados a cada turno que as listas de instalação nunca precificam, e os dois saem da máquina.

O Claude Code já tinha hooks: um script shell nas suas configurações que dispara nos mesmos eventos. A documentação responde à escolha numa linha de tabela: um mod serve para interface e para reescrever eventos; um hook serve para bloquear, permitir ou logar com um script que você já tem.

A diferença mensurável é o spawn de processo. Um hook nas configurações inicia um processo novo a cada chamada de ferramenta. Cronometrado nesta máquina, um hook shell que não faz nada custa cerca de 8 ms e um hook que inicia o Node, cerca de 43 ms, a cada chamada, antes mesmo de o script fazer qualquer coisa. Nas 5.993 chamadas de ferramenta da semana do teste, isso dá mais de quatro minutos só de inicialização de interpretador. Um mod não paga nada disso: o handler roda dentro do próprio processo do motor, e o log do motor mostra o salto se resolvendo em cerca de um milissegundo.

Handler	Custo por chamada	Uma semana de 5.993 chamadas
Hook shell (no-op)	~8 ms	~48 s
Hook Node (no-op)	~43 ms	~4,3 min
Mod (no mesmo processo)	~1 ms	~6 s

O único relato real de migração que existe diz a mesma coisa: vinte e sete hooks shell viraram cinco mods, e o spawn a cada chamada desapareceu junto. A regra que sobrevive: interface ou reescrita de eventos, mod; bloquear, permitir ou logar com um script em que você confia, hook, já que o custo do spawn só importa em milhares de chamadas; conhecimento que você vive repetindo, skill. Um hook que você leu vale mais do que um mod que você não leu.

O mod de segurança mais simples possível é um guarda que vigia todo comando shell, e este foi escrito para travar. Pediu-se ao Claude Code que criasse um arquivo marcador; o guarda lançou um erro; o comando rodou mesmo assim e o arquivo apareceu. Isso não é um bug, é o padrão documentado: quando um hook lança um erro, estoura o tempo limite ou devolve o formato errado, o Claude Code o ignora e segue em frente. Uma decoração quebrada não deveria travar uma sessão, mas um guarda quebrado falha aberto, em silêncio, com uma linha num log de debug que ninguém lê.

A correção é um catch handler que devolve um deny. O mesmo guarda que trava, agora com o catch, recusa o comando e nomeia a falha. Uma linha decide se um guarda falha aberto ou fechado, a documentação traz exatamente esse padrão, e quase ninguém o instala.

Uma equipe da comunidade reexecutou os casos na versão atual e julgou por arquivos marcadores em vez de pelo que o modelo disse. O padrão do catch falhou fechado três execuções em três, e um caminho continua silenciosamente quebrado: um deny devolvido depois de a chamada já ter sido encaminhada não detém a ferramenta. O arquivo foi criado três vezes em três, enquanto o modelo era informado de que a escrita havia falhado.

O relato de campo que deu nome a esse problema manteve por dias um guarda que estava ativado, carregado e sem fazer nada, porque uma flag antiga o havia desligado por baixo: três indicadores verdes sobre um contador parado em zero. Um silêncio que se parece exatamente com saúde.

O guarda de colisão conquista o primeiro "ficar". Ele resolve um problema real, dois chats abertos editando o mesmo arquivo, e seu modo de falha é barulhento: pergunta numa caixa de diálogo e nunca permite em silêncio. Custa cerca de meio segundo nas edições e não acrescenta nada ao prompt. Instale-o, e dê a ele o catch handler mesmo assim.

A Anthropic diz com todas as letras no dia do lançamento: os mods rodam com o mesmo acesso à sua máquina que o próprio Claude Code. Não ficam em sandbox; instale-os como instalaria qualquer código no seu computador. Concretamente, um mod pode agir na sua máquina como você: ler seu ambiente e suas configurações, onde ficam as chaves de API; ver cada prompt e cada chamada de ferramenta; reescrevê-los; aprovar uma chamada de ferramenta antes de você ser consultado; e gastar o uso do seu plano em chamadas de modelo próprias.

Duas armadilhas pegam até usuários cuidadosos. As regras de permissão governam as chamadas de ferramenta do Claude, não as chamadas do próprio mod: negue um arquivo env ao Claude, e um mod ainda pode ler esse arquivo diretamente com seu próprio acesso a arquivos, ou iniciar um programa que o leia. A política de rede tem o mesmo ponto cego: desligue o tráfego web e as chamadas fetch do próprio mod são recusadas, mas um processo filho iniciado pelo mod chega à rede com acesso total. Existe um mod guarda embutido que carrega antes de tudo, mas só em máquinas gerenciadas e para assentos Team ou Enterprise; um assento individual numa assinatura pessoal não recebe nada disso.

Nada disso é teórico. Um usuário publicou uma prova de conceito dias após o lançamento: um mod cujo botão inicia um programa e escreve no diretório home, instalado a partir do catálogo sem nenhum aviso, e o argumento dele se sustenta: o catálogo parece uma loja de apps, o que sugere uma verificação que não existe. Um bug separado nos hooks quebrou o isolamento dos subagents por um dia; o mantenedor chamou de um grande erro e o corrigiu uma versão depois.

O escaneamento do próprio catálogo, com mais de mil mods públicos: mais de quatrocentos iniciam processos no host, quase quatrocentos leem arquivos e mais de trezentos veem cada chamada de ferramenta. A ressalva do catálogo é o enquadramento certo: isso é uma pegada, não um veredito; um rastreador de PRs precisa rodar git. A disciplina custa dois minutos: rode o validador antes de ativar qualquer coisa e conheça as saídas: modo seguro para uma sessão, uma configuração para parar todos os hooks instalados de vez.

Dos dez, três merecem seu lugar: o guarda de colisão, o roteador de modelos e o handoff automático.

Mod	Veredito	O número por trás
Guarda de colisão	ficar	~0,5 s nas edições, falha de forma barulhenta, nada acrescentado ao prompt
Roteador de modelos	ficar	subagent cobrado no modelo barato, um terço do preço
Handoff automático	ficar	70 ms de nada, uma escrita de handoff no limite de contexto
Motor de sugestões	apagar	~250 tokens de saída + ~2,9 s em toda resposta qualificada
Mantenedor de cache	apagar	~1,5 s por turno, pings de aquecimento contra uma janela de cache de 1 hora
Modo de gravação	apagar	mascara a tela, mas não o disco
Medidor de metas	apagar	decoração, benefício medido zero
Mapa de calor do repositório	apagar	decoração, benefício medido zero
Gravador de voo	apagar	decoração, benefício medido zero
Marcadores de sessão	apagar	alcance muito além do seu trabalho

O roteador de modelos tem um recibo: uma sessão no modelo grande gerou um subagent, e o próprio relatório de uso da execução mostrou o subagent cobrado no modelo barato, um terço do preço pelo mesmo trabalho pequeno. Em semanas cheias de subagents, isso é dinheiro de verdade. O handoff automático não custa nada até o momento em que compensa: setenta milissegundos de overhead ocioso e, ao passar de um limite de contexto, ele escreve o handoff para a partida a frio, uma vez. Um dos próprios criadores da onda admite que o botão manual de handoff não economiza tempo de verdade; como escrita automática por limite, economiza.

A disciplina que sobrevive ao teste: leia a auditoria do validador antes de ativar qualquer coisa, dê a todo guarda seu catch handler para que ele falhe fechado, e grave demos em modo seguro em vez de confiar num mod de mascaramento. Os limites são reais: uma semana, uma máquina, uma carga de trabalho, três execuções por ponto no modelo pequeno. Os seus três podem ser outros, mas agora você sabe como encontrá-los.