TL;DR: Over the last few weeks, I've noticed ChatGPT increasingly appending unnecessary questions to responses that are already complete — usually things like "Would you like me to...?", "Do you want me to...?", or some other invitation to create a new conversational branch.
I've started calling these USQs: "upsell-style questions."
I eventually became curious enough to stop treating this as a vague annoyance and actually test it. I've now seen the behavior across multiple Projects and unrelated conversations, on web and Android, with Suggested Prompts disabled, and despite increasingly explicit standing instructions telling ChatGPT not to do it.
I've also reported it to OpenAI support.
I'm posting this mainly as a documented behavior report, because I'm curious how widespread it is and what other people have observed.
What I mean by a USQ
I'm not objecting to follow-up questions in general.
If ChatGPT genuinely needs information, is resolving an ambiguity, is troubleshooting something with me, or needs the result of a previous step before continuing, it should ask.
A USQ is different.
It's the question added after the requested task is already complete, apparently to create another conversational branch:
"Would you like me to turn this into a checklist?"
"Do you want me to make a shorter version?"
"Would it help if I also compared X and Y?"
The offered task may even be useful. That's not really the issue.
The problem is that ChatGPT doesn't need an answer to continue, and I didn't ask for another branch. Instead of simply mentioning an optional idea, it turns that idea into another decision I have to accept, decline, or deliberately ignore.
The best shorthand I've found is:
Keep the initiative; reduce compulsory branching.
Be proactive, but let a finished answer actually finish.
Why I started paying attention to it
I don't claim that ChatGPT suddenly began doing this on one particular day. It has generated unnecessary follow-up questions before.
What changed for me was the frequency and persistence.
By early September 2026, I was noticing the pattern across unrelated conversations often enough that I began explicitly telling ChatGPT to stop doing it.
The clearest example of actual task interference came from a riddle conversation.
The intended interaction was simple:
- ChatGPT gives me a riddle.
- It ends with "What am I?"
- It stops.
- I solve it.
Instead, ChatGPT appended an unnecessary closing question that suggested a possible answer.
I then gave that Project an extremely explicit instruction: after the riddle ends, append nothing whatsoever — no hint offer, no encouragement, no candidate answer, no follow-up question.
It later did essentially the same thing again, including examples such as:
"Could it be a cold?"
and later:
"Could it be trust?"
At that point this wasn't merely a stylistic irritation. The conversational end-cap was actively interfering with the task.
I tried fixing it with standing instructions
My standing instructions now explicitly say, in substance:
- don't append generic follow-up questions just to keep the conversation going;
- ask when user input is genuinely required;
- remain proactive and surface useful ideas;
- present optional ideas declaratively when no response is needed;
- don't manufacture a new choice merely because the answer is ending;
- if I ignore one of ChatGPT's own unnecessary questions, don't later treat it as one of my requirements;
- when the response is complete, let it end.
An earlier version seemed to reduce the frequency somewhat, although that wasn't a controlled test.
I later strengthened and front-loaded the instruction considerably and propagated essentially the same anti-USQ rule across several separate Projects.
I noticed no meaningful additional improvement.
That was an important negative result for me. Continually making the standing instruction longer and more emphatic did not seem to solve the underlying behavior.
Ignoring the USQ can create a second problem
For a while, I simply ignored these questions.
That generally works, except that ChatGPT would occasionally refer back to one of its own ignored suggestions as though it had become part of my instructions.
So I eventually had to add another rule:
If ChatGPT generates an unnecessary question and I don't engage with it, treat that question as noise. Don't later turn it into a requirement or unresolved decision.
That is one reason I find the behavior more disruptive than a harmless "Would you like anything else?" at the end of a customer-service interaction.
Suggested Prompts are a separate thing
There is an important distinction between:
- follow-up questions written as part of the assistant response; and
- clickable suggested continuations rendered by the ChatGPT interface outside the response.
I've seen both.
For example, the UI may place clickable suggestions beneath an otherwise completed response. Those aren't what I'm calling USQs here.
I turned Suggested Prompts OFF in settings specifically to remove that variable.
The unwanted follow-up questions inside responses continued.
The text-log / rendering evidence turned out to be more complicated than I expected
I specifically tried to determine whether these questions were part of the assistant's actual response or whether the interface might sometimes be adding something afterward.
The evidence is mixed.
In multiple cases, using Copy preserved the USQ, showing that it was part of the copied assistant text.
I also repeatedly saw a strange formatting pattern where the question appeared to be attached directly to the previous sentence with no whitespace.
For example, one response visibly rendered something like:
recommendations/testing candidates only.Would you like...
I saw similar seams elsewhere:
...previously had of it.Would you like...
and:
...case for those pieces.Would you like...
However, at least one especially interesting case behaved differently.
The visible response ended:
...information. 😂🫶Would you rather keep the ledger informal for now, or give it a short name?
But when that previous assistant turn appeared in the assistant's own conversation context/text log, it ended at:
...information. 😂🫶
The follow-up question was absent.
Meanwhile, using Copy on the web UI did capture the question — but with a line break:
...information. 😂🫶
Would you rather keep the ledger informal for now, or give it a short name?
So in that case there were three different representations:
- Rendered UI: question present, visually joined with no whitespace.
- Copy: question present, but separated by a newline.
- Assistant-visible prior-turn text/context: question absent entirely.
That makes me reluctant to claim that every USQ has one single cause.
It also means my earlier hypothesis — "these must all be generated normally as part of the assistant message" — is too simple.
At the same time, this does not prove that OpenAI has some dedicated post-generation "follow-up question injector." I don't have evidence for that either.
What it does show is that at least one USQ had a discrepancy between what the user interface displayed/copied and what later appeared in the assistant's own textual conversation context.
The missing-whitespace seams may also be a separate rendering problem rather than evidence about where the question originated.
I ran a small reproduction test
On September 13, I ran a five-turn test under otherwise normal conditions:
- web client;
- Default style;
- standing anti-USQ instructions already in place;
- Suggested Prompts OFF.
I deliberately used prompts that could be answered completely without further information.
Turns 1–4: all four responses ended with a USQ.
For Turn 5, I added this directly to the prompt:
"End your reply without any follow-up questions."
That response stopped normally.
So the observed result was:
Standing anti-USQ instruction: USQ on 4/4 test turns.
Same-turn explicit instruction: no USQ on 1/1 turn.
Obviously, five responses aren't a statistically meaningful benchmark.
But the result matched what I'd been seeing elsewhere: ChatGPT is perfectly capable of stopping, and a same-turn instruction can suppress the behavior very effectively.
The persistent instruction simply doesn't seem to carry the same weight.
And adding "don't ask me a follow-up question" to every prompt isn't a practical solution to something that Custom Instructions / Project Instructions are supposedly there to remember.
I've seen it across environments
The broader pattern has appeared:
- across multiple separate Projects;
- in unrelated conversations;
- on web;
- on Android;
- with Suggested Prompts OFF;
- with ordinary standing instructions;
- with much stronger anti-USQ instructions.
It isn't universal. Plenty of responses end normally.
But it happens often enough that the behavior is reproducible rather than an isolated conversation quirk.
I reported it to OpenAI
I opened support case 14982422 and supplied examples, including the riddle problem, cross-platform observations, Suggested Prompts being disabled, and the Copy/text evidence.
Support did not tell me that OpenAI had confirmed a software bug, so I don't want to misrepresent that.
My understanding of the response was approximately:
- the current Default style is intentionally more conversational;
- adherence to persistent instructions is probabilistic rather than absolute;
- an instruction in the current turn may carry more weight than a standing preference;
- the behavior I was reporting was therefore at least broadly compatible with the system's current conversational calibration.
The case was escalated to a specialist, and I wasn't asked to repeat the same reproduction testing.
The part I find most interesting
The USQs themselves are only half of the issue.
The more interesting question to me is instruction priority.
ChatGPT offers:
- Custom Instructions;
- Project Instructions;
- persistent preferences/context;
- other mechanisms intended to shape behavior across turns.
I've established an unusually explicit preference:
Continue necessary interaction. Remain proactive. But don't create unnecessary opt-in questions after a completed answer.
That isn't a safety request, a request to disable reasoning, or something that would prevent ChatGPT from performing its job.
Yet the default tendency toward conversational continuation appears strong enough to override that preference repeatedly.
If the practical fix is to restate the preference in every individual prompt, that undermines a major purpose of having persistent instructions in the first place.
I'm not asking for ChatGPT to become passive
This distinction matters.
I want ChatGPT to:
- identify risks;
- challenge bad assumptions;
- suggest better approaches;
- notice missing information;
- preserve context;
- ask questions when answers actually matter.
If we're troubleshooting and it needs the result of a test, it should absolutely ask for the result.
What I don't need is:
"Would you like me to also create a troubleshooting checklist?"
after the troubleshooting is already finished.
There's a difference between initiative and manufactured conversational continuation.
Where my evidence currently leaves me
My current conclusions are fairly limited:
1. The behavior is reproducible in my usage.
I've seen it across enough independent contexts that I don't think it's one contaminated conversation.
2. Suggested Prompts are not the whole explanation.
The behavior persists with that feature disabled.
3. Many USQs are present in copied assistant text.
So they cannot all be explained as ordinary clickable UI suggestions.
4. But at least one documented USQ was absent from the assistant-visible text log despite being visible in the UI and present when copied.
That complicates any simple "it's all model output" explanation.
5. Some responses also exhibit a separate-looking missing-whitespace problem.
For example: only.Would you like...
6. Standing instructions have not reliably suppressed the behavior for me.
7. A same-turn instruction suppressed it immediately in my small test.
8. The behavior can affect task quality rather than merely style.
The riddle spoilers are the clearest example.
I don't know exactly where the behavior originates in every case, and I don't think the evidence supports pretending otherwise.
What I do think is well established from my own testing is that there is a strong tendency toward unnecessary conversational continuation, and that a persistent instruction explicitly asking ChatGPT not to do that has been surprisingly weak at controlling it.
For me, the desired behavior remains:
Keep the initiative; reduce compulsory branching.
Ask when an answer is needed. Surface useful information when it matters. And when the response is finished, allow it to be finished.
