Why does AI get better when you're angry?

The last post covered one phenomenon:

why does AI change its answer the moment you question it?

There’s a subtler one too:

why is it that sometimes you ask nicely and AI barely changes, but once you get angry, its output suddenly improves?

You say: “Polish it a bit more.”

It just swaps a few words.

You say: “Make it more natural.”

It gets a little more conversational, but the content is still empty.

You say: “Make the structure clearer.”

It adds subheadings, but the piece is still scattered.

Until you really lose patience and say:

“Look at the nonsense you’re writing.”

“What on earth have you produced?”

“You’ve just repackaged the points I made. Are you actually thinking?”

“Stop talking nonsense with a straight face and producing stuff with no information in it.”

And then the next version is suddenly much better.

So does yelling at AI work?

But:

• sometimes it gets better.
• sometimes it just writes longer, fuller, more strenuously.
• sometimes it overturns the whole previous version and ruins the parts that were good.
• sometimes it just tries harder to please you without actually solving the problem.

Maybe the more accurate question isn’t: why does AI get better when you’re angry?

It’s:

why does some strong feedback make AI better, while some makes it messier?

What actually works isn’t the anger.

It’s that when people are angry, they may finally say two things they usually leave unclear:

exactly how it’s failing, and which directions not to go again.

The first can be called the failure mode. The second can be called negative constraints: telling AI explicitly which directions not to take.

One tells AI:

where it’s broken now.

The other tells AI:

which wrong directions not to fix it in.

These two are far more useful than “make it a bit better.”

AI isn’t scared because you’re angry

Let’s take that misunderstanding apart first.

AI doesn’t feel ashamed, nervous or eager to repair the relationship the way a person does, and it doesn’t suddenly get serious because your tone is harsh.

It can’t be shouted awake.

So “yelling at AI works” looks like a lesson learned on the surface, but the explanation is off.

What’s more likely happening is:

when you’re calm, you give vague feedback.

For example:

• make it a bit better.
• make it more natural.
• give it more depth.
• make it sound less like AI.
• tidy up the structure.

These sound like directions, but they’re hard for AI to act on.

• What counts as better?
• What counts as natural?
• What counts as depth?
• What does “sounds like AI” mean?
• Is the structural problem the order, the hierarchy, or that the main question never got established?

It can only guess.

But when you’re really dissatisfied, you may actually say more specific problems:

• you didn’t explain the mechanism.
• you didn’t distinguish where it applies.
• you stuffed all the feedback in.
• you keep polishing, but the problem isn’t the wording at all.
• you gave lots of points but no line of argument.
• you didn’t explain why this method works.

Those are different.

That isn’t just emotion.

It’s a diagnosis of the error.

Why does strong feedback sometimes make AI better?

I’d break it into a chain:

strong feedback → triggers repair mode → if it includes failure modes and negative constraints, AI is more likely to fix the right thing → if it’s only emotion, AI is more likely to overcorrect.

This chain matters.

Because it shows:

strong feedback itself isn’t a guarantee of quality.

It just makes AI more likely to move.

Whether it moves the right way depends on whether you said clearly:

exactly how it’s failing; and which directions not to go again.

Layer one: strong feedback triggers repair mode

Today’s AI assistants usually haven’t only been pretrained.

Pretraining teaches the model language, knowledge, patterns and forms of reasoning.

But to become a “useful assistant,” it also goes through instruction tuning, and RLHF — Reinforcement Learning from Human Feedback.

Put simply, the model isn’t only learning:

“What’s the next word?”

It’s also learning:

“What kind of answer are people more likely to find helpful?”

“Helpful” is the key here.

A helpful AI needs to understand the user’s intent, accept feedback, correct itself based on it, and produce a version closer to what the user expects.

So when the user is clearly unhappy, AI easily slips into a repair mode:

• the user is unhappy.
• the last version didn’t meet the need.
• I need to adjust.
• I need to admit the shortcomings.
• I need to push harder.
• I need to change the structure, add explanation, rewrite.

That’s why when your tone gets harsher, it often becomes more “hard-working.”

• It writes longer.
• Breaks things down more finely.
• Is more willing to admit fault.
• More willing to overturn the last version.
• Tries harder to move toward the direction you just pointed out.

But there’s a trap here:

trying harder isn’t the same as getting better.

• It may just be longer.
• Fuller.
• More like damage control.
• More like stuffing all the feedback in.

So repair mode only explains one thing:

why it moves.

It can’t guarantee:

that it moves in the right direction.

Layer two: what really helps is the failure mode

A lot of the time, the feedback we give AI states the goal but not the way it’s failing.

For example:

“Give it more depth.”

That’s a goal.

But it doesn’t explain why the current version is shallow.

Shallow can mean many things:

• it describes the phenomenon without explaining the mechanism;
• it gives conclusions without the reasoning;
• it covers one situation without the limits of generalizing;
• it gives methods without saying why they work;
• it piles up jargon without making the concepts clear.

If you only say “more depth,” AI may add jargon, paragraphs and examples.

But it won’t necessarily solve the problem.

Or:

“Make the structure better.”

That’s a goal too.

But structural problems come in many kinds as well:

• the main question isn’t clear;
• the subheadings don’t build on each other;
• causes, examples and methods are mixed together;
• each section stands on its own, but together they form no chain of argument;
• the first half explains mechanisms and the second half suddenly turns into generic advice.

If you only say “better structure,” AI may just add numbering.

But numbering isn’t structure.

Structure is how a question gets resolved layer by layer.

So truly useful feedback doesn’t only say:

“What I want.”

It says:

how it’s failing right now.

That is, the failure mode.

For example:

“This isn’t a wording problem, it’s an argument problem. You’ve laid the training mechanism, context mechanism and task mechanism side by side, but haven’t explained the causal relationship between them.”

That sentence is very effective.

Because it tells AI:

• level of the problem: the argument.
• the specific failure: mechanisms laid flat, no causality.
• the wrong direction: don’t keep polishing.
• the next step: rebuild the relationships between the mechanisms.

That’s much better than “write it with more depth.”

Layer three: negative constraints matter too

There’s another point that’s often overlooked.

We’re used to telling AI:

what I want.

We’re much less used to telling AI:

what I don’t want.

Yet the latter is very useful.

Because in open tasks, there are too many wrong directions.

You say:

“Optimize this article for me.”

AI could take that to mean many things:

• make it longer;
• make it shorter;
• make it more conversational;
• make it more professional;
• add examples;
• add jargon;
• add subheadings;
• change the title;
• rewrite the opening;
• turn up the emotion.

Any of these could be called “optimizing.”

But many of them aren’t what you want.

That’s when “what I don’t want” becomes important.

For example:

• don’t keep polishing.
• don’t just add subheadings.
• don’t make it longer.
• don’t pile on concepts.
• don’t overturn everything.
• don’t add jargon just to sound professional.
• don’t turn a real user’s feelings into a teaching voice.

These are negative constraints.

Their job isn’t to tell AI where to go.

It’s to close off the wrong roads first.

A lot of the time, it isn’t that AI doesn’t know how to try hard.

It’s that it doesn’t know which directions you’ve already rejected.

• You only say “more depth,” and it may pile on jargon.
• You only say “more natural,” and it may get loose.
• You only say “more structured,” and it may add a pile of subheadings.
• You only say “less like AI,” and it may get overly conversational.

So negative constraints aren’t a minor detail.

They help AI narrow the space.

Especially for tasks with no single right answer — articles, copy, product judgment, résumé wording — telling AI “what not to do” matters as much as telling it “what to do.”

Layer four: failure modes + negative constraints narrow the space for revision

When AI generates content, there may be a huge number of directions.

You say:

“Optimize this article for me.”

It can only guess.

But if you say:

“Don’t add more content. The problem isn’t too few points, it’s an unclear backbone. First rebuild the order of the argument.”

that sentence rules out a lot of wrong directions.

It tells AI:

• don’t add points.
• don’t polish.
• don’t change the title.
• don’t keep piling on examples.
• deal with the order of the argument first.

Now AI has fewer directions to choose from.

It’s more likely to hit the mark.

So it isn’t that anger has magic.

It’s that when you’re angry, you sometimes turn a vague request into a clear constraint.

You don’t just say:

“I want it better.”

You say:

“Where it’s broken now.” “Which directions not to change it in.” “What to deal with first.”

That’s the truly valuable part of strong feedback.

So why does it sometimes get worse after you get angry?

Because AI is very sensitive to strong feedback.

If your strong feedback contains a clear diagnosis, it may fix the right thing.

If your strong feedback is only emotion, it may just overcorrect.

For example, you say:

“This is completely wrong.”

AI may overturn everything.

But the original draft may not be completely wrong.

It may just be that:

• the opening isn’t good enough;
• the examples aren’t precise enough;
• the method section is too generic;
• the structure is missing a layer;
• the tone is too template-like;
• the ending floats off.

If AI reads a local problem as total failure, it writes a whole new version.

The new version may fix one problem but ruin the parts that were good.

This is the loop many people run into working with AI:

The first version is too shallow. The second is too stiff. The third is too long. The fourth is too scattered. The fifth finally has structure, but the tone is off again.

It looks like constant improvement.

Actually it’s swinging back and forth between different standards.

• You say heavier, and it goes too heavy.
• You say more natural, and it gets loose.
• You say more professional, and it piles on jargon.
• You say less like AI, and it gets overly conversational.
• You say it needs structure, and it adds lots of subheadings.

That isn’t getting better.

It’s over-alignment.

AI is trying hard to follow your feedback, but it has no stable judgment about:

• which feedback should change the backbone;
• which is just a local adjustment;
• what needs to be kept;
• which problems shouldn’t be solved by “rewriting the whole thing.”

So strong feedback is a knife.

Used precisely, it cuts right to the problem. Used imprecisely, it cuts the content to pieces.

When is strong feedback more likely to work?

I think it needs to meet at least four conditions.

First, you name the level of the problem.

Is this a structural problem or a wording problem? A problem of direction or a local one? Logic or tone?

If you judge the level wrong, every change afterwards will be off.

Second, you state the failure mode.

Not “no depth,” but:

no mechanism. No limits. No causality. No trade-offs. No explanation of why the method works.

Third, you give negative constraints.

Not just “more professional,” but also:

• don’t pile on jargon.
• don’t make it sound like a paper.
• don’t sacrifice readability to sound professional.

Not just “more natural,” but also:

• don’t turn it into loose chatter.
• don’t sacrifice structure.
• don’t get overly conversational.

Not just “rewrite,” but also:

• don’t overturn everything.
• keep the opening and the main judgment; only rewrite the mechanism section in the middle.

Fourth, you say what to keep.

If you don’t say what to keep, AI may delete the good parts too.

For example:

• keep the title.
• keep the real situation in the opening.
• keep this version’s calm tone.
• keep the original main judgment; only rewrite the method section.

That prevents overcorrection.

A more effective way to give feedback

If you’re not happy with AI’s output, don’t just say:

“This doesn’t work.”

You can say:

“The main problem with this version is…, not….

The specific failure modes are:

• …
• …
• …

Please keep:

• …

Please don’t:

• …

Don’t rewrite the whole thing next. First tell me your… strategy: which parts you plan to change, why, and what problems those changes will solve.”

For example:

“The main problem with this version is structure, not wording.

The specific failure modes are:

• the main question isn’t clear;
• the training mechanism, context mechanism and task mechanism are just laid side by side, without a causal progression;
• the method section is too generic to change how anyone actually uses it.

Please keep:

• the title;
• the real usage situation in the opening;
• the professional but not academic tone.

Please don’t:

• keep adding more concepts;
• just polish the sentences;
• stuff all my feedback into the body;
• pile on jargon to look deep.

Don’t rewrite the whole thing next. First tell me your revision strategy: which parts you plan to change, why, and what problems those changes will solve.”

This feedback is far more effective than “you wrote this badly.”

And far more effective than “polish it a bit more.”

Not because it’s more polite.

But because it’s more actionable.

If you can’t say what’s wrong yourself

That’s very common too.

A lot of the time, all we know is:

“It’s not right.” “It’s not what I want.” “It looks complete, but I can’t use it.” “It seems to be trying hard, but it hasn’t solved the problem.”

But we can’t say where exactly the problem is.

At that point, don’t rush to have AI rewrite it.

Because if you haven’t worked out the level of the problem yourself, AI will easily pick a direction at random.

• It may change the tone.
• It may add content.
• It may get longer.
• It may rebuild the structure.
• It may overturn everything.
• Or it may just try harder to please you.

None of which is necessarily what you really need.

A better approach: first have AI diagnose, rather than revise.

You can ask:

I’m not happy with this output, but I can’t say why yet. Don’t rewrite it. First help me diagnose:

- Is the goal of this task clear?

- Is the input information sufficient?

- Are the success criteria clear?

- Where might your reasoning be unreliable?

- Does the output format suit how it will be used?

- Did it violate any constraint I gave?

- Did it over-accommodate, overcorrect, or steer the problem off course?

- What’s most needed now: clarifying the question, adding information, verifying facts, rebuilding the structure, or only local edits?

Finally, pick only the 2 most likely problems. Don’t list a pile of problems that all sound reasonable. And don’t give a new version yet.

This step turns vague dissatisfaction into problems you can handle.

For example, AI code that’s wrong may not be a matter of “bad code style” but of misunderstanding the requirement. An AI product plan that’s wrong may not be “incomplete” but missing a clear definition of the target user. An AI article that’s wrong may not be “badly worded” but built on an argument that doesn’t hold. AI advice that’s wrong may not be “not smart enough” but missing key background. AI research that’s wrong may not be “poor summarizing” but unreliable sources or the wrong dimensions of comparison.

Each of these is fixed in a completely different way.

So when you don’t know how to give feedback, the most important thing isn’t to have AI keep producing.

It’s to have it stop first and judge which layer the failure happened in.

That’s also why many AI self-reviews get messier the more they revise.

An ordinary self-review easily turns into:

• listing a dozen or so problems;
• each seemingly reasonable;
• then the next version stuffing all of them in.

But review isn’t listing problems.

Review is ranking.

First judge which problem is most critical.

• If the goal is unclear, don’t polish first.
• If information is missing, don’t conclude first.
• If the facts aren’t verified, don’t write a plan first.
• If the constraints aren’t clear, don’t let it brainstorm first.
• If the direction is wrong, don’t do local optimization first.
• If it’s only a local problem, don’t overturn everything either.

Good feedback doesn’t have to be very professional from the start.

But it should at least pull AI back from “keep generating” to “diagnose first.”

When you can’t say what’s wrong, the most useful sentence isn’t:

“Rewrite it.”

It’s:

“Don’t change it yet. Help me figure out which layer it actually failed in.”

Finally

So why does AI’s output suddenly improve once you get angry?

• Not because anger works.
• Not because AI deserves a scolding.
• And certainly not because it suddenly got serious.

The more systematic explanation is:

strong feedback triggers AI’s repair mode; but only when the feedback contains clear failure modes and negative constraints is it more likely to fix the right thing.

If the feedback is only strong in emotion, AI may overcorrect.

It gets longer. Fuller. More strenuous. Quicker to admit fault. But not necessarily more accurate.

What really helps is that:

• the level of the problem becomes clear;
• the way it fails becomes clear;
• what not to do becomes clear;
• what to keep becomes clear;
• the next action becomes clear.

Emotion is just the shell.

What’s truly valuable inside is the error signal and the constraints.

So instead of asking:

“Should I be harsher with AI?”

ask:

“Can I translate my dissatisfaction into clearer failure modes and negative constraints?”

AI isn’t afraid of your anger.

But it depends heavily on the quality of your feedback.

Give it emotion, and it repairs. Give it diagnosis and constraints, and it’s more likely to repair the right thing.