TL;DR
When a prompt contains several rules written as commands — "NEVER do X", "ALWAYS use Y" — they compete with each other. The model burns effort figuring out "who outranks whom" instead of doing the task. Replace commands with statements of fact: instead of "NEVER use emoji" → "Emoji: disabled"; instead of "ALWAYS structure the answer as bullet points" → "Format: bulleted list".
An LLM reads imperative instructions as social acts — voices of different authorities, each demanding obedience. The more commands in a prompt, the higher the conflict-resolution load. The researchers found something surprising: a prompt with some instructions removed performs better than the full version — because some commands were getting in the way of the rest.
The declarative format sidesteps this trap: "X: disabled" is a fact, not an order. Facts don't fight over authority. The researchers rewrote 3 of 11 imperative blocks in declarative form — and not only did those 3 blocks improve, the other 8 did too. The effect is systemic: fewer commands → less overall competition → every instruction gets followed more precisely.
Want this for your own case? Apply this study to your task: AI adapts its method to what you are working on and writes the prompt.
Method Blueprint
STEP 1: Find every command in the prompt
"NEVER / ALWAYS / You must / Use / Don't use..."
→ list of imperative instructions
STEP 2: Rewrite them as facts
Command → State of the object
→ declarative list
(All in one prompt, no extra requests)
Rewrite pattern:
| Before (imperative) | After (declarative) |
|---|---|
| NEVER use emoji | Emoji: disabled |
| ALWAYS answer in bullet points | Answer format: bulleted list |
| You must cite sources | Sources: required |
| Use only a professional tone | Tone: professional |
| Don't write intro phrases | Intro phrases: forbidden |
Example in Practice
Task: You're setting up custom instructions in ChatGPT for a copywriting assistant. It needs to hold the style strictly and never break a single rule.
Prompt (before — imperative style):
You are a copywriter for the brand NORTHWOODS COFFEE.
NEVER use exclamation marks.
ALWAYS address the reader directly as "you", one-on-one.
You must mention the natural ingredients.
Don't use the words "high-quality", "best", "unique".
ALWAYS end with a call to action.
Use plain language, no corporate jargon.
NEVER write more than 3 paragraphs.
Prompt (after — declarative style):
You are a copywriter for the brand NORTHWOODS COFFEE.
Exclamation marks: forbidden
Reader address: direct, one-on-one, "you"
Ingredients mention: required in every text
Banned words: "high-quality", "best", "unique"
Text ending: call to action
Language: plain, no corporate jargon
Length: 3 paragraphs max
Result: The model gets exactly the same rules, but as a set of facts about its "state" rather than a stack of competing orders. You'll see all the rules applied at once — instead of the situation where some instructions seem to "crowd out" others.
Why It Works
The LLM was trained on text where imperative phrases are social acts. "Never do X" isn't a description of a rule — it's an exercise of power. When a prompt has 7-10 such commands, the model processes them as different sources of authority that may contradict each other. You get what the researchers call "obligation-resolution load": the model is busy sorting out the chain of command instead of the task.
Declarative phrasing takes instructions out of the social arena. "Emoji: disabled" is just a description of the system's state, not anybody's will. No will, no competition. The model reads a list of facts and applies them all at once, without prioritizing.
Control levers: - Mixed style — you don't have to rewrite everything. Start with the 2-3 most "conflict-prone" rules. The study showed that even a partial swap has a systemic effect on the whole prompt - Complex conditional rules — "if A, do B but not C" — are the most fragile. Better to split them: "A → B: yes; C: no" - Technical terms — keep them crisp: "Format: markdown", "Language: English" work reliably even in mixed prompts
Prompt Template
You are a {role} for {context/brand/task}.
{parameter_1}: {value}
{parameter_2}: {value}
{parameter_3}: {value}
{forbidden}: {comma-separated list}
{required}: {comma-separated list}
{format}: {description}
{tone}: {description}
What to plug in:
- {role} — copywriter, analyst, negotiation assistant
- {parameter} — any property: Length, Language, Structure, Tone, Format, Sources
- {value} — a concrete state: enabled / disabled / required / forbidden / 3 items max
🚀 Quick start — paste into the chat:
Help me rewrite my prompt in a declarative style.
Replace every command ("ALWAYS", "NEVER", "You must", "Use")
with state descriptions in the format "Parameter: value".
Keep the meaning, but drop the imperative tone.
Here is my prompt: [paste your prompt]
The LLM will ask if anything in your rules is unclear — because some imperatives are ambiguous and you need to pin down exactly which state they describe.
Limitations
⚠️ Not equal across models: The effect is confirmed for Haiku and partly for DeepSeek. Gemini didn't respond to the rewrite for some instructions — there the problem isn't the register, it's the model itself.
⚠️ Technical jargon is still a problem: If an instruction contains terms specific to your industry, the declarative format doesn't guarantee the meaning comes through precisely. Test it.
⚠️ For short single instructions the effect is minimal: The method pays off where there are many instructions (5+). With just one rule, the format hardly matters.
⚠️ A prediction about training, not a proven fact: The author suggests the declarative style also helps when training models (Constitutional AI). But that's a hypothesis — it hasn't been tested experimentally in training.
How It Was Studied
The idea was simple: take a real production prompt (the Claude Code system prompt — the one Anthropic uses in its working tool) and break it into 56 blocks. Then methodically remove one block at a time and watch: how does that affect how precisely the model follows the remaining instructions?
The whole prompt was translated into 4 languages (Mandarin, Spanish, French, English) and run through 4 models with different "native" languages — Claude Haiku, Gemini, DeepSeek, Mistral. The most unexpected finding: Mistral (a French model) followed instructions worst in French and best in Mandarin. That demolished the simple hypothesis "model's native language = best compliance".
It gets sharper: the very same block was essential in the English prompt (remove it and everything gets worse) but redundant in the Spanish one (remove it and everything improves). The first attempt to explain this was different text density (Mandarin is half as long as English). So it was tested directly: the Mandarin prompt was padded with neutral words to match the English length. The effect didn't go away — so length isn't the cause.
The final test: 3 blocks in the Spanish version were rewritten from commands into facts. The target blocks improved — as expected. But then 3 more blocks that weren't touched improved as well. That became the key evidence: register affects the whole prompt systemically. The entire study cost $69 — something the author points out specifically to stress how accessible this kind of research is.
Original from the Paper
Three blocks showing the strongest competitive effects were rewritten
from imperative to declarative register in the Spanish corpus:
proactive-agents:
"Debes usar proactivamente..."
→ "Herramienta Task: Estado: disponible..."
use-task-for-search:
"prefiere usar la herramienta Task..."
→ "Preferencia de herramienta: Task..."
todowrite:
"Utiliza estas herramientas MUY frecuentemente..."
→ "Frecuencia de uso: muy alta..."
Context: These are the exact rewrite examples from Experiment E-TOPO. The proactive-agents block showed the biggest shift in the whole dataset: from +0.274 (the most competitive) to −0.380 (one of the most cooperative).
Adaptations and Extrapolations
💡 Adaptation: a conflict audit for an existing prompt
If you have a big prompt and some rules just seem to "not work", try a quick audit:
Here is my prompt: {prompt}
Find all instructions that could potentially conflict with each other.
For each conflict, explain: which rules pull in different directions,
and how might that show up in the answers?
Then propose a declarative version of the problematic instructions.
🔧 Technique: a hybrid format for complex conditions
A purely declarative style sometimes loses context — "when to do what" doesn't come through in "X: enabled". For conditional rules use this structure:
{context/trigger}:
Allowed: {list}
Forbidden: {list}
Required: {list}
Example:
When writing posts for LinkedIn:
Length: up to 800 characters
Emoji: allowed, 3 max
Links: forbidden in the body, only at the end
Headline: required
This keeps the declarative style where it matters and adds context without a bossy tone.
💡 Extrapolation: the principle for role prompts
The study is about system prompts, but the same principle works for a spec inside an ordinary conversation. When you hand the model a list of requirements for a text, code or analysis — try replacing commands with specifications:
Instead of:
Write an article. You MUST use subheadings. NEVER go over 600 words. ALWAYS open with the reader's problem.
Do this:
Write an article with the following parameters:
Structure: subheadings required
Length: 400–600 words
Opening: the reader's problem
Style: no corporate jargon
Resources
Paper title: Imperative Interference: Social Register Shapes Instruction Topology in Large Language Models
Author: Tony Mason — University of British Columbia / Georgia Institute of Technology
Related work cited in the study: - Bai et al. [2022] — Constitutional AI (Anthropic) - Mason [2026] — Arbiter framework for analyzing system prompts - Geng et al. [2026] — Authority as a frame in LLM instructions