Role Prompting

What Is Role Prompting?

Role prompting tells the model who it should act as or what professional perspective it should use while completing a task.

Explain why this Python code is slow.

You are a senior Python performance engineer. Explain why this code is slow to a junior developer. Give 3 fixes.

Role ≠ Task

Do not confuse who the model should act as with what the model should do.

For example, “You are a technical support specialist” is a role. “Diagnose the customer's error and return the likely cause plus two next steps” is the task.

Why Does a Role Help?

A role can reduce ambiguity by telling the model what perspective, audience, or responsibility should guide the response.

Example 1: Change the Audience

The same topic can need very different answers depending on who the assistant is serving.

You are a patient Python tutor teaching a beginner. Explain what a Python dictionary is. Use a simple real-world analogy and one short code example.

You are a senior Python reviewer. Explain the important design trade-offs of Python dictionaries for an experienced developer. Mention complexity and practical caveats.

Example 2: Role + Context

A role becomes more useful when the model also receives the information it must use.

ROLE:
You are a customer support specialist.

POLICY:
Returns are accepted within 30 days with proof of purchase. Final-sale items are not returnable.

TASK:
Decide whether the customer's request is eligible.

CUSTOMER:
“I bought this final-sale item 10 days ago. Can I return it?”

OUTPUT:
Return exactly: ELIGIBLE or NOT_ELIGIBLE, followed by one short reason.

Build a Strong Role Prompt

A useful pattern is Role → Task → Context → Constraints → Output. You do not always need every part, but the pattern makes missing information easy to spot.

Act as an expert and help me.

You are a senior Python code reviewer. Review the function below for correctness and maintainability. Identify the 3 most important issues. Do not rewrite the whole function. Return a numbered list.

Run a Real Role-Prompting Experiment in Python

Test a role against a baseline instead of assuming it helps. Use the same question and compare the responses.

import os
from openai import OpenAI

client = OpenAI(api_key=os.environ["OPENAI_API_KEY"])
question = "Why should I use a virtual environment in Python?"

prompts = {
    "baseline": "Answer the question clearly for a beginner.",
    "role": "You are a patient Python tutor. Explain the answer to a beginner, use one analogy, and give one short example.",
}

for name, instruction in prompts.items():
    response = client.responses.create(
        model="gpt-5-mini",
        input=[
            {"role": "system", "content": instruction},
            {"role": "user", "content": question},
        ],
    )
    print(f"\\n{name.upper()}:\\n{response.output_text}")

Experiment: Compare the answers for clarity, depth, tone, and usefulness. Then remove the analogy requirement and run it again. You are testing which instruction actually changes the behavior.

Role Prompting Does Not Create New Knowledge

This is one of the most important misconceptions. Saying “You are a database expert” does not install a database textbook into the model.

API Message Roles vs. Role Prompting

These ideas are related but not identical. In an API, system, developer, and user are message roles defined by the interface. Role prompting is the instruction itself, such as “You are a patient Python tutor.”

For example, a system or developer message may contain the role instruction, while the user message contains the current question. The exact API semantics depend on the model and platform, so follow the provider's current documentation for message-role behavior.

When Role Prompting Is Useful

Common Role Prompting Mistakes

Mini-Project: Code Review Assistant

Build an assistant that reviews Python code from a specific perspective and returns actionable feedback.

You are a senior Python code reviewer helping a development team.

TASK:
Review the Python code below for correctness, maintainability, and obvious performance problems.

CONSTRAINTS:
- Identify the 3 most important issues.
- Explain why each issue matters.
- Suggest a small fix for each issue.
- Do not rewrite the entire program.

OUTPUT:
Return a numbered list. For each item include: severity, issue, why, fix.

CODE:
{python_code}