Measuring the Mood: How Emotions and Personalities Affect Code LLM Stability

TLDR: A new framework, PromptSE, evaluates code LLM stability by creating emotion- and personality-driven prompt variations. It found that model performance and stability are often decoupled, smaller models can be surprisingly stable, and emotional prompts reveal unique vulnerabilities. This helps quantify model reliability beyond just peak performance, offering a dual-pathway evaluation for both open and closed-source models.

In the fast-evolving world of software development, code generation models, powered by Large Language Models (LLMs), have become indispensable tools. However, these advanced systems face a subtle yet critical challenge: prompt sensitivity. This means that the way a developer phrases a request, even if the underlying technical need is identical, can significantly alter the code generated by the LLM. For instance, a frustrated developer might use different language than a calm one, leading to vastly different outputs, even for the same task. Traditional evaluations often focus on a model’s best performance, overlooking this crucial aspect of consistency and reliability.

To tackle this, a new framework called PromptSE (Prompt Sensitivity Evaluation) has been introduced. Its purpose is to systematically measure how sensitive code LLMs are to these natural variations in prompts, particularly those influenced by emotions and personality. PromptSE aims to establish prompt stability as a key evaluation dimension, alongside performance and fairness, contributing to more trustworthy AI-assisted software development.

Crafting Diverse Prompts: The Emotion and Personality Factor

The core of PromptSE lies in its ability to create a wide array of prompt variations that are semantically equivalent—meaning they all ask for the same code functionality—but differ in their emotional tone or communication style. This is achieved using structured psychological templates. The framework models how developers might express requirements under different emotional states (like being focused, excited, anxious, or frustrated) and personality traits (such as being an “algorithm expert” versus a “pragmatic engineer,” or a “junior explorer” versus a “senior architect”).

These templates allow for controlled adjustments in the “perturbation distance,” which dictates how much the variant prompt differs from the original. This ranges from minor word changes to more substantial stylistic shifts, all while ensuring that critical technical elements like function signatures and input-output constraints remain unchanged. This meticulous approach ensures that any observed changes in model behavior are due to stylistic variations, not altered requirements.

Measuring Stability: PromptSE and PromptSELight Explained

PromptSE employs two main methods to evaluate model sensitivity:

• PromptSE: This is the comprehensive method, designed for open-source models where the internal “thinking” (specifically, the probability of generating certain code) is accessible. It uses a scoring system called SoftExec, which not only checks if the generated code is correct but also factors in how confident the model was in its answer. This helps differentiate between a correct solution the model was very sure about and one it produced with less certainty, offering a more nuanced understanding of performance.

• PromptSELight: For situations involving closed-source models (like commercial APIs) or when a quick assessment is needed, PromptSELight offers an efficient alternative. It simplifies the evaluation by focusing on binary pass rates—whether the code works or fails—without delving into the model’s confidence. Despite its simpler approach, PromptSELight maintains mathematical consistency with PromptSE, making it suitable for rapid screening.

Both methods ultimately contribute to a unified metric called AUC-E (Area Under Curve of Elasticity). This single score, ranging from 0 to 1, provides an overall measure of a model’s prompt stability, with higher values indicating greater robustness. AUC-E allows for straightforward comparisons of stability across different models and datasets.

Key Discoveries from the Study

The research involved testing 14 code LLMs from Llama, Qwen, and Deepseek families against a vast dataset of 14,760 prompt variants. The findings offer crucial insights:

• Performance and Stability Aren’t Always Linked: A significant discovery was that a model’s peak performance (how good it is at its best) does not necessarily correlate with its stability (how consistent it is across different prompts). This means that a model can be very high-performing but also very sensitive to prompt phrasing, or vice-versa. This challenges the idea that “stronger” models are automatically more robust.

• Smaller Models Can Be More Stable: Surprisingly, the study found that prompt stability doesn’t always improve with model size. Some smaller models, like Qwen-1.5B, demonstrated superior stability compared to larger counterparts. This suggests that achieving stability might require specific training strategies rather than just increasing the model’s scale.

• Emotions Reveal Hidden Vulnerabilities: Emotional prompts proved to be effective in uncovering specific weaknesses and “miscalibration” (where a model is overly confident in wrong answers or underconfident in correct ones) in certain models. This indicates that the emotional context of a prompt can act as a diagnostic tool for identifying latent instabilities.

• PromptSELight is a Practical Alternative: The study confirmed that PromptSELight provides a good approximation of the more detailed PromptSE, especially for ranking models by stability. This is valuable for developers and organizations needing to quickly evaluate closed-source models without access to their internal probabilities.

Also Read:

• Boosting Code Security in AI-Generated Software with Fine-Tuning Techniques
• Unpacking the Role of Code Semantics in Large Language Models: A New Study’s Surprising Insights

Practical Implications for AI in Software Development

These findings have profound implications for the practical application of code LLMs:

• Smarter Model Selection: Developers and organizations can now make more informed decisions when choosing an LLM. For critical applications, prioritizing a model with high prompt stability might be more important than selecting one with slightly higher peak performance. This allows for a better balance between reliability and capability.

• Enhanced Prompt Engineering: The insights gained from PromptSE can guide the creation of more robust prompts. By understanding which emotional or stylistic variations might destabilize a model, developers can design prompts that are less prone to unexpected behavior, especially in collaborative environments where different communication styles are common.

• Building More Trustworthy AI: By highlighting prompt stability as a crucial evaluation metric, this research helps advance the development of more reliable and trustworthy AI tools for software engineering. Models that consistently perform well, regardless of minor variations in user expression, will be better suited for real-world deployment.

While this study focused on Python and specific types of prompt variations, it lays a foundational understanding for a critical aspect of LLM behavior. Future research will delve deeper into the architectural reasons behind stability and expand these evaluations to other programming languages and tasks. This work emphasizes that for code LLMs to truly succeed in production, they must not only perform well but also maintain consistent behavior across the rich diversity of human expression. You can explore the full research paper here.