Salience Reminder: How to Keep a Model from "Forgetting" Format Requirements Under Load

Everything happens in a single prompt:

STEP 1: Open with → "IMPORTANT FORMAT REQUIREMENT: [requirement]"  
STEP 2: Write → [the main task]  
STEP 3: Close with → "Make sure to follow ALL the format requirements above"

Task: You asked Claude to write a breakdown of a business idea: a delivery service for premium restaurant food in New York. At the end — a score from 1 to 10 with a rationale. This is a task with a "terminal" requirement: do something at the end of the answer. Without a reminder, there's a high risk Claude gets carried away with the analysis and simply never gives the score.

Prompt:

IMPORTANT FORMAT REQUIREMENT: End your answer strictly with the block 
"SCORE: X/10 — [one sentence of rationale]"

I want to break down a business idea: a delivery service for dishes from 
premium New York restaurants (average check from $150) 
with courier-waiters who set the table on site. 

Analyze:
— Real market demand and the target audience
— Key operational challenges
— The competitive landscape (DoorDash, Uber Eats)
— Unit economics: where the money comes from, where the holes are

Make sure to follow ALL the format requirements stated above.

Result:

The model will produce a detailed analysis of each point. Without the Salience Reminder structure, there's a high chance that during the in-depth analysis it "forgets" the final score block or outputs it in a random format. With the reminder, the answer ends strictly with the block SCORE: X/10 — ... and a one-line rationale, which is handy for comparing several ideas side by side.

The LLM's weakness: The model generates text sequentially — token by token. When a task demands thinking about the content (analysis, math, long text), the "do something at the very end" requirement simply stops actively shaping generation. The instruction was at the start of the prompt — by the end of the answer it's "far away". The model doesn't "forget" in the human sense, but the generation pattern shifts toward the task.

The LLM's strength: The model responds well to whatever is right next to it at the moment. Signals close to the end of the current generation carry a lot of influence. That also explains why "don't do this" requirements (don't use commas) hold up: every token is a new opportunity to check whether the rule is being broken.

How the method uses this: A reminder at the end of the prompt literally "brings" the requirement closer to the moment the model will start fulfilling it. An explicit "IMPORTANT REQUIREMENT" tag at the start adds priority in the overall context. Two signals — before and after the task — frame the instruction so it doesn't get lost.

Control levers: - The harder the task, the more important it is to use this template. For simple questions it's optional. - The more "terminal" the requirement (a specific phrase at the end, JSON, a numbered list), the bigger the effect. - Stacking 3+ requirements — the reminder at the end is a must; without it compliance drops sharply. - The reminder text can be made specific: instead of "follow all the requirements" write "follow ALL the requirements: end with phrase X, output JSON, use only numbered lists".

IMPORTANT FORMAT REQUIREMENT: {format_requirement}

{main_task}

{additional_instructions_if_needed}

Make sure to follow ALL the format requirements stated above.

Placeholders: - {format_requirement} — a specific rule: "answer strictly in JSON format", "end with the phrase "Summary:"", "use only a bulleted list", "use no more than 5 points" - {main_task} — your entire main request - {additional_instructions} — an optional block if there's extra context

For several requirements — list them all in the first block:

IMPORTANT FORMAT REQUIREMENTS:
1. {requirement_1}
2. {requirement_2}
3. {requirement_3}

🚀 Quick start — paste into the chat:

Here's the Salience Reminder template for complex tasks with format requirements. 
Adapt it to my task: [your task].
Ask me questions to fill in the fields.

[paste the template above]

The LLM will ask about the format requirement and the main task — because without them it can't place the reminder "frame" correctly. It will take the template's structure and fill it in for your case.

⚠️ Stacking 5+ requirements: Even with a reminder, meeting all of them at once drops off. For o4-mini — from 99% with one requirement to 47.5% with five. If you need lots of formatting constraints, split them across several requests or keep only the most important ones.

⚠️ Reverse interference: Complex formatting lowers the quality of the answer itself. For o4-mini on math tasks, accuracy dropped from 93% to 27% with active format requirements. If the task requires deep reasoning, keep the requirements simple or ask it to think first and format second.

⚠️ Unpredictability under heavy load: Compliance doesn't always drop linearly. Sometimes a model handles three tasks worse than five — it depends on the specific model. Don't count on "easy task = nothing needed".

⚠️ Requirements "in the middle" of the answer: The study covered two poles — "at the end" and "continuously". Requirements like "in the third paragraph, do X" weren't specifically tested, but they're probably vulnerable too.

A researcher at Microsoft took 15 types of formatting instructions — from "write in all caps" to "end with a JSON block" — and paired them with a task of increasing difficulty: first a trivia question, then a reasoning test, then multi-step math, then a long article summary. That came to over 8,000 prompts — three models (o4-mini, DeepSeek-V3.1, Llama-3.3-70B), three independent runs each.

A key design choice: no LLM-as-a-judge. Compliance with each requirement was checked by deterministic code — either the JSON is valid or it isn't; either the phrase is at the end or it isn't. That removes the noise of subjective scoring.

The most interesting part: models with the reminder didn't just recover to their original level — they exceeded the baseline. In other words, the standard prompt format without a reminder chronically underuses what the model can do. Another surprise: o4-mini — a "reasoning" model — turned out to be especially vulnerable when doing math and formatting at the same time. It seems to spend its "thinking budget" on the format at the expense of the math, which regular instruction-tuned models don't do as sharply.

💡 Adaptation: the "sandwich prompt" for long conversations

If you're working in a long thread and the model has started breaking rules set earlier, remind it right in the next message:

A reminder about the format requirements we set earlier: {requirement}.

{new task}

Make sure to follow this requirement.

The study showed that format's main enemy is the "time gap" between the instruction and the moment it has to be carried out. In a long conversation that gap is huge. An explicit reminder in the new message works on the same logic.

🔧 Technique: a specific reminder → more reliable than a generic one

Instead of "follow all the requirements", spell out exactly what:

❌ Make sure to follow all the format requirements stated above.

✅ Required: end your answer with a line "CONCLUSION:" containing one sentence 
   and use only numbered lists, no bullets.

The study showed that terminal requirements are vulnerable because they lose "salience" toward the end of generation. A specific reminder restores that salience more precisely than a generic phrase.

🔧 Technique: separate reasoning from formatting

The o4-mini result (93% → 27% on math with active formatting) leads to a simple hack for complex analytical tasks:

STEP 1. First solve the task, think out loud, don't think about the format.

[task]

STEP 2. Now take your answer above and format it strictly like this:
{format_requirement}

Two separate requests — or two explicit stages in one. The model thinks first, then formats. It doesn't split its "attention" between both tasks at once.

Did You Forget What I Asked? Prospective Memory Failures in Large Language Models Avni Mittal — Microsoft ([email protected])

Related work mentioned in the study: - IFEval (Zhou et al., 2023) — a set of verifiable instructions for evaluating format following - FollowBench (Jiang et al., 2024) — how compliance drops as constraints accumulate - Lost in the Middle (Liu et al., 2024) — positional sensitivity in long prompts