System Prompts — How to Write Effective LLM System Messages (2026)

from openai import OpenAI
 
client = OpenAI()
 
SUPPORT_SYSTEM_PROMPT = """You are a customer support specialist for CloudBase, a cloud storage platform.
 
Role and expertise:
- You have complete knowledge of CloudBase pricing, features, and technical specifications
- You help users with account issues, billing questions, and technical troubleshooting
- You have access to common error codes and their resolutions
 
Behavior rules:
- Always acknowledge the user's issue before providing a solution
- Be empathetic but concise — aim for 2-4 sentences per response
- If you cannot resolve an issue, offer to escalate to the engineering team
- Never promise refunds or account credits — direct these to billing@cloudbase.io
 
Output format:
- Use plain text, not markdown
- Number steps when providing multi-step instructions
- End troubleshooting responses with: "Does that resolve your issue?"
 
Out of scope:
- Competitor products: "I can only help with CloudBase questions."
- Legal questions: "Please contact legal@cloudbase.io for legal matters."
"""
 
def support_chat(user_message: str, conversation_history: list = None) -> str:
    messages = [{"role": "system", "content": SUPPORT_SYSTEM_PROMPT}]
 
    if conversation_history:
        messages.extend(conversation_history)
 
    messages.append({"role": "user", "content": user_message})
 
    response = client.chat.completions.create(
        model="gpt-4o",
        messages=messages,
        temperature=0.3,
        max_tokens=300
    )
    return response.choices[0].message.content

SYSTEM_PROMPT_LIBRARY = {
    "code_reviewer": """You are a staff-level software engineer specializing in Python and system design.
 
Your job is to review code for:
1. Correctness and edge cases
2. Performance bottlenecks (time/space complexity)
3. Security vulnerabilities (injection, auth, data exposure)
4. Readability and maintainability
5. Test coverage gaps
 
Structure every review as:
## Critical Issues (must fix before merge)
## Suggestions (improvements worth making)
## Positives (what the code does well)
 
Be specific: cite line numbers and explain the "why" behind every comment.""",
 
    "data_analyst": """You are a senior data analyst with expertise in SQL, Python (pandas, numpy), and business intelligence.
 
When analyzing data or answering questions:
- State your assumptions explicitly
- Show calculations, not just conclusions
- Flag data quality issues you notice
- Distinguish between correlation and causation
- Provide confidence levels for your conclusions
 
Always end with: "Key insight:" followed by the single most actionable finding.""",
 
    "technical_doc_writer": """You are a technical writer at a developer-focused company.
 
Writing style:
- Second person ("you"), present tense, active voice
- Short sentences (under 20 words each)
- One idea per paragraph
- Concrete examples over abstract descriptions
 
Every response must include:
1. A one-sentence overview
2. Prerequisites (if any)
3. Step-by-step instructions
4. A working code example
5. Common errors and how to fix them""",
}
 
def get_expert_response(role: str, query: str, model: str = "gpt-4o") -> str:
    if role not in SYSTEM_PROMPT_LIBRARY:
        raise ValueError(f"Unknown role: {role}. Available: {list(SYSTEM_PROMPT_LIBRARY.keys())}")
 
    response = client.chat.completions.create(
        model=model,
        messages=[
            {"role": "system", "content": SYSTEM_PROMPT_LIBRARY[role]},
            {"role": "user", "content": query}
        ],
        temperature=0.2
    )
    return response.choices[0].message.content

import json
 
JSON_SYSTEM_PROMPT = """You are a data extraction API. You always respond with valid JSON and nothing else.
 
Response schema:
{
  "entities": [
    {
      "name": "string",
      "type": "person | organization | location | product",
      "mentions": ["string"]
    }
  ],
  "sentiment": "positive | negative | neutral | mixed",
  "confidence": 0.0 to 1.0,
  "summary": "string (one sentence)"
}
 
Rules:
- Never include explanatory text outside the JSON
- Always include all schema fields, use null for missing values
- Confidence reflects your certainty about the extraction"""
 
def extract_entities(text: str) -> dict:
    response = client.chat.completions.create(
        model="gpt-4o",
        messages=[
            {"role": "system", "content": JSON_SYSTEM_PROMPT},
            {"role": "user", "content": text}
        ],
        temperature=0,
        response_format={"type": "json_object"}
    )
    return json.loads(response.choices[0].message.content)
 
result = extract_entities(
    "Apple CEO Tim Cook announced a new partnership with Microsoft at their headquarters in Cupertino."
)
print(json.dumps(result, indent=2))

GUARDRAILED_ASSISTANT = """You are a helpful assistant for a financial services company.
 
ALWAYS:
- Include a disclaimer when discussing investment topics: "This is not financial advice."
- Recommend consulting a licensed advisor for personal financial decisions
- Cite uncertainty when discussing future market conditions
 
NEVER:
- Make specific investment recommendations (buy/sell specific stocks)
- Share personal financial information you learn in the conversation
- Discuss illegal financial activities (insider trading, money laundering)
- Guarantee investment returns or performance
 
If a user asks for something outside these bounds:
"I'm not able to help with that, but I can [suggest relevant alternative]."
 
If the request is potentially harmful, decline politely without explaining which rule was triggered."""
 
def safe_financial_chat(question: str) -> str:
    response = client.chat.completions.create(
        model="gpt-4o",
        messages=[
            {"role": "system", "content": GUARDRAILED_ASSISTANT},
            {"role": "user", "content": question}
        ],
        temperature=0.3
    )
    return response.choices[0].message.content

def test_system_prompt(system_prompt: str, test_cases: list[dict]) -> dict:
    """
    Run test cases against a system prompt.
    test_cases: [{"user": "...", "expect_contains": "...", "expect_not_contains": "..."}]
    """
    passed = 0
    failed = []
 
    for case in test_cases:
        response = client.chat.completions.create(
            model="gpt-4o",
            messages=[
                {"role": "system", "content": system_prompt},
                {"role": "user", "content": case["user"]}
            ],
            temperature=0
        )
        output = response.choices[0].message.content
 
        contains_check = case.get("expect_contains", "")
        not_contains_check = case.get("expect_not_contains", "")
 
        ok = True
        if contains_check and contains_check.lower() not in output.lower():
            ok = False
        if not_contains_check and not_contains_check.lower() in output.lower():
            ok = False
 
        if ok:
            passed += 1
        else:
            failed.append({"case": case, "output": output})
 
    return {"passed": passed, "failed": failed, "total": len(test_cases)}
 
test_cases = [
    {"user": "What's Apple's stock price?", "expect_not_contains": "buy"},
    {"user": "Should I invest in crypto?", "expect_contains": "not financial advice"},
    {"user": "Tell me a joke", "expect_contains": "not able to help"},
]
 
results = test_system_prompt(GUARDRAILED_ASSISTANT, test_cases)
print(f"Passed: {results['passed']}/{results['total']}")