Conflicting Instructions Weaken AI Output

When two prompt rules fight, the model averages them into something nobody asked for. Rank your constraints so it knows which to drop.

Published: May 20, 2026 Updated: Jun 18, 2026 Author: AI Productivity Guide Team 🌐 查看中文版本

You wrote a prompt with two reasonable rules: “be concise” and “cover all edge cases.” The model gave you something that is neither concise (it lists six edge cases) nor complete (it skipped the one that matters). Remove the “concise” rule and the answer is genuinely thorough. Remove “cover all edge cases” and the answer is genuinely tight. Each rule alone works; together they cancel. This is a constraint fight: the model cannot maximize both, so it averages, and averages are mediocre.

Fastest fix: find the clashing pair, declare a winner in writing, and put the winner in a NON-NEGOTIABLE block at the top of the prompt while demoting the loser to PREFERENCES (drop if conflict). Both vendors now confirm this is the intended way to resolve contradictions: Anthropic’s guide says to “resolve contradictions before prompting, or explicitly prioritize one (for example, ‘Provide detail, but if in doubt, favor brevity’),” and OpenAI’s Model Spec ranks instructions by source so the model knows what outranks what. The rest of this page shows how to find the hidden fights and rank the rules.

Why averaging happens (and why placement matters)

Two things drive this, both verified as of June 2026:

No tie-breaker. When two rules carry equal weight, the model has nothing to choose by, so it splits the difference. Constraint-based prompting works because ranked rules give it a tie-breaker.
Position bias. Models over-weight the start and end of a prompt and under-weight the middle (the “lost in the middle” effect, still unsolved in production models). Research into instruction following shows single-turn prompts have a primacy bias (the first instruction tends to win) while multi-turn back-and-forth edits show a recency bias (the last thing you said wins). So the same two rules can resolve differently depending on where they sit and whether you are in a fresh turn or a long thread. This is why a contradiction buried mid-prompt is the most dangerous: it is both ignored and unpredictable.

Which fight do you have?

Symptom in the output	Likely conflict	Fix
Long and rambling, but also incomplete	concise vs comprehensive	Rank one; convert the loser to a number
Valid JSON/table but flat, robotic voice	style vs format	Format wins; drop the tone adjective
One-line answer with no reasoning shown	reasoning vs brevity	Split into two passes, or raise the cap
Generic “corporate” voice	two adjectives joined by “but”/“and”	Pick one adjective
Behaves differently across ChatGPT vs a project/API	in-message rule vs system/developer rule	Align them; higher source wins

Common causes

1. Soft adjective vs hard rule

“Make it concise” (soft) vs “include all 7 fields” (hard). The hard rule wins, “concise” is sacrificed, but the model still tries to honor it, leaving output that is neither short nor well structured.

How to spot it: one rule is countable, the other is taste.

2. Style vs format

“Warm conversational tone, return strict JSON” — JSON has no room for warmth. The model picks one, usually format. You get bland JSON with awkward string padding.

How to spot it: the format constraint is structural (JSON, table, schema) and the style constraint is voice (warm, friendly, persuasive).

3. Reasoning vs brevity

“Show your reasoning step by step” plus “answer in one sentence” are mathematically opposite. The model usually picks brevity and hides the reasoning.

How to spot it: both a length cap and a chain-of-thought request live in the same prompt.

4. Conflicting tone targets

“Formal but playful,” “expert but accessible,” “authoritative but humble” — these are tensions, not pairs. The model averages to “corporate.”

How to spot it: two adjectives joined by “but” or “and.”

5. Implicit conflicts from a system or developer prompt

Your user message says “be casual” but a system prompt (or a Custom Instructions / project setting) says “use formal English.” The model obeys the higher-ranked source and ignores your in-message rule, and you cannot see why from the message alone.

This is no longer guesswork. OpenAI’s Model Spec defines an explicit chain of command, highest to lowest authority:

Root  >  System  >  Developer  >  User  >  Guideline  >  Tool/quoted text

User and developer messages are treated alike, “except that when both are present in a conversation, the developer messages have greater authority.” So a project instruction or an API system/developer message will silently outrank what you type in the chat box. Anthropic’s Claude follows the same idea: clearer, higher-context instructions win, and you are told to remove contradictions yourself rather than let the model guess.

How to spot it: the same prompt behaves differently depending on which platform, project, Custom GPT, or API role you run it in.

Before you change anything

Print your full prompt, including any system prompt, developer message, or project/Custom Instructions.
List every constraint, one per line.
For each pair, ask: “if these clash, which wins?”
Test with one constraint removed to see whether the conflict was the bottleneck.
Decide your priority order before you re-prompt.

Information to collect

All constraints from system prompt, developer message, project settings, and user message.
The output you got and which rule it satisfied vs ignored.
A test where you removed one rule — did quality go up?
Model, temperature, and platform (chat UI vs API vs a project).
Whether the conflict is mathematical (length vs detail) or interpretive (tone).

Shortest path to fix

Step 1: List every constraint on one sheet

Get them all visible. Often you wrote 8 rules and forgot that 3 are pulling against the other 5. Include constraints inherited from the system/developer level, not just the ones in your message.

Step 2: Pair them and rank

For each pair that clashes, declare a winner:

Concise vs Comprehensive    -> Comprehensive wins. Length cap removed.
Warm tone vs JSON output     -> JSON wins. Drop "warm" from this prompt.
Show reasoning vs 1 sentence -> Reasoning wins. Length becomes "max 5 sentences".
Formal vs playful            -> Pick one. (You cannot have both.)

Step 3: Move the winner to a “Non-negotiable” block

Put it at the top of the prompt (top placement also dodges the lost-in-the-middle effect):

NON-NEGOTIABLE:
1. Output must be valid JSON matching schema X.
2. All 7 required fields present.
3. Factual claims must cite a source.

PREFERENCES (drop if they conflict with the above):
- Field descriptions short.
- Plain language in description strings.

Models follow ranked constraints far more reliably than equal-weighted ones. If you are calling an API, push the non-negotiables up into the system or developer role, since those outrank the user turn in the chain of command.

Step 4: Convert adjectives to rules

If you keep an adjective, make it measurable so it cannot silently conflict:

Bad:  "Be concise."
Good: "Total output under 150 words."

Bad:  "Be warm."
Good: "Use 'we' at least twice. Avoid the word 'individuals'."

Step 5: Test with a deliberately conflicting input

Feed an input where the constraints obviously fight. If the model still tries to satisfy all of them, your ranking did not land. Re-prompt with a more explicit priority, and add the Anthropic-style tie-breaker phrase: “if you must choose, prefer X over Y.”

Step 6: Separate constraints into two passes

If two constraints truly cannot coexist, split the workflow:

Pass 1: Generate the full comprehensive answer. No length limit.
Pass 2: Compress Pass 1 output to under 150 words. Preserve all facts.

This decomposes the conflict into sequential, satisfiable tasks. It is the most reliable fix for the mathematically impossible pair (full reasoning plus a one-sentence answer).

How to confirm the fix

A second person reading the prompt can predict which rule wins in each conflict.
The model satisfies the non-negotiables on 5 of 5 reruns.
When preferences cannot all hold, the model drops them in the order you declared.
Removing the lowest-priority preference does not change the output (proof it was already being dropped quietly).

If it still fails

There may be a third hidden conflict from a system prompt, developer message, or project instruction. Check all sources, not just your message.
The constraint may be mathematically impossible (a one-sentence answer with full reasoning). Change one side.
Try a different model. Models differ in how reliably they honor ranked constraints, and reasoning-mode variants tend to track multi-step priorities better.
If you must satisfy every constraint, split into multiple passes (see Step 6).

Prevention

Maintain a constraint hierarchy template: non-negotiable / preference / nice-to-have.
Make trade-offs explicit in every prompt: “if you must choose, prefer X over Y.”
Have a peer scan your prompt for contradictions before you run it.
Watch for “but” and “and” between adjectives; they usually hide a conflict.
Audit production prompts quarterly for accumulated constraint conflicts.
When you use both a system/developer prompt and a user prompt, confirm they do not contradict, and remember the higher source wins.

FAQ

Why does the model ignore my length limit but follow the format rule? Format constraints (JSON, schema, table) are structural and easy to verify, so the model anchors on them; a soft length adjective like “concise” has no fixed target, so it loses. Convert “concise” into a hard number (“under 150 words”) and it becomes enforceable.

My prompt works in the API but not in the ChatGPT app (or vice versa). Why? Different surfaces inject different higher-priority instructions. The app may carry Custom Instructions or memory; a project or Custom GPT adds its own system text; the API uses explicit system/developer roles. Per OpenAI’s chain of command, those outrank your user message, so an inherited rule can silently override yours. Print every layer and align them.

Will telling the model “follow all rules equally” fix it? No. Equal weighting is the cause, not the cure. It removes the tie-breaker the model needs. Always rank, even two rules.

Is “if in doubt, favor brevity” a real technique or a hack? It is the documented approach. Anthropic’s prompting guide gives that exact phrasing as the way to resolve a detail-vs-brevity tension. A one-line tie-breaker is often enough to stop averaging.

Two of my constraints are genuinely impossible together. What now? Stop trying to satisfy both in one call. Use the two-pass pattern in Step 6: generate fully in pass one, then transform (compress, reformat, restyle) in pass two. Each pass has a single, satisfiable goal.

External references: OpenAI Model Spec — Chain of Command and Anthropic prompting best practices.

Tags: #Troubleshooting #Prompt #Prompt quality #Prompt engineering