Apply to my task
arXiv:2507.05573 ★ 84 Jul 8, 2025

Model drift: why prompts break when an LLM gets upgraded, and how to write one that survives

Key result

After every model upgrade, prompts start to misfire, and it's not a bug but a pattern: new LLMs follow instructions more precisely but are worse at filling the gaps you didn't spell out. The prompt migration method lets you write requests that hold their quality through any version change. The essence: turn the prompt from a request into a spec with explicit sections: role, instructions, format, data. Each part goes in its own XML tag, so the model sees a clear map and stops guessing which parts are commands and which are context. This removes the main cause of post-upgrade failures: confusion between data and instructions.

PromptMigration: Stabilizing GenAI Applications with EvolvingLargeLanguageModels

Key Aspects of the Research:

The study shows that when large language models get a version upgrade (for example, from GPT-4 to GPT-4.1), old prompts that used to work well can start to fail and produce poor results. This phenomenon is called "model drift." To keep answers stable and reliable, prompts need to be adapted, becoming far more structured, detailed, and explicit.

Key Result: A systematic shift to stricter, more detailed prompts fully restores the answer reliability lost in a model upgrade.


The Core of the Method, Explained:

The essence of "prompt migration" is consciously changing how you write prompts in response to how LLMs evolve. Where you once could rely on the model to "read between the lines" and pick up implicit hints, newer, more powerful models behave like "smart but literal servants": they follow instructions more precisely but are worse at catching what isn't said outright.

In practice, this means your prompts should start to look like a spec for a contractor who won't take any initiative.

The technique for users:

  1. Be extremely explicit: Don't count on the model figuring it out. If you want a list, write: "Give the answer as a numbered list." If you want a particular tone, specify: "Answer style: businesslike and restrained."
  2. Use a clear structure: Instead of a solid block of text, organize the prompt into sections. The study recommends this structure:
    • Role and Goal: Who the model should be and what the end goal is.
    • Instructions: Step-by-step directions on what to do and how.
    • Formatting rules: A clear description of what the answer should look like (for example, "put headings in bold," "use a markdown table").
    • Examples (Few-shot): Show 1-2 examples of an ideal request and answer.
    • Context: Provide all the necessary information, clearly separated from the instructions.
  3. Use delimiters: So the model doesn't confuse instructions with context, use clear delimiters. The study found that XML tags (for example, <CONTEXT>...</CONTEXT>) work more reliably than ordinary bullet markers or JSON.

This technique turns your prompt from a request into a clear order, minimizing the chance that the upgraded, more "literal-minded" LLM misinterprets it.


Practical Applicability Analysis:

  • Direct applicability: Very high. Anyone can start improving their prompts right away by adding more structure and explicit rules and using XML tags for markup. For example, instead of "Summarize the text," write: "You are a business analyst. Analyze the text below and present a summary as 3 bullet points. <TEXT>...

  • Conceptual value: Huge. The study gives users a key insight: an LLM is not a static entity. Its behavior changes over time. That explains why old prompts "break," and it teaches users not to get discouraged but to adapt, treating prompting as an ongoing process rather than a one-time setup.

  • Adaptation potential: Maximum. Although the study is built on a technical example (SQL generation), its conclusions are completely universal. The adaptation mechanism is simple: take any task of yours (writing an email, creating a content plan, analyzing a review) and apply the principles of explicitness and structure to it. Instead of asking to "write an email to a client," you build a structured prompt with sections: <EMAIL_GOAL>, <CLIENT_INFO>, <KEY_POINTS>, <TONE_REQUIREMENTS>.


Practical Example:


You are an experienced social media manager specializing in promoting local coffee shops.



Create a content plan of 3 Instagram posts for the "Morning Breeze" coffee shop to attract new customers this week.



- **Coffee shop name:** "Morning Breeze"
- **This week's promotion:** 20% off the new "Salted Caramel" latte.
- **Target audience:** Students and freelancers looking for a cozy place to work.
- **Features:** Fast Wi-Fi, plenty of outlets, small dogs welcome.



1.  Come up with 3 unique Instagram post ideas.
2.  Each idea must target the target audience.
3.  Be sure to mention the "Salted Caramel" latte promotion in at least one post.
4.  Highlight the work-friendly perks (Wi-Fi, outlets).



Provide the answer as a numbered list.
For each post, include:
- **Headline:** Short and catchy.
- **Post copy:** The main content (3-4 sentences).
- **Call to action (CTA):** What the user should do.
- **Hashtags:** 5-7 relevant hashtags.

**Rule:** Do not use emoji.

Why It Works:

This prompt is effective because it follows the "prompt migration" methodology directly, lowering the risk that the model misinterprets it:

  • A structure built on XML tags: The <ROLE>, <OBJECTIVE>, <CONTEXT>, <INSTRUCTIONS>, <OUTPUT_FORMAT> tags clearly separate the different parts of the request. The model won't confuse the context (information about the coffee shop) with direct instructions.
  • Maximum explicitness: Instead of a general "come up with some posts," it gives clear directions: "3 unique ideas," "targeted at the audience," "mention the promotion."
  • A clear output format: The <OUTPUT_FORMAT> section leaves the model no room to improvise. It dictates exactly which parts the answer must contain (Headline, Copy, CTA, Hashtags), which ensures a consistent, predictable result.
  • Negative constraints: The rule "Do not use emoji" is an example of an explicit instruction that prevents unwanted model behavior and makes the result more professional.

Another Practical Example


You are an HR assistant. Your job is to help me prepare for a job interview.



Analyze the job description and my experience, then generate 5 likely questions I may be asked in the interview, plus brief talking points for answering them.



**Position:** Product Manager at an EdTech startup.
**Responsibilities:**
- Market and competitor analysis.
- Building and prioritizing the backlog.
- Working with the development team (writing tickets, accepting work).
- Analyzing product metrics (MAU, Retention, LTV).
- Running CustDev interviews.



- 3 years as a marketer at a tech company.
- Launched ad campaigns and analyzed their performance.
- Ran customer surveys to improve the product.
- Taught myself SQL for data analysis.
- No direct experience working with a backlog or a development team.



1.  Compare the requirements in `` with my experience in ``.
2.  Identify 3 strengths (where my experience matches the requirements) and 2 weaknesses (where there are gaps).
3.  Write 5 interview questions that will most likely probe both the strengths and the weaknesses.
4.  For each question, suggest 2-3 key talking points that highlight my strengths and smartly explain the gaps in my experience.



Present the result as follows:
**Likely question 1:** 
- **Talking points:**
  - 
  - 

**Likely question 2:** 
... and so on.

Why This Example Works: The Mechanism.

This prompt works by decomposing and structuring a complex analytical task as much as possible, which fits perfectly with how modern LLMs behave:

  • Separating the data: Using the <VACANCY_DESCRIPTION> and <MY_EXPERIENCE> tags cleanly isolates the two data sources. This keeps the model from "mixing" them and helps it analyze each block in turn.
  • A step-by-step thought process: The <INSTRUCTIONS> section effectively mimics the "Chain-of-Thought" technique. It doesn't just ask for the end result ("give me questions"); it prescribes a logical sequence of actions: 1. Compare, 2. Find strengths/weaknesses, 3. Write questions based on the analysis, 4. Prepare talking points. This channels the model's "reasoning" in the right direction.
  • Focusing on gaps: The instruction "write questions... that probe both the strengths and the weaknesses" is very explicit and pushes the model to do a deeper analysis instead of just superficially matching keywords.
  • Control over the result: As in the first example, <OUTPUT_FORMAT> guarantees the final answer will be structured, useful, and easy to read, eliminating the risk of getting an unreadable wall of text.

Usefulness Score: 92

02

Main Evaluation Criteria

  • A. Relevance to prompting techniques: Yes, the study proposes a concrete prompt structure (Role, Instructions, Reasoning Steps, Output Format, Examples, Context) and shows with examples how to make prompts more explicit and structured.
  • B. Better conversational answers: Yes, the study's main goal is to restore and stabilize the quality and reliability of LLM answers after an upgrade.
  • C. Direct practical applicability: Yes, users can immediately apply the principles of structuring and making instructions more explicit in any chatbot, with no code or special tools.
  • D. Conceptual value: Very high. The study introduces the fundamental concept of "model drift" and explains why prompts that worked yesterday may break today. It gives users the right "mental model": an LLM isn't a static tool but an evolving system that requires prompts to adapt. The idea that new models are becoming "smart servants" rather than "flexible craftsmen" is a key insight for any user.
  • E. A new useful practice (clustering): The work falls into several key clusters at once:
    • 1. Prompt phrasing techniques: Proposes a stricter, more detailed structure.
    • 2. LLM behavioral patterns: Explains that new models need more explicitness and handle implicit instructions worse.
    • 3. Prompt structure optimization: Recommends XML tags for markup and a clear description of the output format.
    • 7. Reliability and stability: The entire work is devoted to methods for making answers more reliable and consistent.
  • Practicality checklist (+15 points): Yes, the study provides ready-made constructions, explains how to structure requests, reveals non-obvious LLM behavior (weaker implicit inference in newer versions), and offers ways to improve accuracy and stability.
03

Numerical Usefulness Score

The score of 92 points reflects the enormous practical and conceptual value for any regular LLM user. The study tackles one of the most common and frustrating problems: "Why did my perfect prompt stop working?" It doesn't just offer a fix; it explains the root cause, which is the evolution of the models themselves.

Arguments for a high score: 1. Explaining an "invisible" problem: Users often blame themselves or assume the LLM is "getting dumber," when in fact its behavior is changing. The paper gives a clear explanation (model drift) and takes away the frustration. 2. A universal principle: The idea of moving from flexible prompts to stricter, more structured ones applies to absolutely every task, from writing emails to analyzing data. 3. Concrete tactics: The recommendations to use a "Role -> Instructions -> Format" structure and XML tags for markup are ready-made tools you can use immediately.

Counterarguments (why the score isn't 100): * Technical context: The paper's main example (generating SQL queries for the Tursio enterprise application) is fairly complex and far removed from an everyday user's tasks. It takes some mental effort to transfer these findings to your own scenarios (for example, generating social media posts). * Developer focus: The paper is aimed primarily at GenAI application developers (the concept of a "migration test bench," CI/CD). Everyday users have to "extract" the principles useful to them from a broader, technical context.


Research digest

Key result

After every model upgrade, prompts start to misfire, and it's not a bug but a pattern: new LLMs follow instructions more precisely but are worse at filling the gaps you didn't spell out. The prompt migration method lets you write requests that hold their quality through any version change. The essence: turn the prompt from a request into a spec with explicit sections: role, instructions, format, data. Each part goes in its own XML tag, so the model sees a clear map and stops guessing which parts are commands and which are context. This removes the main cause of post-upgrade failures: confusion between data and instructions.

Principle

An old-style prompt is a request. A new-style prompt is a spec. The fundamental difference: someone working from a spec isn't expected to 'take a hint.' The structure that doesn't break: - Role and goal: who the model is and what needs to be done - Instructions: step-by-step actions - Format rules: what the answer looks like - Context: data, kept separate from commands The fun part: XML tags turned out to be more reliable than JSON and ordinary markers; the model sees more clearly where one part ends and the next begins. You'd think it wouldn't matter how you separate things; it turns out to matter a lot.

Why it works

Older models were good at 'guessing' intent, flexibly interpreting vague requests. Newer ones are trained to follow instructions more precisely, which means they do literally what's written, and nothing more. It's the difference between a seasoned employee who's known you for five years and a brand-new junior: the junior does exactly what's written in the ticket. A vague prompt for a powerful model is a task with no requirements. The result is unpredictable. An explicit structure removes room for interpretation, and the result becomes stable.

When to apply

Any recurring scenario with a fixed prompt: text analysis, writing replies, content generation, data processing. Especially important where the result has to be predictable every single time: customer support, reports, templated tasks. NOT suited to: quick one-off questions and short conversations. If you're asking 'explain in plain words what inflation is,' XML tags and role sections are overkill.

Mini recipe

1. Add a role and goal: The first two lines say who the model is and what needs to be done. Not 'write a text,' but 'You're an editor. Task: cut the text in half without losing meaning' 2. Break the instructions into steps: Not 'analyze it,' but '1. Find three key problems. 2. Rank them by importance. 3. Give a conclusion in three points'; the model follows the list instead of deciding what to do on its own 3. Lock in the answer format: Spell out what you want to see: a list, a table, paragraphs, the number of items. Without this, the model decides differently every time 4. Wrap the data in XML tags: Anything that's context rather than a command goes inside tags: `...`, `...`, `...` 5. Add a couple of explicit prohibitions: 'Don't use bullet lists,' 'Don't add filler phrases'; a couple of specific 'don't do X' rules eliminates the most common failures

Examples

[BAD]: `Analyze the customer review and write a reply` [GOOD]: `You're a customer success manager. Task: write a reply to a negative review. [review text] Sequence: 1. Find the main complaint 2. Acknowledge the problem without making excuses 3. Offer a concrete solution Format: 3-4 sentences, businesslike tone. Don't use emoji or the phrase 'we apologize for any inconvenience'.` The difference: the first version leaves the model room to interpret, so you'll get a different result every time. The second says what to do, in what order, and what a correct answer looks like.

In plain words

When developers upgrade an LLM from version 3.5 to 4.0 or switch from GPT to Claude, they naively expect everything to just get better on its own. In reality, the app's logic falls apart: old prompts on the new model produce unpredictable nonsense. The core problem is that every model is a unique neural firmware with its own triggers. The PromptMigration method solves this headache not by hand-tweaking words but by building a "bridge" between the old behavior and the new capabilities, so you keep stable answers when you swap the engine.

It's like ordering coffee from the same barista for years using your own inside jokes and half-hints, and then a new hire shows up. You give him the same line, he looks at you like you're crazy and pours you hot water. To avoid going without coffee, you need to translate your instructions into a language this particular newcomer understands, while keeping the original meaning of your order. Old context in a new head without adaptation is a sure way to get garbage out.

Technically, this works through semantic alignment and checks for quality regression. Instead of just copy-pasting the text, the system analyzes which parts of the prompt triggered the desired response in the old model and rebuilds them for the new model's architecture. The key methods here are automatic generation of variations and comparative testing, where the new model literally takes an exam on matching the old model's reference answers. If accuracy drops by even 5%, the prompt goes back for rework until the model "gets" the task right.

Although the study focuses on migrating between GPT versions, the principle is vital for any enterprise software. If your company runs hundreds of automated chains, you can't just hit "update" and hope for a miracle. PromptMigration applies everywhere: from support chatbots to complex data-analysis systems. It's insurance against your AI suddenly getting rude with customers or hallucinating in financial reports after the next update from OpenAI or Anthropic.

The main takeaway is simple: a prompt isn't just text; it's program code tightly bound to specific hardware (the model). You can't just drop it into another environment and expect identical behavior. You need a migration process that pins down the system's behavior and keeps quality from slipping. Either you spend time adapting prompts properly, or you spend money cleaning up after your app's sudden dumbing-down.

AI lab assistant

Apply this study to your task

Describe what you're working on. AI takes the method and the measured results from this paper and adapts them to your case, or writes a ready prompt built on them.

Based on Model drift: why prompts break when an LLM gets upgraded, and how to write one that survives arXiv:2507.05573

Sign in to apply this study New accounts get 50 free credits.

Get the week’s best papers by email

One email on Sundays with the highest-rated new techniques. Unsubscribe with one click.