You asked a concrete question — “Should I use Postgres or DynamoDB for this workload?” — and got back four paragraphs of “well, it depends on your access patterns, scale requirements, team familiarity, and budget.” That’s not analysis. That’s the model mirroring an open question with an open answer. Vagueness is almost always a prompt shape problem, not a model capability problem: the same model that hedges on “how should I structure my app” will give a sharp answer to “Given 10k DAU, mostly key-value lookups, and a team that knows SQL — pick Postgres or DynamoDB and defend it in 3 sentences.”
This page walks through the six prompt shapes that produce vague output and the rewrites that pull a real opinion out of the model.
Common causes
Ordered by frequency.
1. Open-ended question, no decision point
Classic offenders:
"How should I structure my React app?"
"What's the best way to handle authentication?"
"Any thoughts on database choice?"The model has nothing to decide between, so it surveys the option space instead of picking. You get a checklist of considerations, not a choice.
How to spot it: your prompt does not name two or more concrete alternatives, and does not end with a verb the model has to fulfill (“pick”, “write”, “rank”, “decide”).
2. No context — model has to guess the situation
If you say “what’s the best caching strategy” with no info on traffic volume, read/write ratio, or existing stack, the model defaults to “it depends” because any specific answer would be wrong for half the audiences it imagines. The hedge is calibration.
How to spot it: read your prompt as if you knew nothing about the project. If you can’t tell which option would obviously be wrong, the model can’t either.
3. No success criterion
“Give me a good answer” — what does “good” mean here? Concrete steps? A ranked list? A code snippet under 50 lines? Without a target, the model produces the median of all possible “good” answers, which is mush.
How to spot it: your prompt does not say what shape the answer should have, what length, or what the user should be able to do after reading it.
4. RLHF politeness on opinion questions
Modern chat models are trained to hedge on subjective questions to avoid offending users with strong takes. Phrasing your question as opinion-seeking (“what do you think about Tailwind”) triggers diplomatic mode by default.
How to spot it: the answer is “there are valid arguments on both sides” energy. The fix is to phrase as a binding decision the model has to defend, not an opinion to share.
5. Asking for a “comprehensive overview”
Words like “comprehensive”, “complete guide”, “everything you need to know” push the model toward breadth over depth. You get 12 bullets at 1-sentence depth instead of 3 bullets at 4-sentence depth.
How to spot it: count concrete artifacts (file paths, numbers, code snippets, commands) in the output. If under 3, depth lost to breadth.
6. Earlier turns established a survey frame
If your first turn was “compare A, B, and C”, later turns inherit the comparative frame. “Now pick one” gets you a ranked list with caveats, not a decision.
How to spot it: scroll up the conversation. If recent turns are about options and tradeoffs, the model is in survey mode regardless of your current ask.
Information to collect
- The exact prompt text and any system prompt.
- Model name and version, temperature, max tokens.
- Conversation history (all prior turns affect the frame).
- The output you got and the output you wanted.
- Domain context the model would need to give a sharp answer.
Shortest path to fix
Ordered by ROI. Steps 1-3 usually solve 80% of cases.
Step 1: Reshape “how” into “pick”
Replace open inquiry with a binding decision:
| Vague prompt | Sharp prompt |
|---|---|
| ”How should I structure my React app?" | "I have 12 routes, 4 of them auth-gated. Pick: single-app-router setup vs nested layouts. Defend in 3 sentences." |
| "What database should I use?" | "Workload: 10k writes/day, 90% reads, joins required. Choose Postgres or DynamoDB. Give the deciding factor in 2 sentences." |
| "Any thoughts on testing strategy?" | "Decide: unit-heavy with Vitest, or integration-heavy with Playwright. Justify based on a 3-person team shipping weekly.” |
The model now has something to fail at — picking the wrong one — which forces it to actually reason.
Step 2: Front-load 5 lines of context
Before the question, paste this template:
Stack: <runtime, framework, key deps with versions>
Scale: <users, requests, data size>
Constraint: <budget, deadline, team size, deploy target>
Tried: <what you already attempted and why it failed>
Goal: <the deliverable, with a success criterion>Example:
Stack: Next.js 14, Supabase, Vercel
Scale: 2k DAU, 200 writes/min peak
Constraint: $50/mo infra budget, single dev
Tried: Connection pooling with PgBouncer; still hit pool exhaustion at peak
Goal: One concrete config or architecture change that survives peak, in <30 LOC diff
Question: ...A 5-line context block converts “it depends” into “given X, do Y.”
Step 3: Forbid hedging vocabulary explicitly
Append:
Constraints on your answer:
- Do not use the words "it depends", "consider", "you might", "perhaps", "various"
- Pick one option and defend it
- Include at least 2 of: file path, command, code snippet, specific number, version pin
- Maximum 200 wordsThis works surprisingly well — RLHF made the model good at following negative constraints when they are explicit.
Step 4: Demand artifacts, not advice
Replace “explain how to X” with “produce the X”. If you want a regex, ask for the regex string, not a regex tutorial. If you want a config, ask for the YAML file, not a discussion of config options.
Bad: "How should I configure this nginx route?"
Good: "Write the nginx server block. Include only the location directives needed. No comments explaining why."Step 5: If still vague, flip the script
If the model genuinely can’t answer because it lacks information, ask it to tell you what’s missing:
"What's the minimum information you need from me to give a specific answer instead of a generic one? List 3-5 questions."Then answer those, paste them in, and re-ask. This converts a one-shot vague answer into a two-turn sharp one.
Step 6: Reset the conversation if survey-mode is sticky
If prior turns established a comparison frame, start a new conversation with only the relevant context. Long threads accumulate framing baggage that you can’t undo with a single follow-up.
How to confirm the fix
- The new answer names a specific choice in the first 2 sentences.
- Output contains at least one runnable artifact (code, command, config).
- A teammate reading the answer can act without asking follow-up questions.
- Word count of “consider/depends/might” is zero.
If it still fails
- Reduce to a minimum prompt: one sentence of context + one decision verb.
- Try a higher-capability model (Opus, GPT-5 Pro); some vagueness is capability-bound on smaller models.
- Try temperature 0.7 for opinion questions — too low can over-hedge.
- Switch from chat UI to a system-prompt-controlled API call; UIs add their own neutrality bias.
Prevention
- Treat every prompt as a function with a return type — name the type before writing the prompt.
- Maintain a personal “anti-hedge” suffix you paste into every opinion-seeking prompt.
- For research-style questions, separate “survey” turn from “decide” turn; never combine.
- Audit your last 10 prompts for “how” — every “how” should be a “do” or a “pick”.
- Use few-shot examples of sharp answers when prompting a new task type.
Related reading
- Long prompt degrades output
- Prompt asks “best” without defining it
- No success criteria in prompt
- AI gives lists when execution is needed
- Output sounds polished but is not actionable
- Prompt Triggered an Unexpected Refusal — How to Reframe
- Too Many Examples Overwhelm the Task
Tags: #Troubleshooting #Prompt #Prompt quality #Vague answer