To get more accurate and detailed responses, more and more people write their prompts in increasingly complex ways. Besides basic roles, objectives, and output formats, they pile on XML tags, fixed execution steps, tool usage rules, and even emphasize “must” and “absolutely don’t.” At first glance, the more detailed you write, the less likely AI should be to make mistakes, but when it comes to The GPT-5.6 EraAfter that, OpenAI does not recommend doing this.
Recently, OpenAI released the latest GPT-5.6 Sol prompt guide, which can be summed up in one sentence: “Stop over-prompting.” Rather than telling AI exactly what to do at each step, what’s more important now is clearly stating the destination, key constraints, available evidence, and completion criteria—then letting the model choose the most efficient path on its own.
OpenAI found in a set of internal coding agent evaluations that using more streamlined system prompt configurations improved evaluation scores by approximately 10-15%, reduced total Token usage by 41-66%, and lowered costs by 33-67%. However, the company also emphasized that these results are from specific workloads only, and actual improvements should be verified with your own applications and test cases.
OpenAI Urges an End to Over-Prompting! GPT-5.6 Prompt Rewrite Guide: Concise Rules Can Save Up to 67% on Costs
In the past, prompt engineering often treated models as programs that needed to be operated step by step.
Users specify which document to read first, what to search for next, how many sources to find before comparing them, and finally the fixed order for outputting results. If the model ever misses a step, another rule gets added. When a different error occurs next time, another exception gets added. Over time, the system prompt becomes extremely long, with the same thing potentially written three times.
The prompt approach of GPT-5.6, on the other hand, is more like treating AI as a collaborator that can independently plan its own work.
You should also clearly tell it what the final deliverable should be, what conditions make it complete, what evidence is required, and what boundaries it cannot cross—but you don’t need to pre-plan all its routes.
For example, when instructing AI to handle customer service issues, instead of specifying steps like “first search policies, then read account information, then compare the three terms, and finally write a response,” it’s better to be direct and clear: “Complete eligibility determination based on current policies and account evidence; execute and complete any authorized and executable actions first; responses must list completed actions, customer-facing explanations, and current blockers; if required evidence is missing, only ask for the minimum missing fields.”
The latter prompt is much shorter in content, but it clearly specifies the deliverables, evidence, permissions, output format, and how to handle missing data. This means the model knows where the destination is and where the guardrails are, but whether it should query once or twice along the way, or which tool to use first, is left for it to determine based on the current situation.
OpenAI mentioned that GPT-5 series models will be stricter about the “contracts” embedded in prompts.
Imagine a single prompt that on one hand requires “answers must fully explain all background,” while on the other hand states “always keep it brief.” One part demands “when data is insufficient, you must ask the user,” yet another part insists “never ask questions back.” Even a human reading this would wonder which instruction to follow, and the model has to expend reasoning resources to determine which rule takes priority.
OpenAI recommends keeping the final deliverables users can see, success criteria, stopping conditions, safety and business constraints, evidence requirements, authority boundaries, situation-dependent tool selection rules, and necessary output formats. On the other hand, redundant rules that merely rephrase the same thing, examples that don’t affect behavior, and basic steps the model can already reliably handle should be prioritized for removal.
Also, avoid overusing absolute terms like `Always`, `Never`, `must`, or `only`. For things that truly involve security boundaries, required fields, or actions that must never occur, you can certainly be explicit. However, decisions like when to search, when to ask, whether to use tools, or whether to keep retrying usually depend on context and are better expressed as decision rules.
Here are 5 effective prompting techniques provided by OpenAI.
Tip 1: Start with Simplification
OpenAI’s first suggestion is not to rewrite the entire prompt from scratch, but to start from a working version and only remove one group of content at a time.
First, you can find the different versions of the same rule, stylistic and procedural requirements that don’t affect behavior, and tools and tool descriptions that aren’t relevant to this task.
For example, if a customer service prompt contains these three statements: “confirm data before answering,” “never draw conclusions without evidence,” and “all important answers must be supported by account information,” they can be consolidated into a clearer rule like: “Important conclusions must be supported by account or policy evidence; if necessary data is missing, only ask for the minimum required fields.” This way, even though the number of rules is reduced, the essential behaviors are preserved.
More tools don’t necessarily make you more powerful. The GPT-5.6 guide recommends only providing tools relevant to the task, with clear documentation of what each tool does, when to use it, important response fields, and error behaviors. If you’re just checking an order, providing a long list of unrelated tools like image generation, code editing, and email sending will only make the model waste time figuring out which options to ignore.
Tip 2: Outcome-First & Stopping Conditions
Prompts should directly describe what success looks like, along with when to stop. This is especially important for AI agents that can search the web, read files, or repeatedly call tools, because when there are no stop conditions, the model may have already found sufficient evidence, but will run several more rounds of search just to add an unimportant example or polish a sentence.
The original approach might be: “Search the official website first, then find three sources, summarize each one, double-check keywords, and finally organize the answer.” After switching to a results-first approach, you could write it as: “Find reliable evidence sufficient to answer the core question, with important facts cited; answer directly when evidence is sufficient, only continue searching when essential dates, numbers, or official statements are missing.”
Stop conditions shouldn’t just tell the model to find any result and call it done. OpenAI specifically reminds that reducing tool loops cannot come at the expense of correctness, necessary evidence, computation, or citations. A better approach is to require the model, after receiving each result, to determine whether the existing evidence can answer the core question—if yes, provide the answer; if not, identify the missing key facts, then apply the minimal remediation.
Tip 3: Precise Control of Length and Tone (Length & Personality)
GPT-5.6 defaults to being more concise than GPT-5.5, so the common “Be concise” or “Keep it short” prompts may no longer be necessary—and for certain tasks, responses might even end up too short, missing critical constraints.
OpenAI recommends using `text.verbosity` in the Responses API to set the overall verbosity level, which can be `low`, `medium`, or `high`, with the prompt then providing additional details on the length, structure, and essential content required for the task.
If you want concise answers, don’t just write “be brief.” Instead, tell the model the priority for what to keep: “Lead with the conclusion, keeping the evidence that supports it, major limitations, and next steps; prioritize removing lengthy introductions, repetitive statements, formulaic reassurances, and unnecessary background.” This way, the model knows what cannot be cut even when brevity is essential.
OpenAI also separates “personality” from “collaborative style.” Personality governs tone, warmth, formality, humor, and empathy, while collaborative style determines when the model asks questions, when it makes assumptions on its own, how proactive it should be, how it explains trade-offs, and how it handles uncertainty.
Both should be brief, and cannot replace the objectives, success criteria, tool rules, and stop conditions.
Something like “be friendly” is too vague, but can be refined to: “answer questions directly; when users report issues, first point out the specific situation, then provide next steps. Only offer reassurance when it’s genuinely helpful, and skip formulaic praise or unnecessary endings.” This approach to prompting is more likely to produce consistent results than simply requiring “be friendly, professional, and concise.”
Tip 4: Clearly Define Autonomy
GPT-5.6 can proactively execute multi-step tasks, but how far the model should go should be determined by the user’s requirements and prompts together.
The official recommends using a concise policy to clarify which actions can be performed directly, which are limited to inspection and reporting, and which absolutely require obtaining consent.
For example: when users request answers, explanations, reviews, diagnoses, or planning, AI can read the relevant information and report results, but should not independently implement modifications.
When the user explicitly requests building, modifying, or fixing, I can edit local code, check logs, and run non-destructive tests within the specified scope without stopping to ask at every step. However, when it involves external writes, data deletion, purchases, destructive operations, or a significant expansion of the scope of work, I must still obtain confirmation first.
Tip 5: Leverage Programmatic Tool Calling (PTC)
Programmatic Tool Calling is an important new capability introduced in GPT-5.6.
In simple terms, models can generate JavaScript that coordinates multiple tool calls in an isolated execution environment provided by OpenAI, including parallel processing, loops, and conditional logic, and compresses large intermediate results before returning. External systems can only access through tools permitted by the application—this environment has no general network access, file system, Node.js package installation, or subprocess execution capabilities.
PTC is well-suited for scenarios with predictable control flow and for tasks that can be organized by programs into smaller, structured results, such as filtering, sorting, merging, deduplication, batch processing of large volumes of similar records, performing repetitive deterministic validations, or reducing numerous fields to a fixed format.
If a company has tens of thousands of orders and needs to identify inventory shortages, remove duplicate records, and sort by shortage quantities, this is a perfect task for code to handle. It can read both inventory and demand data simultaneously, calculate the gaps, and return only the necessary fields—without having to load all intermediate data back into the model’s context.
However, multiple tools or parallel calls themselves don’t necessarily mean PTC is required. If one call can complete the task, each result changes the next decision, the work involves approval, the final answer must preserve citations or original files, or semantic judgment is needed between each call, the model should directly use tools.
Deciding the real reason behind a complaint, determining whether to issue a refund, or preserving the original message and crafting a response—these aren’t things that should be fully handed off to code for automated processing.
Prompts shouldn’t just consist of a single sentence like “efficiently use PTC.” The official recommendation is to explicitly specify which finite stage it’s responsible for, which tools can be used, the output format, the maximum number of retries, under what conditions to stop, and when to hand the work back to the model.
Summary
In simple terms,The latest GPT-5.6 prompt guideIn fact, this is a reminder that the role of prompt engineers is changing. In the future, they’ll need to be more like managers who clearly articulate goals: specifying what needs to be accomplished, what standards define success, what data and tools are available, what safety and permission boundaries cannot be crossed, and finally validating results through testing.
As for what to do first at each intermediate step, how many searches are necessary, and what fixed order to use each tool in – none of these need to be hardcoded. Giving the route selection back to the model actually increases the chances of getting stable and efficient results.
You can also use the list below to check your prompts:
- Did you write the same thing more than once?
- Are there any conflicting length, question, or permission requirements?
- Are there any examples that no longer change behavior?
- Are there any tools unrelated to the current task?
- Is the final deliverable clearly defined?
- When is something considered complete?
- Does the model know when to stop, retry, or ask?
- Have you run the same tests after each change?
Source: KOCPC Chinese