GPT-5.6 Pays You to Delete Your System Prompt: State Every Rule Once and Stop Repeating Yourself

The highest-return prompt work you can do this week is not adding anything. It's deleting.

On July 9, 2026, OpenAI shipped its official prompting guide for the GPT-5.6 family (the flagship is codenamed Sol, with Terra and Luna as the price/performance and high-volume siblings). The guide reverses advice a lot of us internalized over the last two years. The old GPT-5 playbook told you to restate important rules, add "keep going until done" persistence blocks, and bolt on brevity constraints. On GPT-5.6, that same scaffolding measurably lowers output quality.

The single strongest recommendation in the guide: state each instruction exactly once. Then delete the duplicates, the redundant examples, the persistence padding, and the inherited "be brief" rules. This post shows you how to run that subtraction pass without breaking your agent.

The numbers, stated honestly

OpenAI's internal coding-agent evals found that swapping long explicit system prompts for lean ones improved evaluation scores by roughly 10 to 15% while cutting total tokens by 41 to 66% and cost by 33 to 67%.

Read that caveat before you get excited. OpenAI labels these figures "directional." They vary by workload, and the guide asks you to validate on your own representative tasks. These are not guarantees you can quote at a stakeholder meeting. They are a strong signal that the shape of a good prompt has changed.

Why redundancy went from helpful to harmful

Older models were sloppy instruction-followers. You repeated a rule in three places because that was the only way to make it stick. GPT-5.6 follows what the guide calls "prompt contracts" literally. When two rules overlap or quietly contradict each other, the model burns reasoning tokens trying to reconcile both. The result is slower, more expensive, and often wrong.

The guide puts it plainly: "conflicting rules can create more instability than missing detail."

So the duplicated instruction you added as a safety net is now the thing making your agent hesitate. Repetition reads as a second, slightly different rule, and the model tries to honor both.

What the subtraction pass looks like

Here is a bloated system prompt of the kind that was normal in 2025. Every line felt responsible when it was written.

You are a customer support agent. Be concise. Keep responses brief.
Resolve the customer's issue. Always be helpful and thorough.
Do not stop until the issue is fully resolved. Keep going until done.
Before taking any action that changes data, ask the customer first.
Never mutate account data without permission. Always confirm before writing.
Limit responses to three sentences. Be efficient and to the point.
If you are unsure, ask. Do not guess. When uncertain, request clarification.
Resolve the issue end to end and do not give up early.

Count the collisions. "Be concise," "keep responses brief," "be efficient," and "limit to three sentences" are four versions of one idea, and the three-sentence cap will truncate a legitimately complex answer. "Ask before you change data" appears three times, which on GPT-5.6 can trigger permission checks even for safe, expected actions. "Keep going until done" appears twice, and Sol is already persistent by default.

Now the lean rewrite. You can produce it by hand, or you can hand the old prompt to the model and ask it to do the cut for you.

The Prompt: ``` You are a prompt editor. Below is a system prompt for a GPT-5.6 agent.

Rewrite it so that: - Each distinct instruction appears exactly once. - Remove duplicated rules, restated brevity constraints, and any "keep going until done" persistence padding. - Keep every stopping condition, success criterion, and hard authorization boundary intact, stated once and clearly. - Do not add new rules. Only remove, merge, or tighten existing ones.

Return the rewritten prompt, then a short list of what you removed and why, so I can confirm nothing load-bearing was cut.

[paste the old system prompt here] ```

Why This Works: The last constraint is the one that matters. A rewrite with a list of cuts turns the edit into something you can review line by line, and "do not add new rules" stops the model from replacing your duplicates with fresh ones of its own.

Expected Output:

You are a customer support agent. Resolve the customer's issue end to end.

Lead with the answer or the next step, and include any caveat that matters.
Use the length the issue needs.

Ask the customer before you change any account data.
If you are unsure what the customer needs, ask one clear question instead of guessing.

Removed: "Be concise," "Keep responses brief," "Be efficient and to the point" (one idea stated four ways). Removed the three-sentence cap, because it would cut off answers to complex issues. Removed "Do not stop until the issue is fully resolved," "Keep going until done" and "do not give up early" (covered by "end to end"). Merged three versions of the data-change rule into one. Merged three versions of "ask when unsure" into one. Removed "Always be helpful and thorough" (no behavior attached).

Eight lines became five, and every boundary from the original is still there, stated once.

What you keep

Subtraction is not "delete until it breaks." OpenAI's guidance says GPT-5.6 is better at inferring the user's goal and the intended level of work, but you should still give it domain context, hard constraints, approval boundaries and success criteria, and tell it when an ambiguity is important enough to ask about. Those are the load-bearing lines. Everything else has to earn its place.

The guide is just as specific about examples and style rules: keep them when they encode a product requirement or fix a gap you actually measured. An example that exists because someone once saw a bad output in 2025 and never checked again is a candidate for the cut.

Put the approval rules in one place

The repeated "ask before you change data" lines are the most expensive kind of duplication, because they make the agent ask permission for things you wanted it to just do. OpenAI's fix is to define what level of action a request authorizes, name the safe actions out loud, and keep the whole policy in one place.

The Prompt:

Action policy:
- Without asking: read account details, order history and help articles;
  look up order status; draft a reply.
- Ask first: any change to account data, refunds, cancellations,
  or anything outside the customer's own account.

Why This Works: The agent no longer has to guess whether looking up an order counts as "taking an action." The safe list removes the false permission checks, and the ask-first list keeps the real boundary. The guide makes the same split for coding agents: answer, review and diagnose requests get inspected and reported, in-scope local changes and non-destructive tests run without asking, and external writes, destructive actions, purchases or a big expansion of scope need confirmation.

Replace "be brief" with what a short answer must include

GPT-5.6 is more concise by default than GPT-5.5, and the guide warns that broad rules like "Be concise" or "Keep it short" may be unnecessary and can make answers too brief. That is exactly what the three-sentence cap in the old prompt would have done.

Two changes replace the brevity pile. Set the default level of detail with the text.verbosity parameter instead of prompt text. Then, in the prompt, say what an answer cannot drop. The guide's own phrasing is a good template: lead with the conclusion, include the evidence that supports it, any material caveat, and the next action, and trim introductions, repetition and generic reassurance first.

Run the cut one group at a time

Do not ship the lean prompt because it reads better. The guide's method is to start from a prompt that already works, remove one group of instructions, examples or tools at a time, and rerun the same evals after each cut.

1. Collect 20 to 50 real requests from your logs, including the awkward ones: ambiguous asks, requests that should trigger a confirmation, and requests that should not.
2. Run them on the current prompt and save the outputs as the baseline.
3. Remove one group, for example all the brevity rules. Rerun and compare.
4. Keep the cut if quality holds or improves. Put the group back if something real broke, and write down why it stays.
5. Move to the next group: persistence padding, duplicated boundaries, then examples, then tools the task does not need.

Tools count too. The guide says to expose only the tools relevant to the task and keep their descriptions short and precise, since every tool description is more prompt the model has to read and reconcile.

The habit to keep

Most system prompts grow by accretion. Someone sees a bad output, adds a line, and nobody ever removes one. On GPT-5.6 that habit costs you twice, in tokens and in a model that hesitates between rules that almost agree. Make the subtraction pass part of every model migration: one rule, stated once, kept only if your evals say it matters.

Want hands-on training on lean prompt design for GPT-5.6 and the other current models for your team? Connect with Kief Studio on Discord or schedule a session.