Como impedir que o Claude Code invente informações quando não sabe a resposta (Configuração exata incluída)

O Claude Code mente para você todos os dias. Funções inventadas, imports falsos, "testes passaram" quando nada foi executado. A solução é uma configuração de 4 camadas que torna a mentira cara.

O Claude diz que o bug está corrigido. Duas horas depois, você descobre que a função que ele chamou nunca existiu.

A maioria dos desenvolvedores aprende a verificar tudo duas vezes e culpar o modelo. A verdadeira solução pega cada mentira antes que ela saia da sua máquina.

Aqui está a configuração completa para honestidade 👇

Por que o Claude inventa coisas em primeiro lugar

O Claude é um preditor de texto. Quando ele não sabe algo, ele prevê um texto que parece correto. Nomes de funções inventados parecem reais. Bobagens ditas com confiança soam iguais a verdades ditas com confiança.

Você não consegue diferenciar até que seu código quebre duas horas depois, de uma forma que leva mais uma hora para depurar.

A solução não é um modelo mais inteligente. É tornar a saída do Claude verificável em tempo real e tornar "não sei" mais barato do que adivinhar.

4 camadas abaixo. Juntas, elas reduzem a fabricação a praticamente zero.

Camada 1: As regras de honestidade no CLAUDE.md

A primeira camada é um conjunto de regras no CLAUDE.md que dizem exatamente quando e como o Claude deve admitir incerteza. Coloque isso na raiz do seu projeto:

1## Regras de honestidade (leia a cada turno)
2
3Antes de afirmar que uma função, classe ou import existe, verifique lendo
4o arquivo ou executando um grep. Nunca invente símbolos.
5
6Se você não puder verificar algo, diga "Não verifiquei isso" explicitamente.
7Não escreva código que dependa da afirmação não verificada.
8
9Se uma tarefa pedir para usar uma biblioteca que você nunca viu referenciada
10neste projeto, pergunte antes de adicioná-la.
11
12Se uma tarefa envolver testes ou builds, não afirme sucesso a menos que você
13tenha realmente executado o comando de teste ou build nesta sessão.
14
15Nunca invente mensagens de erro, respostas de API ou stack traces. Se você
16não os viu, diga isso.
17
18Quando você realmente não sabe, a resposta correta é "Não sei" ou
19"Preciso verificar primeiro." Ambas são melhores do que um palpite confiante.

Essas regras parecem óbvias.

Não são, porque por padrão o Claude é otimizado para parecer útil, e "não sei" parece inútil a menos que você lhe dê permissão explícita.

A última linha é a mais importante. É a licença para "não sei", e a maioria das pessoas nunca a concede.

Camada 2: O padrão de verificação antes de escrever

A segunda camada força o Claude a verificar antes de escrever. Adicione isso ao CLAUDE.md sob as regras de honestidade:

1## Protocolo de verificação
2
3Antes de escrever ou editar código que use um símbolo (função, classe, tipo,
4constante), faça um dos seguintes:
5
61. Leia o arquivo onde ele está definido e confirme a assinatura
72. Execute `grep -r "nomeDoSimbolo" .` ou use a ferramenta Glob para encontrá-lo
83. Verifique package.json, requirements.txt, Cargo.toml ou equivalente para
9   a dependência
10
11Se você pular a verificação, prefixe o código com um comentário:
12`// NÃO VERIFICADO: Não confirmei que este símbolo existe`
13
14O modo planejar-depois-executar é preferido para qualquer tarefa que envolva
15mais de um arquivo. Use Shift+Tab para entrar no modo de planejamento antes de começar.

Isso custa algumas chamadas de ferramenta extras ao Claude por sessão. Economiza as horas que você gastaria depurando chamadas de função falsas.

Camada 3: Os hooks que pegam mentiras em tempo real

A terceira camada são hooks no settings.json que executam um verificador de tipos ou linter toda vez que o Claude escreve um arquivo. Se o Claude inventou um import, o verificador falha instantaneamente, e o Claude tem que corrigi-lo antes de afirmar que a tarefa está concluída.

1{
2  "hooks": {
3    "PostToolUse": [
4      {
5        "matcher": "Write(*.ts|*.tsx)|Edit(*.ts|*.tsx)",
6        "hooks": [
7          { "type": "command", "command": "npx tsc --noEmit --pretty false 2>&1 | head -20" }
8        ]
9      },
10      {
11        "matcher": "Write(*.py)|Edit(*.py)",
12        "hooks": [
13          { "type": "command", "command": "ruff check --quiet $file && pyright $file 2>&1 | head -20" }
14        ]
15      },
16      {
17        "matcher": "Write(*.rs)|Edit(*.rs)",
18        "hooks": [
19          { "type": "command", "command": "cargo check --message-format=short 2>&1 | head -20" }
20        ]
21      }
22    ]
23  }
24}

A saída do hook volta para o Claude como contexto. Se o tsc disser "Não é possível encontrar o módulo 'foo'", o Claude vê imediatamente e corrige o import fabricado. Nenhum código inventado sobrevive a uma verificação PostToolUse.

Para tarefas que envolvem testes, adicione um hook Stop que execute a suíte antes que o Claude possa declarar a sessão concluída:

1"Stop": [
2  {
3    "hooks": [
4      { "type": "command", "command": "npm test 2>&1 | tail -30" }
5    ]
6  }
7]

Agora o Claude não pode dizer "pronto, testes passaram" sem realmente executá-los. O hook os executa.

O resultado volta para o Claude. Se falharem, o Claude tem que corrigi-los ou admitir que não passaram.

Camada 4: O subagente verificador de fatos

A quarta camada é um subagente cujo único trabalho é revisar as afirmações do Claude antes de serem enviadas.

Coloque isso em .claude/agents/fact-checker.md:

1---
2name: fact-checker
3description: Use este agente depois que o Claude fizer afirmações sobre o que o código faz, quais testes passaram ou o que uma biblioteca suporta. Invoque antes de qualquer commit, antes de qualquer resumo para o usuário e depois de qualquer tarefa que envolva novas dependências.
4tools: Read, Grep, Glob, Bash
5model: sonnet
6---
7
8Você verifica afirmações, você não escreve código.
9
10Quando invocado, faça o seguinte:
11
121. Identifique todas as afirmações factuais na conversa recente. Exemplos:
13   "a função X faz Y", "os testes passaram", "a biblioteca Z suporta W",
14   "este import está correto".
15
162. Para cada afirmação, verifique-a independentemente:
17   - Afirmações de código: leia o arquivo real e confirme
18   - Afirmações de teste: execute os testes você mesmo
19   - Afirmações de biblioteca: verifique o pacote real ou sua documentação
20   - Afirmações de import: confirme que o pacote está no manifesto de dependências
21
223. Produza um relatório:
23   - VERIFICADO: afirmação, evidência (arquivo:linha ou saída de comando)
24   - ERRADO: afirmação, o que é realmente verdade
25   - NÃO VERIFICÁVEL: afirmação, por que você não pôde verificar
26
27Nunca aceite afirmações "confie em mim". Nunca faça afirmações próprias. Se você
28não puder verificar, a saída correta é NÃO VERIFICÁVEL.

Invoque este agente antes de commits ou antes de compartilhar resultados com sua equipe. Ele pega as mentiras que as outras 3 camadas perderam.

A licença para "não sei"

O Claude foi treinado para ser útil, e admitir ignorância parece inútil. Então ele adivinha, e o palpite parece correto.

A solução é conceder permissão para não saber. O CLAUDE.md é metade disso. Sua reação é a outra metade. Recompense "não verifiquei isso" com paciência e você terá um Claude honesto em todas as sessões. Puna com frustração e o Claude volta a adivinhar.

Não é uma configuração, é um hábito. A correção mais subestimada em toda a pilha.

Como saber se está realmente funcionando

Três sinais em suas sessões diárias.

O Claude pergunta antes de adicionar dependências. "Devo adicionar X ou usar a stdlib?" em vez de um silencioso npm install.

O Claude referencia arquivo:linha quando fala sobre código existente. "validateToken em src/auth/middleware.ts:47 faz Y" em vez de "a função validateToken faz Y."

O tsc e seu linter param de gritar. Os hooks pegam as raras fabricações instantaneamente e o Claude se autocorrige, então, quando você olha, as mentiras já se foram.

Não está vendo isso depois de um ou dois dias? Uma camada não foi carregada. Geralmente o CLAUDE.md, local errado ou nome errado.

Erros comuns que mantêm o Claude mentindo

CLAUDE.md muito longo. O Claude lê a primeira parte e passa o olho pelo resto. Coloque as regras de honestidade nas primeiras 50 linhas.

Hooks registram silenciosamente. Se a saída não chegar ao stdout, o Claude não sabe que mentiu. Certifique-se de que a saída do hook volte para a sessão.

Você pula o modo de planejamento. É onde o Claude expõe suposições erradas antes de escrever. Pule-o e você pula o momento mais barato para pegar mentiras.

Você não chama o verificador de fatos. Um subagente só funciona se você realmente o invocar. Torne @fact-checker parte do seu fluxo de commit.

Você reage mal ao "não sei." Puna a honestidade uma vez e o Claude volta a adivinhar. As outras 3 camadas não se mantêm sem esta.

A auditoria de honestidade de 5 minutos

1 minuto: copie as regras de honestidade do CLAUDE.md e o protocolo de verificação para a raiz do seu projeto.

1 minuto: copie o bloco de hooks para ~/.claude/settings.json ou .claude/settings.json.

2 minutos: crie .claude/agents/fact-checker.md com o modelo acima.

1 minuto: execute uma tarefa que você normalmente verificaria duas vezes. Observe a saída do tsc voltando para o Claude. Confirme que o Claude diz "verificado" ou "não verifiquei isso" explicitamente.

Pronto. A fabricação cai de "a cada duas sessões" para "rara e pega imediatamente." O modelo não ficou mais inteligente. Sua configuração sim.

Obrigado por ler!