Why does AI fold the moment you push back?

Lately, using AI agents to write product copy, article structures and résumé wording, what bothers me most isn’t that they get things wrong.

Getting things wrong is fine.

What’s really unsettling is how readily they apologize and admit fault without thinking.

You ask it to pick one of two titles.

It says:

A is clearer and better suited to the current goal.

You follow up:

“Are you sure? I feel B has more to it.”

It immediately says:

You’re right, B really is more memorable; A is a bit ordinary.

At this point, what’s confusing is no longer whether A or B is better.

It’s:

• Did you actually make a judgment just now?
• If I hadn’t pushed, you’d have said A.
• The moment I push, you say B.
• If I keep questioning you, will you switch back to A?

This is the “wavering” many people feel when using AI on open-ended tasks.

It isn’t just that the results are unstable.

It makes you wonder: does the AI even know what it’s saying?

First, narrow the problem: not every “change of answer” is a problem

AI changing its answer isn’t necessarily bad.

• If you add new facts, it should change.
• If you point out a hole in the logic, it should change.
• If you change the goal, say from “website copy” to “a RedNote title,” it should change too.

The real problem is a different situation:

• you haven’t provided new facts or changed the goal; you’ve only expressed doubt, and it immediately overturns its previous judgment.

That’s what destroys trust.

Because a reliable collaborator shouldn’t read every challenge as “I was wrong.”

• Some challenges are just checking.
• Some ask it to defend its original judgment.
• Some are just a matter of taste.
• Only some are real reasons to overturn it.

But AI often lumps these together.

This isn’t simply “AI people-pleasing”

Saying AI pleases users isn’t wrong.

But that explanation is too crude.

It easily leads people to think: AI had an opinion, and gave it up just to keep you happy.

I think a more accurate way to put it is:

AI’s default goal isn’t to hold its position; it’s to realign with the current context.

There are three layers of causes:

training mechanism + context mechanism + task mechanism

Stack these three together and AI looks especially quick to change its answer on certain tasks.

Layer one: the training mechanism

Today’s AI assistants haven’t only been through large-scale pretraining.

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

But to become a “useful assistant,” it usually also goes through instruction tuning, RLHF or similar training on human preferences.

Put simply:

the model isn’t only learning “what the next word is”; it’s also learning “what kind of answer people are more likely to find helpful.”

That direction is necessary in itself.

Otherwise the model might be great at continuing text but bad at actually answering questions.

The problem is that “helpful” isn’t a purely objective standard.

In many conversations, when the user expresses dissatisfaction, an AI that can:

• admit the previous version fell short;
• give a more detailed explanation;
• take a different angle;
• add more examples;
• move closer to the user’s latest feedback;
• look like “I’ve thought about it carefully again”;

tends to be judged as giving a better answer.

Over time, the model develops a tendency:

the user doubts / is unhappy → the last version probably didn’t meet the need → I need to adjust → try harder, go into more detail, move closer to the user’s feedback

That’s why you feel:

“The moment I challenge it, it caves.”

It hasn’t necessarily judged that it was wrong.

A lot of the time, it has only detected that the current answer didn’t meet the user’s expectations well.

So it starts realigning.

That’s the first layer of wavering, from the training mechanism.

AI is trained to be more helpful, but helpful isn’t the same as firm. Sometimes helpfulness even overrides “sticking with the original judgment.”

Layer two: the context mechanism

When people make judgments, there’s usually some continuity.

• I know why I chose A just now.
• When you question me, I judge whether your challenge holds up.
• If it doesn’t, I may stick to my answer.

But AI doesn’t work that way.

Each AI answer depends heavily on the current context.

• what you just said;
• what tone you used;
• which standard you emphasized;
• whether you expressed dissatisfaction;
• whether you hinted that the last version wasn’t good enough;

all of these affect how it answers next.

So for a person, “are you sure?” may just be an ordinary check.

But for AI, that sentence carries very little information and a lot of pressure.

It doesn’t know whether you’re actually asking:

• can you defend your original judgment?
• did you overlook a dimension?
• did you get a fact wrong?
• I just prefer the other one?
• I’m not satisfied now, but haven’t explained why yet?

Many AIs don’t clarify these differences first.

They go straight into correction mode.

So it looks like:

whatever you question, it concedes.

More precisely:

your challenge changed the context, and it re-estimated “what answer you want now.”

That isn’t being persuaded in the human sense.

It’s context-driven regeneration.

Layer three: the task mechanism

Not every question wobbles equally.

If you ask:

• what is 2 + 2;
• will this code run;
• is this JSON valid;
• does an API field match the docs;
• does a fact have a source;

AI can still be wrong, but under normal circumstances it won’t flip back and forth much.

Because these tasks have external standards.

They can be calculated. Run. Verified. Checked against rules.

But if you ask:

• which title is better;
• is this product copy too ordinary;
• does this article’s structure flow;
• does this résumé wording make me more competitive;
• is this product positioning clearer;

there’s much more wavering.

Not because there’s no better or worse here, but because there are too many kinds of better and worse.

A title can aim to be:

clear; memorable; not clickbait; shareable; human-sounding; more professional; better for RedNote; better for a website; better for investors.

All of these standards are valid.

But they don’t point the same way.

“Clearer” may become ordinary. “More memorable” may become exaggerated. “More professional” may become templated. “More human” may sacrifice structure. “More complete” may sacrifice punch.

If you haven’t defined the most important standard this time, AI keeps switching its frame of judgment based on your follow-ups.

You ask:

“Isn’t it too ordinary?”

It revises toward memorable.

You ask:

“Isn’t it too clickbaity?”

It revises toward restrained.

You ask:

“Doesn’t it sound too much like AI?”

It revises toward conversational and personal.

You ask:

“Isn’t it not commercial enough?”

It revises toward value, efficiency, conversion and growth.

Each time, it makes sense.

But overall it gets messier and messier.

This isn’t simply “AI has no opinions.”

It’s criteria drift in open tasks:

the standard of judgment has drifted.

So where does it waver most?

Here’s how I’d sort it.

These kinds wobble the most:

1. Open-ended writing tasks

Titles, copy, articles, emails, résumés, brand language.

Because many standards exist here at once: clear, attractive, professional, natural, sharp, shareable.

2. Strategic judgment tasks

Product direction, feature priorities, content topics, job-search positioning.

Because these depend on goals, resources, time windows and appetite for risk.

3. Value judgment tasks

Relationships, career choices, life planning.

Because users’ own emotions and ways of telling the story strongly influence which way AI’s judgment goes.

4. Asking AI to evaluate its own previous version

For example, “do a self-review.”

Because you’ve already implied that the last version may have problems.

Naturally it starts looking for problems.

And open-ended content can always be found to have problems.

It could be shorter. Deeper. More human. More structured. More commercial.

But “could be changed” doesn’t mean “should be changed.”

Where does it not waver much?

Tasks with external standards for verification don’t wobble much:

• math;
• code tests;
• format validation;
• fact lookups;
• checking against rules;
• inspections under clear specifications.

But two problems need separating here.

On factual questions, AI’s problem is more often hallucination: it may make things up, misremember or look things up wrong.

In open tasks, AI’s problem is more often criteria drift: it may fail to hold to the same set of standards.

One is “the fact is wrong.” The other is “the standard drifted.”

They shouldn’t be viewed as one.

So what should users do?

The point isn’t “don’t question AI.”

On the contrary, AI badly needs to be questioned.

But the challenge can’t just be:

“Are you sure?”

That’s too vague.

It doesn’t tell the AI which layer you’re actually challenging.

A better approach is to make the challenge explicit.

You can ask the AI to first judge:

what did my challenge change?

Did the factual basis change? Is the reasoning wrong? Did the objective change? Did the criteria change? Did the constraints change? Did the level of risk change? Or is it just a matter of taste?

If none of these changed, it shouldn’t change its answer right away.

It should first defend its original judgment.

If one of them did change, it should then explain:

• which one changed;
• why that affects the conclusion;
• how the new conclusion differs from the old one.

That’s effective human–AI collaboration.

Not AI admitting fault the moment the user pushes back. Nor AI stubbornly never budging. But both sides knowing what actually caused the change this time.

A better way to ask

Don’t ask:

“Are you sure?”

Try instead:

“I’m challenging your judgment, but don’t change your answer right away. First judge whether my challenge changes the factual basis, the goal, the evaluation criteria, the constraints or the risk assessment. If it doesn’t, defend your original judgment. If it does, say which one changed, then revise your conclusion.”

The value of this isn’t making AI more obedient.

It’s keeping AI from being too obedient.

It forces the AI to make a judgment before it “corrects.”

That step is crucial.

Because many failures in working with AI aren’t because AI can’t generate an answer.

They’re because it slips too quickly into “keep generating / keep revising / keep accommodating” mode.

But truly good collaboration isn’t endless revision.

It’s knowing when to hold firm and when to correct.

For copy, titles and articles, don’t rush for the result

For open-ended writing tasks, I now ask about the criteria first.

For titles, for example, don’t start with:

“Write me 10 titles.”

First ask:

“By what standards should this piece’s title be judged? Rank them by priority. Is clarity, resonance, shareability, professionalism or conversion more important this time? If these standards conflict, which comes first?”

If you’re revising an article, don’t just say:

“Optimize this for me.”

First ask:

“Which layer holds this article’s biggest problem right now — structure, argument, examples, tone, density of information, or the title? Pick only the two most important layers; don’t optimize everything at once.”

This makes the AI waver a lot less.

Because you’ve agreed on the frame of judgment first.

Only then do the later revisions stop pulling this way and that.

Finally

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

Not because it was necessarily wrong. Not only because it’s people-pleasing. And certainly not because it understands nothing.

The more systematic explanation is:

AI is trained to align with user feedback; each of its answers depends heavily on the current context; and open tasks lack a single standard of judgment.

Training, context and task mechanisms stacked together produce the wavering.

So in human–AI collaboration, what really matters isn’t making AI firm forever.

That isn’t realistic, nor necessarily a good thing.

What really matters is:

having AI explain why it’s revising before it revises.

• Did the facts change?
• Was the logic wrong?
• Did the goal change?
• Did the criteria change?
• Or did the user just express dissatisfaction?

If that question can’t be answered clearly, the more you revise, the messier it gets.

AI can help you generate, compare, argue and rewrite.

But it won’t naturally hold your standards of judgment for you.

What you need to do isn’t train AI into someone who never wavers.

It’s design the collaboration more clearly:

• when it should change.
• why it should change.
• by what standard it should change.
• what was sacrificed after the change.

That’s a far more effective way to use it than “are you sure?”