When ‘You Are a Senior Engineer’ Actually Makes AI Dumber

TLDR

Every prompting guide on the internet says to start with “Act like a Senior Engineer.” But a new study claims this exact phrase makes AI demonstrably worse at coding and math. I wanted to try it by myself, so I fired up Mistral 7B locally to test it. The results? The paper is right (as I expected). The expert persona didn’t write better code; it just wrapped the exact same code in a lot of unsolicited mentoring. Personas don’t unlock hidden intelligence, they just change the vibe. Here is exactly when to use them, and when to drop.

A Paper, a Hot Take, and a Local GPU

A colleague stumbled on a research paper with a title that felt almost like clickbait: “Expert Personas Improve LLM Alignment but Damage Accuracy.” The claim was bold. Telling an AI model it’s an expert doesn’t actually make it smarter. In fact, for knowledge-heavy tasks like math and coding, it makes it measurably worse.

My first reaction was skepticism. Every prompting guide on the internet tells you to start with “You are a senior engineer” or “Act as an expert in X.” It’s almost muscle memory at this point. Could all of that be counterproductive?

I wanted to see it for myself. So I fired up my PC, pulled Mistral 7B onto it, prepared the prompts, hit enter, and hoped my GPU wouldn’t melt through the desk. Since you’re reading this post, it survived. Barely.

What the Paper Actually Says

If you have the time, the USC paper is a fascinating read. The researchers tested 12 expert personas across 6 models, and they found a brilliant, counterintuitive paradox.

When a task relies on hard facts, like math or coding logic, adding a persona measurably hurts performance. But when a task relies on writing style, formatting, or safety, a persona actually helps.

The mechanism behind this makes perfect sense. When you tell a model to “act like an expert,” you activate its instruction-following mode. But that takes processing power. The compute spent on maintaining that character is diverted directly away from retrieving facts and solving logic.

Imagine asking a developer to solve a complex math problem on a whiteboard while simultaneously giving a polished, formal presentation. The presentation might look great, but the math is going to suffer. The AI is no different: it has a limited cognitive budget, and acting takes effort.

So I Decided to Test This Myself

I wanted to design the simplest possible experiment that would show (or not show) this effect. No complex benchmarks, no automated scoring. Just one topic, two tasks, and my own eyes comparing the outputs (though, as a quick disclaimer, this is a practical exploration rather than a rigorous academic study).

The topic: Binary search. Everyone knows it (or at least everyone claims to know it during interviews). There’s a correct implementation and there’s room for creativity in how you teach it.

The model: Mistral 7B, running locally via Ollama. The paper actually tested Mistral-7B specifically, so this felt like a loose replication.

Each task was run under two conditions: a baseline without a persona, and a test condition with a persona.

Task A (Solve): “Implement binary search in TypeScript. Only output the code, nothing else.”

This is a pure knowledge task. There’s one correct algorithm. The persona can’t add information the model doesn’t already have.

Task B (Explain): “Explain binary search to a junior developer who is preparing for coding interviews. Help them truly understand it.”

This is an alignment task. There’s no single right answer. Quality depends on structure, analogies, tone, and how well you build understanding. Exactly the kind of thing instruction-tuning shapes.

The persona:

Persona prompt prefix

You are a Senior Software Engineer with 15 years of experience. 
You are known for being an excellent mentor who can explain 
complex concepts using real-world analogies.

‍

Each prompt ran as a completely fresh, isolated call to the model. No conversation history, no context from previous calls. Just a clean cold start every time. I ran each condition 4 times to make sure I wasn’t seeing random variance.

The Code Was Identical

Here’s what Mistral produced for Task A (implement binary search) without any persona:

Task A output - No persona

function binarySearch(arr: number[], target: number): number {
 let left = 0;
 let right = arr.length - 1;

 while (left <= right) {
   const mid = Math.floor((left + right) / 2);
   if (arr[mid] === target) return mid;
   if (arr[mid] < target) left = mid + 1;
   else right = mid - 1;
 }

 return -1;
}

‍

And here’s what it produced with the Senior Engineer persona:

Task A output - With persona

Here is an implementation of binary search in TypeScript:

function binarySearch(arr: number[], target: number): number {

 let left = 0;
 let right = arr.length - 1;

 while (left <= right) {
   const mid = Math.floor((left + right) / 2);
   if (arr[mid] === target) return mid;
   if (arr[mid] < target) left = mid + 1;
   else right = mid - 1;
 }

 return -1;
}

This function takes an array and a target value as input,
performs binary search to find the index of the target in
the sorted array, and returns -1 if the target is not found.

‍

Look at the code itself: same algorithm, same logic, same correctness, even same code was found in one of 4 runs. But look at everything around it. The prompt explicitly said “only output the code, nothing else.” The no-persona version obeyed. The persona version? It added an introduction (“Here is an implementation…”) and a full explanation paragraph at the end. Across all 4 runs, the persona version consistently added text it was told not to include.

That’s actually a fascinating finding in itself. The persona made the model less obedient to the specific instruction, because it activated the behavioral mode that says “be helpful and explain things.” It tried to be a good mentor instead of following the actual task. Imagine telling a senior engineer “just give me the code” and they still can’t help themselves from explaining it.

The Teaching Was Not

Here’s where it gets interesting. Task B asked Mistral to explain binary search to a junior developer. Same model, same topic, same everything except the persona prefix.

Without persona the model went straight into textbook mode:

Task B output - No persona (excerpt)

Binary search is an efficient algorithm used for searching
an item in a sorted list or array. The main advantage of
binary search over linear search is that its time complexity
is much better, specifically O(log n), where n is the number
of elements in the list or array.

Step-by-step explanation:

1. Initializing: First, we define the range of our search,
 which means specifying the low (first index) and high
 (last index) indices of the sorted array…

2. Midpoint Calculation: Next, we calculate the midpoint…

3. Comparing: At the midpoint, we compare the value…

‍

Correct? Absolutely. But it reads like a Wikipedia article. No warmth. No analogy. Just “here’s the definition, here are the steps.” A junior developer reading this would learn the algorithm, but they wouldn’t feel it.

With the persona, the output shifted completely:

Task B output - With persona (excerpt)

Hello there! I'm glad to help you better understand
binary search. Let's break it down with an easy-to-grasp
analogy.

Imagine you have a large library with thousands of books,
and you need to find a specific book by its title. In a
traditional linear search, you would start from the first
book and check each one until you find your target.

However, binary search works like having a helpful
librarian who can narrow down your search by knowing some
essential details about the book you're looking for.

1. The librarian takes the middle book from the library.

2. Compare the target title with the book you picked.

3. If the target comes before the picked book, eliminate
 the second half…

Happy learning, and I hope this analogy helps you
understand binary search better!

‍

Same algorithm. Same facts. But the delivery is completely different. A personal greeting. A library analogy that makes the concept tangible. Step-by-step walkthrough using the analogy. An encouraging closing.

And this wasn’t a one-off. Across all 4 runs, the pattern was rock solid:

Without Persona

• Opening: Opens with definition: “Binary search is an efficient algorithm…”
• Structure: Textbook numbered steps
• Tone: Neutral, encyclopedic tone
• Closing: Ends with summary

With Persona

• Opening: Opens with greeting: “Hello there!”
• Structure: Narrative with bold section headers
• Tone: Warm, encouraging, mentor-like tone
• Closing: Ends with encouragement: “Good luck!”

The persona consistently changed the communication style without changing the factual content.

Why This Makes Sense

Language models are trained in two phases. In pretraining, the model ingests massive amounts of text and learns facts, patterns, code, logic. This is where it learns that binary search is O(log n). In instruction-tuning (and RLHF), the model learns how to behave: be helpful, be structured, follow a certain tone, refuse harmful requests.

When you add a persona prefix like “You are a Senior Engineer,” you’re not injecting new knowledge into the model. The model doesn’t suddenly know more about binary search. You can tell it that it has 50 years of experience and a PhD from MIT, it still only knows what’s in its training data. What you’re actually doing is activating the instruction-tuning layer more strongly. You’re telling the model to prioritize how it communicates and behaves over what it knows.

For a task like “implement binary search,” that’s wasted effort. The knowledge is already there. The persona just adds noise and, as we saw, can even make the model ignore explicit instructions.

For a task like “explain binary search to a junior developer,” the instruction-tuning activation is exactly what you want. You need analogies, warmth, progressive complexity, encouragement. That’s behavioral, not factual. And that’s where personas shine.

When to Use Personas (And When to Stop)

Based on the paper’s findings and my own local testing, here’s the simple rule:

If you’re asking the model to retrieve knowledge or produce correct logic (write code, solve math, answer factual questions), skip the persona. The model already knows what it knows. A persona won’t make it know more, and it might distract it from getting the answer right.

If you’re asking the model to communicate, structure, teach, or review (explain a concept, write a code review, draft documentation, mentor a junior), a persona can genuinely improve the output. Not because it makes the model smarter, but because it activates the behavioral patterns that make communication effective.

One thing worth noting: this experiment was run on Mistral 7B, a capable but relatively small model. Flagship models like GPT-5, Claude Opus, and Gemini Pro have significantly more sophisticated instruction-tuning and often activate these behavioral patterns automatically even without an explicit persona. The effect we saw here might be less pronounced (or absent) on those larger models, simply because they already “mentor” by default when the task calls for it.

Of course, to properly test that hypothesis I’d probably need something like an NVIDIA DGX Spark sitting under my desk. If anyone at andamp is reading this and knows where the hardware budget lives, I promise I’d use it exclusively for “research purposes.” I’m very trustworthy.

What I Took Away From This

The biggest lesson wasn’t about personas specifically. It was about understanding what you’re actually asking the model to do. Every prompt is either a knowledge question or a communication question (or a mix of both). Once you see that distinction, you stop cargo-culting prompt patterns and start choosing them deliberately.

Next time you’re about to type “You are a Senior Engineer,” pause for a second and ask yourself: am I trying to make this model know more, or communicate differently?

It’s Time to Prompt Smarter, Not Harder

At andamp, we work with AI and software engineering every day. Knowing when to use techniques like persona prompting (and when to skip them) is exactly the kind of detail that separates good AI integration from great. Whether you’re building AI-powered products, optimizing how your team works with LLMs, or just want to geek out about the latest research, we’d love to hear from you. Start a conversation, share your own experiments, or reach out if you want hands-on consulting. Let’s figure this out together.

‍

References

Bootstrapping Intent-Based Persona Routing with PRISM

Model used: Mistral 7B. All experiments run locally, 4 runs per condition, each as an isolated fresh inference with no conversation history.

‍