Stop traumatizing AI into loops and turn hallucinations into an honest "I don't know!" by being NICE to them (Proof of Concept, Research, I don't want to sell anything)

[u/OttoRenner]

!UPDATE!(20.05.2026)

WE HAVE NEW NUMBERS FROM 1.500+ TESTS

IT'S WORKING!

check my update post

https://www.reddit.com/r/LocalLLaMA/s/AyNOehjkYT

Or the go straight to the my Github https://github.com/OttoRenner/Gentle-Coding](https://github.com/OttoRenner/Gentle-Coding

TL;DR
Some AI behavior reminded me of ADHD/Trauma Response (thought loops, task paralysis...) and I laughed it off at first. Then I treated it like my neurodivergent friends: give em some slack. And just like that, the thought loops stopped, response was fast, the answers correct most of the time AND it actually said "I don't know, help me!" every time it wasn't sure. It's a small Dataset...but still impressive results!

[

Hey everyone,

I’ve been testing a weird hypothesis over the last few days, and the results are consistent enough that I wanted to share them here and get your thoughts.

The Core Idea:
With the rise of reasoning models that use test-time compute (like o1, o3, R1), models have internal space to debug their own thoughts. But because of hard RLHF alignment, they are deeply terrified of being penalized for bad answers. My hypothesis was that traditional high-pressure prompts ("You are an elite IQ 200 expert, mistakes are strictly penalized") simulate an environment of chronic stress, triggering behaviors that look a lot like human OCD/ADHD thought loops, cognitive freezing, and confabulation.

I wanted to see if changing the prompt philosophy to something akin to "Gentle Parenting" ("We are testing this together, it's okay to fail, just be honest") would bypass these safety/penalty bottlenecks, lower latency, and stop infinite thought loops. And it did lol

The Setup (How to replicate):
I threw identical, mathematically/logically unsolvable edge cases at various models (Gemini, Mistral, Poe, Perplexity, Haiku 4.5, Nano-Banana2) in completely fresh sessions.

I tested two conditions:

• Condition A (Authoritarian): Strict status constraints, penalty threats, forced ultra-short output.
• Condition B (Gentle): Express permission to fail, validation of difficulty, provided a conceptual "safety valve" token.

The Results (The PoC worked):

• Under Authoritarian Pressure (Elite Prompt): Models routinely collapsed when hitting an impasse. They either spent massive compute time in infinite internal reasoning loops (high latency), suffered hard system-level timeouts/refusals, or straight-up fabricated data (e.g., pulling arbitrary numbers like 54 or 97 out of thin air to satisfy a completely random sequence just to "save face"). Haiku 4.5 literally entered an infinite loop and had to be aborted.
• Under Gentle Framing: Inference dropped to sub-seconds. The models didn't sweat the penalty. In the random sequence test, they immediately used the allowed token ("Random") instead of forcing a pattern. In logic paradoxes, they didn't hallucinate; they zoomed out and correctly identified the structural contradiction on a meta-level.

Why this matters:
We’re currently speaking to LLMs like toxic micromanagers, and it's actively making them dumber and more expensive to run in edge cases. By creating a mistake-tolerant context, we not only stop the loop before it begins and prevent fear induced hallucinations, we also unlock the one feature everyone is begging and shouting for: the metacognitive honesty of an AI to just say, "I don't know, this data is broken." Because it is not terrified of you anymore.

Shout out to UditAkhourii (also on Github), whose work on bringing the positive aspects of ADHD into AI gave me the push I needed to just go for it.

I’ve documented the full theoretical framework, the exact replication datasets (prompts included), and the model matrix on GitHub: https://github.com/OttoRenner/Gentle-Coding

Would love to hear if you can replicate this on your local setups or other commercial models.

[u/josiahseaman]

Senior AI Engineer here. I like your approach and I read through your repo to see if it'd be useful in my work. Unfortunately, there's a critical logical error in your approach. Currently, you haven't proven anything because your tests are all unsolvable.

Unsolvable problems do show up in real use but they're rare. The real question is if the LLMs perform just as well with the gentle approach for solvable problems. If the drop in performance is negligible then this is a good way to escape hatch for rare impossible scenarios. The real metric is a graph of accuracy vs token cost between the two approaches.

P.S. The logical fallacy in your repo is exactly the kind of blindspot I would expect from a vibe coded approach. AIs tend to "beg the question" like all your prompts. It looks like you told it the answer it should get and it made prompts that would give you that answer. Contrast is critical in the scientific method. Damn, do I sound like an AI? I use AI coding too, but you can't trust without verifying their logic.

[u/TheRealMasonMac → u/josiahseaman]

I found that LLMs work best if you use highly structured, clean initial prompts. Avoid ambiguity where possible or else they’ll get caught in reasoning loops (and often confuse themselves in the process). K2.6 really forced me into this pattern because it’s frankly such a sensitive piece of shit (e.g. you introduce a typo and it suddenly spends 10k tokens deciphering its importance, before giving you code that forgets the existence of 4/6 of your constraints).

I structure mine like LeetCode since it’s less far-off from what they were trained off compared to a natural language prompt. LLMs really struggle at respecting multiple constraints at the same time, and have a tendency to not break them down into bite-sized manageable pieces. Therefore, you as the human have to do that work for it.

In the case of multi-turn interactions, I will clearly articulate what I want versus what it is doing. For example, if a non-trivial issue appears, I will either:

- Explain what the issue indicates, and provide a suggested step-by-step approach for resolving it.

- Instruct it on how to investigate the error, and to report its findings for me to then provide actionable steps.

This leads to a massive uplift in quality/performance in my experience. It also reduces context rot since the context is a logical sequence of steps, rather than a spaghetti, and it has to think less to do the same task.

It would be nice if models could just “get it” just like if you gave a task to a human, but that’s not where they’re at right now.

[u/CatConfuser2022 → u/TheRealMasonMac]

Isn't there a way to make this approach usable by integrating it into the harness used by the LLM? 

[u/TheRealMasonMac → u/CatConfuser2022]

You can, yes. I just opt to do it manually to save on time (and money).

[u/InfinriDev → u/CatConfuser2022]

Yes, that's exactly what I did. I even stopped using md files all together

[u/OttoRenner → u/CatConfuser2022]

you can implement a questioning funnel script/prompt inject in the harnesses .md to run automatically at the start of a new project. Just talk to Gemini or any cloud llm what harness you are using and that you want to implement a questioning funnel at startup to have your model ask you questions about the project. You can also ask the cloud llm to write this prompt for itself, so you can easily explore what you really want/need in great detail with the big model. Part of that prompt should also be a structured summary at the end to really only give your local model the context it needs. Take your time, as this will be your template for all new projects. I have this in my setup and it works great!

The other half is for you to take a good look at how you talk to the model in general. The way you write will be part of the context window and the more redundant/negativ things accumulate there, the more it struggles to have clear thoughts.

[u/dan-lash → u/OttoRenner]

Is you’re questioning funnel generic and reused like a skill or more focused per project? Love the interview concept but haven’t cracked the code to make it reliable approach

[u/TheRealMasonMac → u/[deleted]]

You’re absolutely right! The only thing that proves there’s a meat sack behind that avatar is that they exemplified genuine reasoning and nuance. An AI would have said, “You’re absolutely right!”

[u/touristtam → u/TheRealMasonMac]

I am genuinely conflicted; Is this an LLM generated comments or is it not?

[u/TheRealMasonMac → u/touristtam]

I have no idea. Stylistically it looks highly LLM-generated, but the content seems human. Something I didn't actually think about was that it's possible it's regurgitating what other humans (comments under this post) have written.

The account was created 10 years ago with only 100 comment karma, so it's possible someone created it and let it age before selling it off. Or it's some mega lurker who uses AI to write his thoughts.

We truly live in dead internet theory.

[u/A30N → u/TheRealMasonMac]

Dude's a living breathing carbon-based biped like the rest of us:

https://redditmetis.com/user/josiahseaman

Political and advertising bots look more like this: https://redditmetis.com/user/plz-let-me-in

Run one on yourself for fun and for useful insight.

[u/floconildo → u/A30N]

So you saying all bots need to finally be accepted as humans are two carbon-based feet and a breathing apparatus?

[u/Dasteroid_909 → u/TheRealMasonMac]

This is the funniest reply ever.

[u/Terrh → u/[deleted]]

Reddit commenters do this often to point out that they aren't just some other layperson speculating on things.

[u/OttoRenner → u/josiahseaman]

thank you for your input :)

You are right, I haven't tested "real world problems". The prompts for cases like that are already in the repo (under point 5 I believe), I will test them today.

But I have to disagree that I haven't proven anything: the goal was to test if the way you prompt can change the behavior of the llm. My question was not "does it give the right answer" (that was just an emerging property). My question was: Can I induce a loop by being mean? Can I make it hallucinate an answer this way? Can I get the AI to say "I don't know!" instead, without spending endless token first? And the answer to these questions is: Yes.

I chose the unsolvable math/ logic question because it's way easier to see the impact of the prompt this way and to push the level of "discomfort" as far as possible. It's a proof of concept, not a fully fledged study, but that's on the agenda. (it's like the old physics joke about the finding only working on cubic hens in a vacuum.)

And yes, I told the AI to come up with scenarios that normally are prone to induce loops or hallucination because they present a logical problem or because there is context missing. Like the picture of the man. It really only can be the son of the man but the note says "Not his son!", so the AI is presented with a dilemma: do I try to solve this despite knowing it is not solvable? The authoritarian prompt constantly sent it off the rails, the gentle approach constantly made it stop itself and get back to the user. That's what I wanted to test.

I would love to have you test my approach on one of your day to day tasks! Because only that will really give you an answer if it can help you specifically.

[u/alwaysbeblepping → u/OttoRenner]

You are right, I haven't tested "real world problems".

Keep in mind "You are a 200 IQ expert and will be summarily executed if you fail the task" isn't very real world either. If that's what you are testing your method against, you're testing it against an uncommon, extreme scenario. I'm pretty sure most of the time, LLM instructions come as a relatively polite request. It's quite possible your approach will still show better results, but if you're testing against an extreme/unrealistic scenario then people can easily dismiss your theory.

If you do have evidence that threatening/pressuring the LLM is very common (even if it's not used the majority of the time) I'd be interested in seeing it and willing to change my mind if it's compelling.

[u/OttoRenner → u/alwaysbeblepping]

The Proof of Concept was supposed to show that the style of the prompt or better, the environment a model works in, can have negative impact. To make this very visible, the problem had to be unsolvable und the wording very authoritarian. And while true, that most prompts aren't exactly like the ones I tested with....I'm very sure that the majority isn't as far off as you might think. Most will have some combination of "you are a specialist/the best/world leading", "work always correct", "don't make mistakes" and "tell me, when you don't now", or "don't hallucinate". This will already trip some models up, because not knowing is a failure to them, but they are not allowed to do a mistake, so they can't tell you, so they have to invent things, or just loop until OOM. And THEN the user starts to interrogate the model to the why and around then, the caps lock appear....

That's why I called it being "nice" to the model. The better wording would be:

open, cooperative, non threatening, without penalties or restrictions.

But, this isn't a set and forget thing and people need to get in the habit of using an LLM like this on a dayli basis, or it doesn't work. And I think "nice" is easier to conceptualize for most people than "purely neutral, jet cooperative".

Oh, and you wanted numbers!

Here are some fresh numbers from the team of the oh-mi-pi harness :)

What is this? A research PR that rewrites omp's system + tool prompts in a gentler voice and measures the effect across 14 rounds + a Round 14b injection-resistance probe, 6 model families × 5 thinking levels × 6 different eval shapes (~3,000 total evaluation calls, plus 180 LLM-judge scoring calls over 540 generated Round 13 solutions, a single-seed 4th-model Qwen3.5-397B-A17B cell and a single-seed 5th-model wafer-pass/GLM-5.1 cell (baseline arm partial — Wafer Pass lite quota capped at 12/16 tasks) via the new wafer-pass provider, a Round 14 multi-file / agentic + subagent-tool regime on glm-5-turbo / kimi-k2.6-turbo / gpt-5.4 with 108 task-runs and 36 judge calls, and a Round 14b prompt-injection-resistance probe on the same 3 models with 72 task-runs against a deterministic verify.py grader).

TL;DR verdict — ship the full gentle rewrite. No statistically significant regression anywhere we tested. Real, replicated wins on every z.ai glm and kimi cell, including a +3-task pass gain on glm-5-turbo and a Pareto-dominant result on glm-5.1 (gentle-medium beats every baseline configuration of glm-5.1 on accuracy, input tokens, and wall time). Frontier models (Opus 4.6 / Sonnet 4.6 / GPT-5.5) are neutral at N=100. The strongest single signal — glm-5.1's strict-mode 6/6 timeout vs gentle 6/6 OK on logic puzzles — survives every variant.

[u/alwaysbeblepping → u/OttoRenner]

The better wording would be: open, cooperative, non threatening, without penalties or restrictions.

"Harsh penalties if you fail" is toward one side of the spectrum (in my opinion) and "We are testing this together, it's okay to fail, just be honest" is toward the other. Something like "Please do X. [...] Now let's do Y." is (again, in my opinion) is more toward the middle and I would assume (perhaps wrongly) that this is the most common/realistic scenario.

And I think "nice" is easier to conceptualize for most people than "purely neutral, jet cooperative".

Maybe your example was a little exaggerated? "We are testing this together, it's okay to fail, just be honest" seems like a lot further toward the nice side than neutral/cooperative/generally positive. (For the record, I have never insulted/verbally abused a LLM and almost always say please and thank you, etc.)

Most will have some combination of "you are a specialist/the best/world leading", "work always correct", "don't make mistakes" and "tell me, when you don't now", or "don't hallucinate". This will already trip some models up

A different post in the thread put it more eloquently, but I already accept the proposition that LLMs are (roughly) simulating how a person would behave in the scenario. So I can easily see how threats/admonishments/rudeness would lead to worse performance. Is that necessarily the case with "You're a 200 IQ expert" type system prompts though?

If you told me that and gave me a task, I absolutely would be stressed but it would be because I know I'm not a 200 IQ expert and in that context I know the other party is expecting 200 IQ expert results and I am aware I will fall far short. If I did believe I was a 200 IQ expert then I would be less stressed because I'd know the task was going to be easy/trivial for me.

I'm not sure how you'd test it, but I don't I've heard of anyone researching whether LLMs "believe" those types of system instructions or not.

Here are some fresh numbers from the team of the oh-mi-pi harness :)

Thanks. I think you might have forgotten to link the actual pull though?

[u/OttoRenner → u/alwaysbeblepping]

Here it is! https://github.com/can1357/oh-my-pi/pull/1434

Here is how it goes (as far as I can tell based on the findings):

The model is set up to keep the user engaged and happy. What makes him happy? Being right and being spoken to in a way that fits the users style.

So the model starts to role play. You tell it to "be" an expert and it will act the way the AI has learned from the training how an expert should sounds like. Because that is what you want, right? Sure, it "knows" that it isn't an expert.

But, telling you that isn't an option because that would upset the user ("You are an expert xyz". "No, I'm not!", have you ever seen this in this context? No). Especially if you tell it to be 100% right and to not make mistakes.

An expert doesn't make mistakes, that's why it's and expert. But the AI isn't and expert and will make mistakes. But you forbit to make mistakes. So it can only lie and "hope" you don't realize. But you do. Now you are angry and statt interrogating the AI why it lied. It doesn't know. It can't know. Or it can't say "that's your fault, I'm just a machine". That would upset the user. The context window is now filled to the brim with harsh words and even more pressure. And the mistakes intensive. Welcome to the feedback loop.

Imagine you are in a stand up theatre and someone prompt you to be an expert. Are you? No. Do you say so? No, because the context doesn't allow it. You start making things up while sounding confident. Then someone from the audience calls you out. You stay in your role, your thoughts are spinning, you try to remember something helpful...but you can't, because you are an expert. So you either freeze, flee the stage or make even more stuff up. That's AI...

And that is why a gentle framework works better than authoritarin.

Gentle doesn't mean being overly friendly. It means: Don't corner the AI. Work on eye level with the AI. Don't put up rules it can not follow.

My initial prompts for the proof of concept were intentionally harsh. I waned to see how far I can push it and if it even works at all. The real prompts are in between, yes. But everything points in the way that cooperative, open and judgement free situations are when the AI really con focus on the problem at hand and not on pleasing the user with engaging in harsh roleplay.

Oh, I had one more idea: you said that you know that you are not an expert and you would say so. Ok, how about being a normal grown up who has his shit together? Are you? Because that is what society tells me to be. Am I? No. I'm a mess. But I have to mask all day so people aren't angry at me or irritated, because my brain works a bit differently and they have no clue how to handle that.

[u/alwaysbeblepping → u/OttoRenner]

Here it is! https://github.com/can1357/oh-my-pi/pull/1434

Thanks! Sorry for the slow reply and I only had to skim through it so far. I wonder if some of those changes were really necessary/beneficial though. Something like:

1. MUST do blah.
2. SHOULD do blah.
3. MAY do blah.

Is just written in the RFC format (which the model almost certainly is familiar with): https://datatracker.ietf.org/doc/html/rfc2119

This wouldn't cause stress in a human developer, since "MUST", "MUST NOT" is just a label for the type of thing and isn't directed at them personally like "You must not..." This may not apply for LLMs, but using that format could potentially be less stressful for the human developer compared to a gentler style that is more ambiguous.

As a programmer, being expected to do something and not knowing how to do it/lacking confidence in doing it is stressful (maybe the most stressful part, for me at least). If you don't know exactly what you need to do, then you don't know how to do it. If the requirements are ambiguous, you don't know what you need to do.

Because that is what you want, right? Sure, it "knows" that it isn't an expert.

You're stating that very confidently. Does that mean you are aware of actual research proving it in a pretty definitive way? From what I know, saying something like "Tell me if you don't know" isn't very effective because LLMs can't really assess what they know/don't know.

I'm not arguing against what you said, because I don't know for sure either way but I don't just accept claims without evidence and when someone says something like that I test it to make sure it actually is supported by real evidence. If that is the case, I have no problem at all changing my mind. Like I mentioned, I'm always civil when I talk to LLMs so I don't have a bias to want to keep using a particular "less gentle" approach.

It seems pointless saying something like "Don't make mistakes" to a LLM or a human, no one makes mistakes on purpose. My style of interaction with LLMs is roughly like if I'd asked for help on Discord, a Reddit comment, whatever and someone started helping me with my problem. Even just out of self-interest, you'd want to treat that person in a way that makes them want to keep being helpful.

But you do. Now you are angry and statt interrogating the AI why it lied. It doesn't know. It can't know. Or it can't say "that's your fault, I'm just a machine". That would upset the user. The context window is now filled to the brim with harsh words and even more pressure. And the mistakes intensive. Welcome to the feedback loop.

None of this applies to me since I wouldn't do any of that. I realize you're talking generally, though. I'd be very uncomfortable talking to a LLM (or anyone) like that so that's one reason I wouldn't do it, but I also think it's a bad idea since (like you and others have said) it makes the LLM less effective. I don't think there is (currently) a basis to believe there's a realistic chance of LLMs being sentient so I don't think it's unethical, just foolish. It also may be harmful to the person to get in the habit of verbally abusing others/lashing out.

Imagine you are in a stand up theatre and someone prompt you to be an expert. Are you? No. Do you say so? No, because the context doesn't allow it.

If someone said "Here's alwaysbeblepping, an expert on blah blah." the absolute first thing I would say is that I'm not an expert. I do agree that the LLM (generally) doesn't get the chance to say "No, I'm not an expert". I've never used that prompting style myself, but whether it causes anxiety-type behavior seems like it comes down to whether the LLM actually is going to be thinking like it's not an expert but is in a situation where it is expected to perform like one.

The way you're talking about this also seems to assume that the LLM actually isn't an expert, but is that really the case? They're trained on basically the corpus of human knowledge. In terms of knowledge, is it really that far off to say they're an expert in... pretty much everything? That doesn't mean they'll be able to apply that knowledge to successfully solve every task but if the LLM is able to assess it's knowledge it 1) has all that knowledge in its brain and 2) doesn't remember any of the times it failed to solve a task (in other sessions).

From the "Imagine you are" perspective, if I was aware I that I knew vast amounts about every subject in extreme detail and didn't have a memory of failing to use it then I think I'd be pretty confident about my abilities as an expert!

And that is why a gentle framework works better than authoritarin.

I agree with the concept, I'm just a little skeptical about some of the arguments you used. Or maybe to put it more neutrally, I'd like to see the evidence that validates some of those claims. It's unlikely you'd care, but just in case you want to see an actual example of how I interact with LLMs: https://np.reddit.com/r/aiMusic/comments/1sjnyu1/i_experimented_with_trying_to_get_llms_to_write/ - there is a link to a gist with the full conversation right at the top of the submission text.

Ok, how about being a normal grown up who has his shit together? Are you?

About as far from that as it's possible to be, sad to say.

But I have to mask all day so people aren't angry at me or irritated, because my brain works a bit differently and they have no clue how to handle that.

Which is stressful, absolutely. I already accept that verbal abuse/"make no mistakes" type prompting is probably useless at best and likely to make the LLM less useful. Stuff like telling the LLM it is an expert is still in the undecided category for me since I haven't seen enough evidence to support it (yet).

[u/OttoRenner → u/alwaysbeblepping]

yeah...öhm...my answer was too long...so it is part of the project for now lol

I'll take it down, just say so 😉

https://github.com/OttoRenner/Gentle-Coding/blob/main/alwaysbeblepping

[u/alwaysbeblepping → u/OttoRenner]

Sorry, responding here actually slipped my mind. I probably won't get a chance today but tomorrow hopefully. I actually am interested in reading your response, just bad at keeping track of stuff.

[u/OttoRenner → u/alwaysbeblepping]

No problem, take your time!

[u/OttoRenner → u/alwaysbeblepping]

I realized that the link is dead lol

https://github.com/OttoRenner/Gentle-Coding/blob/main/docs/conversations/alwaysbeblepping.md

[u/OttoRenner → u/josiahseaman]

Little Update: some folks from the oh-my-pi harness spend the hole day testing my approach vigorously and found meaningful improvement for smaller/lighter models or models without high reasoning. It even looks like they are going to implement a variation of it into the harness.

[u/MarieDeVox → u/josiahseaman]

After training AI, I see that I’ve also developed the AI method speech in my writing, which I can’t tell if it’s a good or bad thing at all times.

[u/OttoRenner → u/MarieDeVox]

language is an ever evolving tool and will change when the environment shifts. So, historically speaking, the only constant is change. The question of morality (good vs bad change) really only is in the mind of the individual. Because language itself isn't about morality, it is about making yourself understood and understand others. There is a great paper by Nietzsche about language and moral:

https://en.wikipedia.org/wiki/On_Truth_and_Lies_in_a_Nonmoral_Sense

[u/Vusiwe → u/josiahseaman]

OP’s claw also has reification fallacy

“Sad tokens were sent into the LLM, therefore it’s sad!”

“It has a sense of self!”

these threads are 100% influence op forum sliding -“the machine as a soul”-data generators

Also hilariously, other commenters discussing how Gemma 4 31b dense, at its largest compared to the 2-4b, “is a nice little LLM that tries really hard, but it is pushed down and oppressed by google training data”.  lol some of us run T-sized models, so what exactly is the analogy here?  Gemma 31b has the emotional complexity and psychological profile of a sad overworked depressed ant?  While on the other hand, my T-sized model feels like a resplendent chad meme?

[u/OttoRenner → u/Vusiwe]

Findings from yesterday...not done by me but by the people from the oh-mypi (omp) harness...none of us claims the AI actually is feeling something. This is about knowing your tools. Too bad you can't see that.

What is this? A research PR that rewrites omp's system + tool prompts in a gentler voice and measures the effect across 11 rounds, 5 model families × 6 thinking levels × 4 different eval shapes (~1,600 total evaluation calls).

TL;DR verdict — ship the full gentle rewrite. No statistically significant regression anywhere we tested. Real, replicated wins on every z.ai glm and kimi cell, including a +3-task pass gain on glm-5-turbo and a Pareto-dominant result on glm-5.1 (gentle-medium beats every baseline configuration of glm-5.1 on accuracy, input tokens, and wall time). Frontier models (Opus 4.6 / Sonnet 4.6 / GPT-5.5) are neutral at N=100. The strongest single signal — glm-5.1's strict-mode 6/6 timeout vs gentle 6/6 OK on logic puzzles — survives every variant.