In the previous article, we went through the contents of the dedicated GPT-5.6 prompting guide[^1] in detail. As a sequel, this article compares it with another guide OpenAI publishes — the general “Prompt engineering” guide[^2] — and briefly sums up “what, in the end, has changed compared with conventional prompting.”
Conclusion — From “precise instructions” to “defining the outcome”
Placing the two official guides side by side, we can organize them as follows.
| Basic approach of the general guide[^2] | Approach of the dedicated GPT-5.6 guide[^1] | |
|---|---|---|
| Analogy for the model | A GPT model is a “junior coworker” who needs explicit instructions | No analogy. Premised on leaving the choice of path to the model |
| Recommended writing style | Precise, explicit instructions | Defining the outcome, constraints, evidence, and completion bar |
| Handling of procedure | Decompose the task into sub-requests and confirm each | Do not prescribe the procedure; describe the “destination” |
| Supporting evidence | None stated | Evaluation score +10–15%, tokens −41–66%, cost −33–67% (a sample of internal coding-agent evals; varies by workload) |
Below we look at the basis for each.
The conventional basic approach — “A GPT model is a junior, it needs precise instructions”
The general “Prompt engineering” guide explains how to write instructions to the model by analogy with people.
A reasoning model is like a senior co-worker. You can give them a goal to achieve and trust them to work out the details. A GPT model is like a junior coworker. They’ll perform best with explicit instructions to create a specific output.
(A reasoning model is like a senior colleague: give it a goal to achieve and you can trust it to work out the details. A GPT model is like a junior colleague, producing its best results only when given explicit instructions to create a specific output.)
The same guide goes on to say the following.
Generally speaking, reasoning models will provide better results on tasks with only high-level guidance. This differs from GPT models, which benefit from very precise instructions.
(Generally speaking, reasoning models produce better results even with only high-level guidance. This differs from GPT models, which benefit from very precise instructions.)
On the handling of multi-step tasks, the same guide’s “Agentic tasks” section states the following, recommending an approach that makes the procedure explicit — decomposing the task and confirming each part.
Decompose the user’s query into all required sub-requests, and confirm that each is completed.
(Decompose the user's request into all the required sub-requests, and confirm that each has been completed.)
This is the official-guide grounding for the writing style many engineers have grown accustomed to: “decompose the task into steps and give the model detailed instructions.”
The approach of the dedicated GPT-5.6 guide — hand over the outcome and leave the path to the model
The dedicated guide for GPT-5.6 Sol, by contrast, sets out the following sentence as its premise (a point covered in detail in the previous article).
GPT-5.6 works best when prompts define the outcome, important constraints, available evidence, and completion bar, then leave room for the model to choose an efficient path.
(GPT-5.6 works best when the prompt defines the outcome, the important constraints, the available evidence, and the completion bar, and then leaves the choice of an efficient path to the model.)
On that basis, it states that a configuration that trims the instructions to be leaner comes with figures like the following.
In a sample of internal coding-agent eval runs, configurations with leaner system prompts improved evaluation scores by roughly 10–15% while reducing total tokens by 41–66% and cost by 33–67%. Results will vary by workload, so treat these ranges as directional and validate changes on representative tasks from your own application.
(In a sample of internal coding-agent eval runs, configurations with leaner system prompts improved evaluation scores by roughly 10–15% while simultaneously reducing total tokens by 41–66% and cost by 33–67%. Because results vary by workload, treat these figures as directional reference values and validate them on tasks representative of your own application.)
These figures have not been demonstrated to bring comparable improvements in other uses such as chat or writing, and the guide itself asks that they be treated as directional reference values that change with the workload.
The general guide’s approach — “for a junior, decompose into sub-requests” — and the dedicated guide’s approach — “the outcome, not the procedure” — point in opposite directions. The dedicated guide does not explicitly contrast this difference with the general guide, but for the same model, GPT-5.6, two different official recommendations on how to write instructions coexist.
Writing the same request two ways
An actual example given by the dedicated guide is as follows.
Resolve the customer's issue end to end.
Success means:
- make the eligibility decision from available policy and account evidence
- complete any allowed action before responding
- return completed_actions, customer_message, and blockers
- if required evidence is missing, ask for the smallest missing fieldRewriting the same request in the general guide’s approach (a style that makes the procedure explicit) yields the following (this is not an OpenAI example but one created by this article for comparison).
1. Read the customer's inquiry and check the contract and terms of service
2. Determine whether the customer is eligible
3. If eligible, carry out the response such as a refund or exchange
4. Summarize the response and reply to the customer
5. If information is missing along the way, confirm with the responsible staff before proceedingThe former defines “what counts as complete” (the conditions for success) and leaves the assembly of the steps to reach it to the model. The latter specifies the steps themselves, from 1 to 5, and the model’s role comes closer to executing the given steps in order. The reason the dedicated guide reports improved evaluation scores and reduced tokens is that, in many situations, the former style makes it easier for the model to choose an efficient path.
Relation to agentic tasks
The dedicated guide also has a section on how to report during multi-step tasks. The approach is to give a short preamble before the first tool call, and thereafter update only when the situation changes substantially.
Do not ask the model to narrate routine tool calls.
(Do not have the model narrate routine tool calls one by one.)
Note that the body of the dedicated guide (as of the July 16, 2026 archive) did not cover Codex or ChatGPT Agent. OpenAI’s documentation has been updated since, and the related current Model guidance has a section titled “Migrate with Codex.” The details of behavior in autonomous, long-running tasks are covered in the previous article.
From “writing instructions” to “designing the task”
Summing up the above, the general guide’s approach of “give GPT models precise instructions” has not, in OpenAI’s official documentation, been withdrawn. On top of that, for GPT-5.6 the dedicated guide recommends a style that defines the outcome, constraints, evidence, and completion bar, together with measured data. How to read the coexistence of these two approaches is a matter of interpretation on the part of this article, but at least as far as GPT-5.6 is concerned, the center of gravity of the work humans handle seems to be shifting from writing the “procedure” of detailed instructions to “designing the task” — defining the outer frame of outcome and constraints.
Summary
- OpenAI’s general “Prompt engineering” guide likens a GPT model to a “junior who needs precise instructions” and recommends a style of decomposing the task into sub-requests and confirming each
- The dedicated GPT-5.6 prompting guide recommends a style of defining the outcome, constraints, evidence, and completion bar and leaving the choice of path to the model. The effects it cites — evaluation score +10–15%, tokens −41–66%, cost −33–67% — come from a sample of internal coding-agent evals, and the guide itself notes that they vary by workload
- Even for the same request, “specifying the steps one through five in order” and “defining only the conditions for success” differ greatly in how much is left to the model
- The two guides do not explicitly contrast their approaches, and the general guide’s “precise instructions” approach has not been withdrawn. Even so, for GPT-5.6, the center of gravity seems to be shifting from writing instructions to designing the task
References
- Prompting guidance for GPT-5.6 Sol — OpenAI Developers (archived as of July 16, 2026). For a detailed explanation, see the previous article. The archived version was used as the primary source so that the content at the time of citation can be referenced in a fixed form (the original URL was confirmed to display differently depending on the access environment as of July 17, 2026). The related current document is Model guidance (confirmed July 17, 2026).
- Prompt engineering — OpenAI Developers (confirmed July 17, 2026)