The first GPT-5 prompt I ported over from GPT-4 got worse, not better. It was a scheduling assistant with two rules sitting a paragraph apart: "Never book an appointment without explicit patient consent," and, further down, "auto-assign the earliest available slot to reduce wait times." GPT-4 quietly picked one and moved on. GPT-5 stalled, second-guessed itself, and spent reasoning tokens trying to honor both at once. The instructions hadn't changed. The model's willingness to take me at my word had.
That's the shift worth internalizing before you rewrite a single prompt. OpenAI describes GPT-5 as following instructions with "surgical precision" — which is a feature right up until your prompt quietly contradicts itself. Prompting GPT-5 well is less about clever phrasing and more about two things older models let you skip: setting the right dials, and removing conflicts you never noticed you'd written.
Two dials before you touch the prose
GPT-5 exposes two API parameters that replace a surprising amount of prompt wording.
reasoning_effort controls how much the model thinks and how eagerly it reaches for tools. It takes minimal, low, medium (the default), or high. The new minimal tier is the fast lane — you get a reasoning model's behavior with latency close to a non-reasoning one. verbosity is a separate dial for how long the final answer runs: low, medium (default), or high. Crucially, it's decoupled from reasoning effort, so you can ask the model to think hard and still answer in two sentences.
response = client.responses.create(
model="gpt-5",
reasoning={"effort": "low"}, # minimal | low | medium | high
text={"verbosity": "low"}, # low | medium | high
input="Summarize the incident and propose one fix.",
)
Reach for the parameters first. A lot of "make it more concise" and "don't overthink this" prose in legacy prompts is just verbosity and reasoning_effort waiting to be set properly. And you can still override the global default in-context when one path needs more room — the guide's own example sets low verbosity everywhere, then asks for "high verbosity for coding tools" so generated code stays readable.
Calibrating eagerness
GPT-5's default instinct is to be thorough, and on a large agentic task that's exactly what you want. On a small one it's a liability: the model fans out across your tools when a single call would do. This is the failure mode the guide illustrates with a real production tuning story — a coding-tool vendor had shipped the line "Be THOROUGH when gathering information," and GPT-5 took it so literally that it over-explored trivial tasks. Softening that one instruction fixed it.
To rein the model in, lower reasoning_effort and give it an explicit budget. A phrase as blunt as "usually, this means an absolute maximum of 2 tool calls" does real work. Define what "enough context" looks like so it knows when to stop.
To push the other way — long, autonomous trajectories — raise reasoning_effort and add a persistence clause:
You are an agent — please keep going until the user's query is completely resolved, before ending your turn.
For agentic runs, also invest in tool preambles: short status notes the model emits as it works, so a multi-minute task isn't a silent black box. You steer them the same way you steer anything else — "Always begin by rephrasing the user's goal... then immediately outline a structured plan detailing each logical step."
The real work: delete your contradictions
Here's where most of the payoff hides. Because GPT-5 tries hard to satisfy every directive, a vague or conflicting instruction doesn't get shrugged off — it degrades the whole response as the model works to reconcile the irreconcilable. My scheduling bug wasn't a prompt that needed more detail; it was two rules that couldn't both be true.
So audit for conflicts before you audit for coverage. Two directives that assume different states of the world, an absolute "never" undercut by a convenience shortcut elsewhere, a format demand that fights a length limit — these are the expensive bugs now. OpenAI ships a prompt optimizer in its dashboard that flags exactly this class of contradiction; run your existing prompts through it before assuming the model is the problem.
Reuse reasoning across turns
If you're building anything multi-step, use the Responses API over Chat Completions, and pass previous_response_id to carry the model's reasoning from one call into the next. That lets GPT-5 reference the plan it already built instead of reconstructing it from scratch each turn. It's not a rounding-error improvement: the guide reports a Tau-Bench Retail score climbing from 73.9% to 78.2% purely from feeding prior reasoning back in. Free accuracy for wiring an ID through your loop.
Two quick wins
Markdown is off by default. GPT-5's API responses come back as plain text for compatibility, so if you want fenced code and tables, ask for them: "Use Markdown only where semantically correct (e.g., inline code, code fences, lists, tables)." On long conversations, re-state that instruction every few user turns — adherence drifts otherwise.
Let the model tune its own prompt. GPT-5 is good at metaprompting. When behavior is close but inconsistent, hand it the failing prompt and ask: "What specific phrases could be added to or deleted from this prompt to more consistently elicit the desired behavior?" The edits it suggests — usually deletions — are often the ones you'd have missed.
The takeaway
Treat your GPT-5 prompt like code you're refactoring, not prose you're polishing. Set reasoning_effort and verbosity explicitly so the model isn't guessing your intent from adjectives. Grep your own instructions for two rules that can't both hold, and delete one. Give agentic runs a tool budget or a persistence clause, never a vague "be thorough." Do that, and the "surgical precision" that broke my scheduling bot becomes the reason it does exactly what you meant — which is the whole point of a model that finally takes you literally.
Sources: GPT-5 Prompting Guide (OpenAI Cookbook), Introducing GPT-5 for developers (OpenAI)