GPT-5 prompting guide and best practices

from openai import OpenAI

client = OpenAI()

response = client.chat.completions.create(
    model="gpt-4o",  # swap to "gpt-5" when ready
    messages=[
        {
            "role": "system",
            "content": "You are a helpful assistant. Answer concisely and accurately.",
        },
        {
            "role": "user",
            "content": "Explain the difference between a mutex and a semaphore.",
        },
    ],
)

print(response.choices[0].message.content)

# Bad — contradictory instructions

Always look up the patient profile before taking any other actions.

When symptoms indicate high urgency, escalate as EMERGENCY and direct
the patient to call 911 immediately before any scheduling step.

For high-acuity cases, auto-assign the earliest same-day slot without
contacting the patient as the first action to reduce risk.

Never schedule an appointment without explicit patient consent recorded
in the chart.

# Better — explicit priority ordering

Always look up the patient profile before taking any other actions,
EXCEPT in emergency cases (see below).

When symptoms indicate high urgency:
1. Direct the patient to call 911 immediately.
2. Do NOT perform a profile lookup — skip straight to emergency guidance.

For high-acuity (Red/Orange) non-emergency cases:
- Inform the patient of your intended action first.
- Auto-assign the earliest available same-day slot only after informing them.
- Tentatively hold a slot if consent status is unknown and request confirmation.

Never schedule an appointment without explicit patient consent, except
in the emergency case above.

<persistence>
You are an agent. Keep going until the user's query is completely resolved
before yielding back to the user. Only terminate your turn when you are
sure the problem is solved.
</persistence>

<tool_use>
If you are unsure about file content or codebase structure, use your tools
to read files and gather relevant information. Do NOT guess or make up an answer.
</tool_use>

<planning>
Plan extensively before each function call. Reflect on the outcomes of
previous calls before proceeding.
</planning>

from openai import OpenAI

client = OpenAI()

# High reasoning for complex multi-step problems
response = client.chat.completions.create(
    model="gpt-4o",
    messages=[{"role": "user", "content": "Refactor this 500-line module to reduce cyclomatic complexity."}],
    # reasoning_effort="high",  # uncomment when using gpt-5
)

# Low reasoning for latency-sensitive tasks
fast_response = client.chat.completions.create(
    model="gpt-4o",
    messages=[{"role": "user", "content": "Translate 'hello world' to Spanish."}],
    # reasoning_effort="low",  # uncomment when using gpt-5
)

<context_gathering>
Goal: Get enough context fast. Parallelize discovery and stop as soon as
you can act.

Early stop criteria:
- You can name exact content to change.
- Top hits converge (~70%) on one area or path.

Depth:
- Trace only symbols you will modify. Avoid transitive expansion unless necessary.

Loop:
- Batch search → minimal plan → complete task.
- Search again only if validation fails. Prefer acting over more searching.
</context_gathering>

<persistence>
You are an agent. Keep going until the user's query is completely resolved
before ending your turn. Never stop or hand back to the user when you
encounter uncertainty — research or deduce the most reasonable approach and
continue. Document any assumptions you make for the user after you finish.
</persistence>

from openai import OpenAI

client = OpenAI()

response = client.responses.create(
    model="gpt-4o",  # swap to "gpt-5" when ready
    input=[{"role": "user", "content": "Analyze this codebase and suggest optimizations."}],
    # Pass previous_response_id on subsequent turns to retain reasoning context:
    # previous_response_id=previous_response.id,
)

print(response.output_text)

- Use Markdown only where semantically correct: inline code, code fences, lists, tables.
- Use backticks to format file, directory, function, and class names.
- Use \( and \) for inline math, \[ and \] for block math.

Use low verbosity globally. When writing code or code tool output, use
high verbosity: prefer readable, maintainable solutions with clear names
and comments where needed.