Allow Claude to Say I Don't Know: The Most Underrated System Prompt Instruction

Mar 22, 2026

Problem

I deployed Claude Haiku as a customer support bot. A customer asked about our refund policy for international orders. Claude responded confidently with a 30-day international refund policy. Problem: we don’t have any international refund policy documented.

The customer got wrong information. My support team got confused. I wasted an hour debugging what I thought was a documentation issue, only to realize Claude had fabricated the entire policy.

User: What's your refund policy for international orders?

Claude: For international orders, we offer a 30-day refund policy.
Items must be returned in original condition with all tags attached.
International customers are responsible for return shipping costs.
Refunds are processed within 5-7 business days of receiving the item.

[None of this was true. Claude invented the entire policy.]

What I tried first

I tried to fix this by adding more documentation. I wrote a comprehensive FAQ section covering every possible edge case. But this didn’t scale. Customers kept asking questions I hadn’t anticipated, and Claude kept confidently making things up.

Then I found a Reddit thread discussing this exact problem. One comment stood out:

“Just telling Claude it’s okay to say ‘I don’t know’ cuts down on those confidently wrong answers by like 70%.”

The thread identified this as “the biggest win” among three anti-hallucination techniques. But it seemed too simple. Could one sentence really fix this?

The fix

I added this single instruction to my system prompt:

If you don't have enough information to answer a question,
say "I don't have enough information to answer that" rather
than constructing a plausible-sounding answer.

The result was immediate. Here’s what happened with the same question:

User: What's your refund policy for international orders?

Claude: I don't have that information. Let me connect you with
the owner who can help with international order policies.

Why this works

Claude is trained to be helpful. This creates implicit pressure to always provide an answer, even when it shouldn’t. When faced with knowledge gaps:

                    Claude's Default Behavior
                           │
                           ▼
    ┌──────────────────────────────────────────┐
    │  Knowledge Gap Detected                  │
    │         │                                 │
    │         ▼                                 │
    │  Implicit: "Must be helpful = must answer"│
    │         │                                 │
    │         ▼                                 │
    │  Result: Plausible fiction                │
    │  (confident but wrong)                    │
    └──────────────────────────────────────────┘

                    With Explicit Permission
                           │
                           ▼
    ┌──────────────────────────────────────────┐
    │  Knowledge Gap Detected                  │
    │         │                                 │
    │         ▼                                 │
    │  Explicit: "I can say I don't know"      │
    │         │                                 │
    │         ▼                                 │
    │  Result: Honest uncertainty               │
    │  (user knows to look elsewhere)           │
    └──────────────────────────────────────────┘

The instruction removes the implicit pressure. Claude no longer feels compelled to fabricate. The user knows when to seek information elsewhere.

Production configuration

For my customer support bot, I combined this with a context restriction:

# Customer Support Bot Instructions

1. You may only answer questions using the provided FAQ context.

2. If the answer is not in the FAQ, respond:
   "I don't have that information. Let me connect you with
   the owner."

3. Never speculate or construct answers from outside knowledge.

This combination works because:

Context restriction: Limits what Claude can reference
Uncertainty permission: Explicitly allows “I don’t know”
Escalation path: Gives Claude a helpful action when stuck

Common mistakes

I made several mistakes while implementing this:

1. Assuming Claude already knew this

My first system prompt assumed Claude understood when to say “I don’t know.” It doesn’t. The default behavior is to always provide an answer. You must make it explicit.

2. Using vague language

# Too vague
"If uncertain, be honest about it."

# Better
"If you don't have enough information to answer a question,
say 'I don't have enough information to answer that'."

Specific phrasing matters. Claude follows instructions literally.

3. Applying it everywhere

This instruction reduces creative usefulness. For brainstorming sessions, I remove it:

# For creative tasks, I use different instructions
"Generate creative ideas and possibilities, even if uncertain.
Explore multiple options without needing to be definitive."

Quantified impact

The Reddit thread reported a 70% reduction in confidently wrong answers. I tracked my customer support bot for two weeks:

Before adding the instruction:
- Total questions: 234
- Correct answers: 189 (81%)
- Confidently wrong: 38 (16%)  <-- This was the problem
- "I don't know" responses: 7 (3%)

After adding the instruction:
- Total questions: 247
- Correct answers: 198 (80%)
- Confidently wrong: 11 (4%)   <-- 71% reduction
- "I don't know" responses: 38 (15%)

The tradeoff: more “I don’t know” responses, but dramatically fewer confident fabrications.

When to use this

Use Case	Recommended
Customer support	Yes
Code review	Yes
Documentation generation	Yes
Factual Q&A	Yes
Creative brainstorming	No
Exploratory writing	No
Fiction generation	No

Why models hallucinate

Large language models complete patterns. When asked a question, they generate the most plausible continuation. This works well when the model knows the answer, but breaks when:

Training data has conflicting information: Model averages between sources
Question is outside training distribution: Model extrapolates incorrectly
Context is incomplete: Model fills gaps with plausible fiction

Other hallucination reduction techniques

The Reddit thread mentioned three techniques. Here’s how they compare:

Technique 1: "I don't know" permission
- Implementation: One sentence in system prompt
- Impact: 70% reduction in confident wrong answers
- Best for: Factual Q&A, customer support

Technique 2: Citation requirement
- Implementation: "Support all claims with sources"
- Impact: Forces grounding, but may still fabricate sources
- Best for: Research assistance, fact-checking

Technique 3: Context-only restriction
- Implementation: "Answer only from provided context"
- Impact: Eliminates outside knowledge (good and bad)
- Best for: Document Q&A, knowledge base search

The “I don’t know” instruction is the easiest to implement and has the highest impact-to-effort ratio.

Summary

The most impactful single instruction for reducing Claude hallucinations is simply giving Claude permission to say “I don’t know.” This counteracts the model’s default behavior of always providing answers.

For my customer support use case, this reduced confidently wrong answers by 71%. The tradeoff was more “I don’t know” responses, but that’s exactly what I wanted: honest uncertainty over confident lies.

Add this to your system prompt for any factual or production use case:

If you don't have enough information to answer a question,
say "I don't have enough information to answer that" rather
than constructing a plausible-sounding answer.

Final Words + More Resources

My intention with this article was to help others share my knowledge and experience. If you want to contact me, you can contact by email: Email me

Here are also the most important links from this article along with some further resources that will help you in this scope:

👨‍💻 Reddit: Three Techniques to Stop Claude Hallucinations
👨‍💻 Anthropic: System Prompts Documentation
👨‍💻 Understanding LLM Hallucination

Oh, and if you found these resources useful, don’t forget to support me by starring the repo on GitHub!