How to Keep Claude Code Honest: 4 Essential Configurations

Claude Code can sound confident while generating code that never existed, fabricating imports, API responses, or test outcomes. When developers trust these hallucinations, they may spend minutes chasing non‑existent symbols.

Four‑layer configuration to curb hallucinations

The solution is not a smarter prompt but a set of engineering constraints applied at four levels: embed honesty rules, verify symbols before writing, run automatic checks after each file change, and add an independent fact‑checking sub‑agent.

Layer 1 – Honesty rules in CLAUDE.md

Place a concise set of rules at the top of the project’s CLAUDE.md file, for example:

## Honesty rules

Before claiming a function, class, type, import, file, command, API, or test result exists, verify it first.
If you have not verified something, say "I have not verified this".
Do not write code that depends on an unverified claim.
Do not claim tests, builds, lint, or type checks passed unless you actually ran the command in this session and saw the result.
Never invent error messages, stack traces, API responses, package names, or file paths. If you did not see it, say so.
When you genuinely do not know, say "I do not know yet" and check first.

These rules shift the default behavior from “guess and assert” to “acknowledge uncertainty”.

Layer 2 – Verification before writing

Add a verification protocol to CLAUDE.md that requires the model to perform at least one of the following before using a symbol:

## Verification protocol

Before writing or editing code that uses a symbol, do at least one:
1. Read the file where the symbol is defined and confirm its signature.
2. Search the repo for the exact symbol name.
3. Check the dependency manifest before using a package.
4. If the claim depends on runtime behavior, run the relevant command.

If verification is skipped, label the claim as unverified instead of presenting it as fact.

Example: before inserting import { validateToken } from "@/lib/auth", the model should search for validateToken, confirm the file exists, and verify the signature with TypeScript or the appropriate language server.

Layer 3 – Hooks to surface false code immediately

Configure a PostToolUse hook in the Claude settings so that after any Write or Edit operation the tool runs a fast verification command. A minimal example:

{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Write|Edit",
        "hooks": [
          {
            "type": "command",
            "command": "npm run typecheck 2>&1 | head -80"
          }
        ]
      }
    ]
  }
}

Choose the command that best reveals errors for your stack. Typical choices:

TypeScript: npm run typecheck or npx tsc --noEmit Frontend: npm run lint and key page tests

Python: ruff check, pyright, core unit tests

Rust: cargo check Go: go test ./... or package‑specific tests

The hook’s purpose is not to run every test on every change but to feed the model concrete feedback (error messages, failed type checks) that it can incorporate into its next step.

Layer 4 – Dedicated fact‑checker sub‑agent

Create a sub‑agent (e.g., .claude/agents/fact-checker.md) whose sole job is to verify claims about code, tests, dependencies, and documentation. A sample definition:

---
name: fact-checker
description: Verify claims about code, tests, dependencies, and docs.
tools: Read, Grep, Glob, Bash
---

You verify claims. You do not write code.

For each factual claim, verify independently:
- Code claims: read the file and cite file path or line.
- Test claims: run the command or mark it unverified.
- Dependency claims: check package.json or equivalent manifest.
- API claims: check local docs, package docs, or source.

Report each claim as VERIFIED, WRONG, or UNVERIFIABLE.
Do not accept prior assistant claims as evidence.

Run this agent at key moments—before a commit, after a complex bug fix, or when a new dependency is added—to ensure every conclusion is backed by observable evidence.

Together, the four layers transform Claude Code from a pure text generator into a collaborator constrained by the project’s actual state, making its output verifiable and trustworthy.

Quick five‑minute rollout

Minute 1: add the honesty rules to the top of CLAUDE.md.

Minute 2: append the verification protocol.

Minutes 3‑4: edit .claude/settings.json to add a lightweight PostToolUse hook that runs the fastest check for your stack.

Minute 5: create the fact-checker sub‑agent and configure it to run before each commit.

Even if the model still hallucinates occasionally, these constraints make it pause, run real checks, and surface errors early, dramatically improving reliability in production workflows.

References

Claude Code official docs: “How Claude remembers your project”

Claude Code official docs: “Hooks reference”

Claude Code official docs: “Create custom subagents”

Code w/ Claude session: “Making agentic workflows trustworthy and verifiable with a custom DSL”

YouTube video: same session link

Elicit blog: “New in Elicit: Research Agents”