OpenAI just published its prompting playbook for GPT-5.6, and the headline finding upends how most people write prompts. In OpenAI’s own testing, stripping repeated instructions out of a system prompt raised evaluation scores by roughly 10 to 15% while cutting total tokens by 41 to 66% and cost by 33 to 67%. The giant rule lists you wrote for older models are now making GPT-5.6 slower, more expensive, and less accurate.
This GPT-5.6 prompting guide pulls the seven changes that matter most into plain English. You will learn why “state each instruction once” beats long rule stacks, how to pick between the new Sol, Terra, and Luna models, how the six reasoning effort levels work, and how new dials like verbosity and programmatic tool calling change what you should type. Everything here is drawn from OpenAI’s official guidance for the model family that went live on July 9, 2026.
The Key Takeaways
- Leaner prompts scored 10 to 15% higher and cut tokens by up to 66%, so state each instruction exactly once.
- GPT-5.6 has two separate dials: which model (Sol, Terra, or Luna) and how hard it thinks (six effort levels from none to max).
- Pro mode applies extra computation before a single final answer, and you can stack it on any effort level for your highest-stakes requests.
- GPT-5.6 is more concise by default than GPT-5.5, so your old “be brief” rules may now cut too much.
- New verbosity and programmatic tool calling features let you set length once and let the model process data in code instead of reading it token by token.
What actually changed in GPT-5.6
GPT-5.6 is not one model but a family of three, and it is tuned to think differently than the versions before it. The biggest practical shift is that the model does more with less instruction, so prompts that were optimized for GPT-5.5 or GPT-5.4 can actively hurt your results. OpenAI’s guidance is blunt about this, recommending you audit old prompts rather than copy them across.
The seven tips below follow OpenAI’s own priorities, starting with the change that moves scores the most. If you want the full launch breakdown of the three models first, read our explainer on ChatGPT 5.6 and how Sol, Terra, and Luna differ. Then come back here to fix your prompts.
Tip 1: Delete the repeated instructions from your old prompts
OpenAI’s single strongest recommendation is to state each instruction exactly once. In their words, “configurations with leaner system prompts improved evaluation scores by roughly 10 to 15% while reducing total tokens by 41 to 66% and cost by 33 to 67%.” That is a rare case where you cut cost and improve quality at the same time.
Older models often needed the same rule restated in three places to obey it. GPT-5.6 does not. Trim repeated statements, duplicated style notes, redundant examples, and process directions that do not change behavior. If a line is not doing new work, it is now costing you accuracy as well as tokens.
The practical move is to open your longest system prompt and delete every sentence that repeats an earlier one. Keep one clear version of each rule, then test. This is the fastest win in the entire OpenAI GPT-5.6 prompting guide.
Tip 2: Match the compute to the job with two dials
GPT-5.6 splits capability into two independent controls. One is which model size you send the request to, and the other is how hard that model thinks before answering. Getting both right is how you stop overpaying for simple tasks and stop under-thinking hard ones.
Choose your model: Sol, Terra, or Luna
Sol is the flagship for your hardest problems, Terra is the balanced workhorse for everyday business work, and Luna is the cheap, fast option for high-volume tasks. The price gap is large, so the model choice matters as much as the prompt.
| Model | Best for | Price per 1M tokens (input / output) |
|---|---|---|
| Sol | Hardest problems: complex coding, multi-step agents, research | $5 / $30 |
| Terra | Everyday business work, balanced quality and cost | $2.50 / $15 |
| Luna | Cheap, fast, high-volume work like summarizing and drafting | $1 / $6 |
Sol: the flagship for hard problems
Sol is built for your most demanding work, including complex coding, multi-step agents, and scientific or security research. At $5 input and $30 output per million tokens it is the priciest tier, so reserve it for problems that genuinely need frontier reasoning. Sol is also the model that runs pro mode and the deepest max effort, so it is where the high-compute dials pay off.
Terra: the everyday workhorse
Terra is the balanced production tier, competitive with the previous generation at roughly half the cost. At $2.50 input and $15 output it handles the bulk of business writing, analysis, and support work without the Sol premium. For most teams it becomes the default once they test it against real tasks and see the quality holds.
Luna: fast and affordable
Luna is the cheap, high-volume tier at $1 input and $6 output per million tokens. It is tuned for routine automation like summarizing, drafting, and classification, where speed and price matter more than peak intelligence. Route your simplest, highest-volume jobs here to keep costs down.
OpenAI’s model guidance suggests starting with Sol as your baseline, then testing whether Terra or Luna holds up on your real tasks. Many everyday jobs run fine on Terra at roughly half the cost. You can see where all three sit against rivals in our roundup of the best AI models right now.
Set the reasoning effort
The second dial is reasoning effort, and GPT-5.6 exposes six levels. OpenAI’s advice is to start at whatever setting you used on your last model, then test one level lower, because the new generation usually needs less thinking to reach the same answer.
| Effort level | When to use it |
|---|---|
| none | Simple lookups where latency matters most |
| low | Speed-sensitive, lightweight work |
| medium | Balanced default for most tasks |
| high | When your tests show a measurable quality gain |
| xhigh | Harder tasks that clearly reward more thinking |
| max | Your genuinely hardest, quality-first problems |
Dropping one level often saves money with no quality loss, which is why OpenAI frames testing lower as the default habit. Save the top levels for the few problems that truly need them.
Tip 3: Turn on pro mode for your highest-stakes answers
GPT-5.6 adds a genuine pro mode, and it is the dial to reach for when quality matters more than speed or cost. In the Responses API you set reasoning.mode to pro, and the model applies extra computation to the request before returning a single final answer. It layers on top of whatever model and effort level you already picked.
Do not confuse pro mode with max effort. Max is the highest of the six effort levels, giving one reasoning chain more time on a single problem with hidden dependencies or messy context. Pro mode adds a separate round of model work before the final answer, and you can stack it on any effort level from low to max. Save pro for the small set of requests where a wrong answer is genuinely expensive.
For work that is genuinely parallelizable, ChatGPT and Codex also expose an ultra mode that decomposes a task and spawns coordinating subagents instead of running one chain. That lifted Sol from 88.8% to 91.9% on the Terminal-Bench 2.1 coding benchmark, but each subagent burns tokens independently, so ultra is overkill for routine requests. Reach for it only when a task splits cleanly and time-to-result matters most.
Tip 4: Rewrite your “be concise” rules
GPT-5.6 already defaults to shorter answers than GPT-5.5. That means the blanket brevity rules you added for older models can now trim too much, dropping detail you actually wanted. OpenAI specifically tells migrating users to check whether “be concise” or “keep it short” still earn their place.
When you do want a short answer, stop giving vague brevity commands. Tell the model which information to keep and which detail it can drop instead. Something like “keep the pricing and the deadline, drop the background history” gives you control that “keep it brief” never will.
Tip 5: Describe tone as concrete behavior, not adjectives
Words like “friendly” and “empathetic” are too abstract for consistent results. GPT-5.6 responds far better when you spell out the actual writing behavior you want. Describe how direct to be, what to open with, and what to skip.
OpenAI’s own example replaces “be empathetic” with a concrete instruction, such as stating the answer directly and, if the user reports a problem, acknowledging that specific issue before giving the next step. A support prompt might say “name the customer’s problem in your first line, give the fix as numbered steps, skip the apology paragraph.” Concrete instructions get you the same tone every single time, which is exactly what teams want when comparing options like Claude vs ChatGPT for real workflows.
Tip 6: Set output length once with the verbosity dial
Output length is now its own control. GPT-5.6 adds a verbosity setting with low, medium, and high options that you set once for your whole app instead of begging for shorter answers in every prompt. In the API this is the text.verbosity parameter.
The clean pattern is to set your default detail level with verbosity, then use the prompt only for task-specific length requirements. That keeps your prompts focused on the task while a single global dial handles how much the model says. It is a small change that removes a lot of repeated length instructions.
Tip 7: Let GPT-5.6 write code to use your tools
This one is for builders. GPT-5.6 ships with a feature called programmatic tool calling, and it changes the economics of data-heavy tasks. Until now, every tool result was fed back into the model to read word by word, so “check 900 rows of ad data” meant the model reading all 900 rows.
Now the model can write a small JavaScript program instead. The script runs in an isolated runtime with no network access, pulls the data, does the filtering and math in code, and returns only a small structured result. The 900 rows never touch the model, so answers come back faster at a fraction of the cost. It works best for bounded jobs like filtering, joining, sorting, deduplicating, and aggregating tool results.
OpenAI warns against vague instructions like “use programmatic tool calling efficiently.” Instead, spell out the bounded stage, the eligible tools, the output schema, the retry limit, and the stop condition. Keep direct model calls for semantic judgment, approvals, and citations, and use code for the deterministic heavy lifting.
Do you need to rewrite every prompt?
If you build products on the API, yes, these seven changes are worth a focused prompt audit, and the token savings alone usually pay for the effort. If you just chat with GPT-5.6 in ChatGPT, the same instincts help, mainly writing shorter rule lists and describing tone concretely. You can check what the free tier actually gives you in our guide to what ChatGPT’s free plan includes.
If juggling models, effort levels, and verbosity dials sounds like too much, an app like Fello AI handles the routing for you. It puts GPT-5.6-class models alongside Claude, Gemini, Grok, and DeepSeek in one place, so you can send each task to a strong model without touching a single technical setting. That makes it a simple way to get frontier answers, and to generate images, documents, and slides, without learning the full API.
Conclusion
The theme across every GPT-5.6 change is the same, which is to say less and let the model do more. Delete repeated rules first, since that single move improves quality while cutting cost. Then match each task to the right model and effort level, rewrite your brevity and tone rules, and lean on verbosity and programmatic tool calling to stop repeating yourself.
Start with your longest system prompt today, trim every duplicated instruction, and test one effort level lower than you used before. That one afternoon of cleanup is the highest-return work you can do with GPT-5.6.
FAQ
How do I prompt GPT-5.6?
State each instruction exactly once and delete repeated rules from old prompts, which OpenAI found raises scores 10 to 15% while cutting tokens up to 66%. Pick the right model tier, set a reasoning effort level, and describe tone as concrete behavior instead of vague adjectives.
What are the GPT-5.6 reasoning effort levels?
GPT-5.6 has six levels: none, low, medium, high, xhigh, and max. OpenAI recommends starting at whatever setting your last model used, then testing one level lower, since GPT-5.6 usually needs less thinking to reach the same answer. Save max for your hardest problems.
Is there a GPT-5.6 pro mode?
Yes. Set reasoning.mode to pro in the Responses API and GPT-5.6 applies extra computation before returning a single final answer. It stacks on any effort level and suits high-stakes requests. That differs from max effort, the top of the six effort levels, and from ChatGPT’s ultra mode, which spawns subagents.
Which GPT-5.6 model should I use, Sol, Terra, or Luna?
Use Sol ($5/$30 per 1M tokens) for your hardest problems, Terra ($2.50/$15) for everyday business work, and Luna ($1/$6) for cheap, high-volume tasks. OpenAI suggests starting with Sol, then testing whether Terra or Luna holds up on your real tasks to save cost.
What is programmatic tool calling in GPT-5.6?
Programmatic tool calling lets GPT-5.6 write a small JavaScript program to process tool results in an isolated runtime, then return only a compact result. Large datasets never pass through the model token by token, so data-heavy tasks run faster and much cheaper.
