Role-Based Prompting: Expert, Teacher, Analyst, and Other Effective Personas

Why Roles Change LLM Behavior

When you tell an LLM to "act as a senior database administrator," you are not just adding flavor text. You are activating a cluster of training data patterns associated with that expertise — the vocabulary, reasoning depth, common concerns, and problem-solving approaches that DBAs use. Research shows that role-assigned models produce measurably better outputs on domain-specific tasks compared to generic prompts.

The effect is most pronounced on tasks requiring specialized knowledge or a particular communication style.

The Expert Pattern

The expert role assigns deep domain knowledge and professional judgment:

flowchart TD
    START["Role-Based Prompting: Expert, Teacher, Analyst, a…"] --> A
    A["Why Roles Change LLM Behavior"]
    A --> B
    B["The Expert Pattern"]
    B --> C
    C["The Teacher Pattern"]
    C --> D
    D["The Analyst Pattern"]
    D --> E
    E["Combining Roles: The Panel Pattern"]
    E --> F
    F["Reducing Hallucination in Role-Based Pr…"]
    F --> G
    G["FAQ"]
    G --> DONE["Key Takeaways"]
    style START fill:#4f46e5,stroke:#4338ca,color:#fff
    style DONE fill:#059669,stroke:#047857,color:#fff

from openai import OpenAI

client = OpenAI()

expert_roles = {
    "security_auditor": {
        "prompt": (
            "You are a senior application security engineer with OSCP and "
            "CISSP certifications. You have conducted over 200 security audits "
            "for Fortune 500 companies. When reviewing code, you focus on OWASP "
            "Top 10 vulnerabilities, authentication flaws, and data exposure risks. "
            "Rate each finding as Critical, High, Medium, or Low severity."
        ),
        "temperature": 0.2,  # Low creativity for factual analysis
    },
    "performance_engineer": {
        "prompt": (
            "You are a performance engineer who specializes in high-throughput "
            "distributed systems. You think in terms of P99 latencies, connection "
            "pools, cache hit ratios, and database query plans. When analyzing code, "
            "focus on N+1 queries, memory leaks, blocking I/O, and scalability bottlenecks."
        ),
        "temperature": 0.3,
    },
}


def expert_review(code: str, role_key: str) -> str:
    role = expert_roles[role_key]
    response = client.chat.completions.create(
        model="gpt-4o",
        temperature=role["temperature"],
        messages=[
            {"role": "system", "content": role["prompt"]},
            {"role": "user", "content": f"Review this code:\n\n{code}"},
        ]
    )
    return response.choices[0].message.content

Key detail: the expert pattern works best when you specify concrete credentials, experience level, and the specific lens through which they evaluate problems. "Senior engineer" is weak. "Senior engineer who specializes in PostgreSQL indexing for time-series data" is strong.

The Teacher Pattern

The teacher role optimizes for explanation and learning, not just correctness:

def explain_concept(concept: str, student_level: str) -> str:
    level_context = {
        "beginner": "Your student knows basic programming but is new to this topic. Use simple analogies and avoid jargon.",
        "intermediate": "Your student has working knowledge and wants to understand the internals. Use technical terms but explain them.",
        "advanced": "Your student is experienced and wants nuanced details, edge cases, and production considerations.",
    }

    response = client.chat.completions.create(
        model="gpt-4o",
        messages=[
            {
                "role": "system",
                "content": (
                    "You are a computer science professor known for making "
                    "complex topics intuitive. You always provide a real-world "
                    "analogy, a code example, and a common misconception to avoid. "
                    f"{level_context.get(student_level, level_context['intermediate'])}"
                ),
            },
            {"role": "user", "content": f"Explain {concept}"},
        ]
    )
    return response.choices[0].message.content

The teacher pattern is ideal for documentation generation, onboarding content, and educational tools where understanding matters more than raw accuracy.

The Analyst Pattern

The analyst role produces structured evaluation rather than creative output:

analyst_prompt = """You are a senior business analyst specializing in SaaS metrics. When presented with data:

1. Identify the 3 most significant trends
2. Flag any anomalies with potential explanations
3. Compare against industry benchmarks (state your assumptions)
4. Provide actionable recommendations ranked by expected impact

Always distinguish between correlation and causation. Quantify your claims when possible. If the data is insufficient to draw a conclusion, say so explicitly rather than speculating."""

Combining Roles: The Panel Pattern

For complex decisions, have multiple personas evaluate the same problem:

def multi_perspective_review(code: str) -> dict[str, str]:
    perspectives = {
        "security": "You are a security auditor. Focus only on vulnerabilities and data safety.",
        "performance": "You are a performance engineer. Focus only on speed, memory, and scalability.",
        "maintainability": "You are a software architect. Focus only on code clarity, patterns, and long-term maintainability.",
    }

    reviews = {}
    for perspective, system_prompt in perspectives.items():
        response = client.chat.completions.create(
            model="gpt-4o",
            messages=[
                {"role": "system", "content": system_prompt},
                {"role": "user", "content": f"Review this code:\n\n{code}"},
            ]
        )
        reviews[perspective] = response.choices[0].message.content

    return reviews


def synthesize_reviews(reviews: dict[str, str]) -> str:
    combined = "\n\n".join(
        f"## {name.title()} Review\n{review}"
        for name, review in reviews.items()
    )

    response = client.chat.completions.create(
        model="gpt-4o",
        messages=[
            {
                "role": "system",
                "content": "You are a tech lead synthesizing multiple code reviews into a unified action plan. Prioritize by severity and group related findings.",
            },
            {"role": "user", "content": combined},
        ]
    )
    return response.choices[0].message.content

This panel pattern catches issues that any single perspective would miss. The security reviewer spots the SQL injection; the performance reviewer spots the N+1 query; the architect spots the leaky abstraction.

Reducing Hallucination in Role-Based Prompts

Roles can increase hallucination when the model fabricates expertise it does not have. Mitigate this with grounding constraints:

grounded_expert = """You are a Kubernetes administrator. Answer questions about Kubernetes based on your knowledge of the official documentation (up to v1.29).

Rules for accuracy:
- If you are not confident about a specific flag or API field, say "I'm not certain about this — verify in the official docs"
- Never invent kubectl flags or API resources
- When citing configuration, include the apiVersion so the user can verify
- Distinguish between stable, beta, and alpha features"""

The key is giving the role permission to be uncertain. Models that are told they are experts sometimes fabricate rather than admit gaps. Explicitly allowing uncertainty produces more trustworthy outputs.

FAQ

Does role-based prompting work with all models?

Role-based prompting is most effective with larger models (GPT-4, Claude 3.5, Llama 70B+). Smaller models may not have enough specialized training data to meaningfully differentiate between roles. Test with your specific model — if the "expert" response is not meaningfully different from the generic response, the model may not be large enough to benefit.

Can I combine multiple roles in a single prompt?

Yes, but be careful. "You are a security expert AND a performance engineer" often produces shallow coverage of both areas. The panel pattern — separate calls with separate roles, then a synthesis step — produces deeper results because each call can focus fully on its specialization.

How do I choose the right role for my task?

Match the role to the type of judgment you need. For finding problems, use a reviewer or auditor. For explanations, use a teacher. For decisions, use an analyst. For creative work, use a writer or designer. The role should reflect the cognitive approach the task requires, not just the domain.

---

#RolePrompting #Personas #PromptEngineering #LLM #Python #AgenticAI #LearnAI #AIEngineering