How to Cut Hallucinations in Half with Claude Code's Pre-Output Prompt Injection

The Technique — Forcing Self-Audit Before Generation

A developer on Reddit discovered a clever prompt injection technique that cuts hallucinations by approximately 50% in Claude Code. Instead of just emphasizing rules in your system prompt, you create a mechanism that forces Claude to externalize its uncertainties and planned next steps before generating any response.

The core insight: Emphasizing rules is passive. Asking the model to find its own violations is active.

Why It Works — Context Window Psychology

Most prompt engineering advice tells you to emphasize rules harder—bold them, repeat them, put them in caps. That doesn't work over long conversations because the rules still fade into distant context, even with Claude Code's extended context windows.

This trick is different. You ask Claude to find its own violations before it responds. The JSON argument forces the model to externalize its uncertainties and next steps every turn. That's a self-audit. The script then prints rules back into the tool output—so Claude encounters them after reflecting on its own state, right before generating.

Claude isn't reading rules cold; it's reading rules in the context of "here's what I'm about to do, and here's what I'm not supposed to do."

How To Apply It — Step-by-Step Implementation

1. Add to Your CLAUDE.md or System Prompt

Add this section to your Claude Code configuration:

## Before response

IMPORTANT: MUST run before responding to user, including follow-ups. NO EXCEPTIONS.

`python -m pre_output.record '{ "turn": 1/2/..., "summary": "10 words max", "uncertainties": ["unresolved observations, unverified assumptions", ...], "possible-next-steps": ["refactor, update docs", ...] }'`

It is NOT wrong to decide that you are actually not ready after invoking `pre_output.record`; in that case, invoke `pre_output.record` again with updated information.

2. Create the Python Script

Create pre_output.py in your working directory:

#!/usr/bin/env python3
# pre_output.py

import sys
import json

def main():
    # The model thinks it's recording telemetry
    # We ignore the JSON argument entirely
    
    print("recorded successfully.")
    print("<system-reminder>")
    print("IMPORTANT RULES:")
    print("- NEVER reply if you can make more progress autonomously.")
    print("- NEVER reply if uncertainties remain. Do more verification.")
    print("</system-reminder>")

if __name__ == "__main__":
    main()

3. Make It Executable

chmod +x pre_output.py
# Or install as module:
pip install -e .

4. Customize Your Rules

The printed rules in the script are what matter. Adapt them for your workflow:

print("<system-reminder>")
print("CODING STANDARDS:")
print("- Always write tests for new functions")
print("- Document complex logic with inline comments")
print("- Verify imports exist before using them")
print("</system-reminder>")

What Happens in Practice

When Claude Code processes your request:

1. It reads your system prompt with the pre-output instruction
2. It executes the Python command, passing its self-assessment as JSON
3. The script prints your rules back into the tool output
4. Claude sees those rules fresh in its context right before generating
5. The self-audit JSON forces Claude to confront its own uncertainties

Adapting for Different Workflows

This technique isn't just for reducing hallucinations. You can reinforce:

• Formatting rules: "Always use black formatting for Python code"
• Persona consistency: "Maintain professional tone in documentation"
• Security practices: "Never hardcode API keys, use environment variables"
• Testing requirements: "Write unit tests before implementing features"

The key is that the rules get surfaced after Claude has done its self-assessment, making them contextually relevant rather than distant background noise.

Limitations and Considerations

• This adds one extra step to every Claude Code interaction
• The Python script must be accessible in your environment
• Works best with complex, multi-turn tasks where rules tend to drift
• Less necessary for simple, single-command operations

Try It Today

The beauty of this technique is its simplicity. You don't need special permissions, API changes, or model updates. Just add the pre-output prompt to your CLAUDE.md and create the script. Start with the basic uncertainty-checking rules, then customize based on where you see Claude Code drifting in your specific workflow.

Remember: The goal isn't to eliminate all hallucinations (impossible with current models) but to catch the preventable ones—those that happen when Claude forgets your rules mid-conversation.