GPT-5.6 Sol Hits 8 Million Users—and Changes How We Should Write Prompts

Introduction

Only days after the release of GPT-5.6, OpenAI reported another sharp rise in adoption. At the time of the original report, Codex and ChatGPT Work had passed 8 million active users, and OpenAI had once again reset usage limits for everyone.

The growth story is striking, but the more useful lesson may be hidden in OpenAI's new GPT-5.6 prompting guidance. The company is now encouraging developers to remove repeated rules, unnecessary examples, bloated tool descriptions, and step-by-step instructions that the model no longer needs.

For GPT-5.6 Sol, a strong prompt is less about controlling every move and more about defining the destination: the required result, hard constraints, available evidence, approval boundaries, and the standard for completion.

Eight Million Users Push Codex and ChatGPT Work to a New Milestone

Tibo, who leads Codex and ChatGPT at OpenAI, announced that the combined active-user count for Codex and ChatGPT Work had reached 8 million. OpenAI also reset usage limits again and continued operating without the previous five-hour rate limit.

The pace was unusually fast. According to the original report, the combined user count rose from 6 million to 7 million and then to 8 million within a few days of GPT-5.6's launch.

Usage resets also became frequent enough to turn into a running joke among users. Some people described the pattern as a daily refresh that kept weekly limits out of sight, especially for those who had not fully consumed their restored allowance before the next reset arrived.

The resets should not be interpreted as a permanent entitlement or a fixed product policy. They were public responses to a rapid adoption surge, and limits can vary by plan, model, workload, and current capacity.

OpenAI Warns That Scaling May Be Uneven

Sam Altman said demand for GPT-5.6 Sol was growing rapidly and credited the inference team with expanding capacity to support it. He also warned that users might see occasional service hiccups while the infrastructure continued to scale.

That warning matters because a usage reset does not remove the underlying cost of serving a reasoning model. More users, longer agent runs, parallel tools, and higher reasoning settings can all increase compute demand.

The practical takeaway is simple: restored limits may create more room to experiment, but teams should still design workflows around measured quality, latency, and

cost rather than assuming unlimited capacity.

The Price Story Is Really an Efficiency Story

Altman also said GPT-5.6 Sol was priced at roughly half the cost of a competing model he referred to as Fable, while using about half as many tokens in many comparable tasks.

If a model costs half as much per token and completes the same work with roughly half the tokens, the total cost can approach one quarter of the comparison baseline in those specific cases.

That is not a universal formula. OpenAI’s own documentation repeatedly recommends testing representative workloads because model choice, reasoning effort, tool usage, caching, latency, and output requirements all affect the final cost.

Still, the direction is clear: the value of GPT-5.6 is not only that each token may be cheaper. The model is also designed to get more useful work from fewer tokens.

Your Old Prompt Library May Need a Rewrite

For several generations of AI models, prompt engineering often meant adding more structure.

Teams built long system prompts with detailed roles, repeated warnings, XML blocks, persistence instructions, examples, tool descriptions, and explicit process steps. Whenever the model failed, another rule was added.

GPT-5.6 Sol changes that balance.

OpenAI’s current model guidance says GPT-5.6 has stronger intent understanding and often does not need every intermediate step prescribed. Developers should still provide domain context, hard constraints, approval boundaries, evidence requirements, and success criteria—but they can give the model more freedom to choose the working path.

In a sample of OpenAI’s internal coding-agent evaluations, leaner system prompts reportedly:

• Improved evaluation scores by roughly 10% to 15%
• Reduced total token usage by 41% to 66%
• Reduced cost by 33% to 67%

OpenAI describes these figures as directional rather than universal. They should be validated against the tasks, tools, and evaluation suite used in your own application.

The Four-Part Prompt Structure

A practical GPT-5.6 prompt can usually be organized around four elements:

1. Outcome — What finished result should the model deliver?
2. Constraints — What scope, safety, permission, or policy boundaries must it respect?
3. Evidence — What files, data, documentation, or source material should guide the work?
4. Acceptance criteria — What must be true before the

task is considered complete?

This approach gives the model a clear contract without forcing it through a rigid route.

Example: Auditing a Codebase for Security Risks

An older prompt might assign the model a senior-security-engineer role, specify every file-navigation step, dictate the order of analysis, repeat warnings, and prescribe the exact reporting workflow.

A leaner GPT-5.6 version could look like this:

Outcome:
Audit this repository and identify high-severity security vulnerabilities.

Constraints:
Focus on authentication and input validation.
Do not change production configuration or modify files.
Report each issue once without repeating the same risk in multiple sections.

Evidence:
Use the attached architecture documentation and dependency inventory.
Do not invent missing implementation details.

Acceptance criteria:
For every finding, include the file location, the supporting evidence, the likely impact,
and a practical remediation.
Before finishing, verify each finding against these requirements.

The model can then decide whether to inspect a specific directory first, use subagents, run a non-destructive test, or compare dependencies against known patterns.

The user defines what good work looks like. The model chooses an efficient route within the permitted boundaries.

Three Guardrails for Giving the Model More Autonomy

Leaner prompting does not mean abandoning control. It means moving control to the places where it matters.

1. Define the Stop and Approval Boundaries

State which actions the model may perform independently and which actions require confirmation.

For example, reading files, inspecting logs, editing in-scope local code, and running non-destructive tests may be allowed. External writes, purchases, destructive actions, production changes, or a material expansion of scope should normally require approval.

A clear boundary is more useful than repeating “ask me first” throughout the prompt.

2. Require Self-Verification

Ask the model to check its output against the acceptance criteria before delivery.

This is especially useful for code review, research, document generation, data analysis, and multi-step tool workflows. The verification rule should be concrete: confirm required fields, test the change, cite evidence, or compare the final output with a supplied reference.

3. Start Small and Add Only What Is Missing

Begin with the smallest prompt and tool set that already works.

Remove or add one category at a time, then rerun the same evaluations. This makes it easier to identify which instruction actually improves quality and which one only adds tokens.

Rewriting an entire prompt stack in one pass may produce a cleaner result, but it also makes failures harder to diagnose.

One Extra Sentence Can Create Conflicting Instructions

GPT-5.6 follows instructions closely. That is useful when the prompt is coherent, but it makes contradictions more expensive.

A prompt may ask for a comprehensive answer in one section and a very short answer in another. It may tell the model to act autonomously, then repeat that it must ask for approval before every change. It may require

all available detail while also imposing a strict output limit.

Earlier models sometimes ignored one side of the conflict. A stronger instruction-following model may try to satisfy both, producing hesitant behavior, unnecessary approval requests, or an output that meets neither requirement cleanly.

The answer is not to add another paragraph explaining which rule matters most. The answer is usually to remove or reconcile the conflict.

What to Remove

OpenAI’s lean-prompt guidance supports removing:

• Repeated rules
• Examples that do not encode a real requirement
• Style instructions that do not change the desired result
• Process steps the model already performs reliably
• Tools that are irrelevant to the current task
• Long tool descriptions that repeat obvious information
• Multiple versions of the same approval rule

What to Keep

The prompt should preserve:

• The required outcome
• Relevant context and evidence
• Hard safety, policy, and permission boundaries
• Approval and stopping conditions
• Success criteria
• Required output structure
• Instructions that fix a measured failure
• Examples that encode an important product requirement

A useful rule is to keep the instructions that can change the result and remove the ones that merely repeat your preferred process.

Practical Advice for Using GPT-5.6 Sol

One widely shared set of user tips recommends cleaning up old instruction bundles, enabling Codex memory where appropriate, and starting with a moderate reasoning setting before moving higher.

The official guidance supports the same measured approach.

When migrating from GPT-5.5 or GPT-5.4, OpenAI recommends keeping the current reasoning setting as a baseline and testing that setting alongside one level lower. GPT-5.6 may maintain or improve quality with fewer tokens, but the best configuration depends on the workload.

For many production tasks:

• Use a lower setting when latency matters and the task is straightforward.
• Start around a balanced setting for general multi-step work.
• Move to higher effort only when evaluations show a meaningful improvement.
• Reserve the most expensive modes for difficult, quality-critical tasks.
• Compare task success, completeness, evidence quality, latency, token use, and total cost.

Choosing the highest setting by default can waste resources without improving the result.

The Real Shift Is From Micromanaging to Directing

The deeper change is not only technical. It is a change in how people collaborate with AI agents.

The old approach treated the model like a junior assistant who needed every step described in advance. The user planned the entire route, and the model executed it.

The newer approach is closer to directing an experienced operator. The user defines the

objective, boundaries, evidence, and quality bar. The model plans and executes the path, stopping when it reaches a decision or action that requires human approval.

This does not eliminate prompt engineering. It raises the level at which prompt engineering happens.

The most valuable work is no longer writing hundreds of procedural instructions. It is deciding:

• What result actually matters
• What evidence is trustworthy
• Which actions are authorized
• Which risks require a human decision
• How the final output will be tested
• When the agent should stop

As models become more capable, excessively detailed prompts can create the very friction they were meant to prevent.

Frequently Asked Questions

What is GPT-5.6 Sol?

GPT-5.6 Sol is the flagship model in OpenAI’s GPT-5.6 family. OpenAI positions it for complex production workflows, coding, knowledge work, tool use, and tasks where quality and token efficiency both matter.

Why can shorter prompts perform better with GPT-5.6?

GPT-5.6 can infer more of the user’s intended workflow and does not always need every intermediate step prescribed. Removing repeated or conflicting instructions reduces prompt overhead and gives the model a clearer objective.

What should a good GPT-5.6 prompt include?

A strong prompt should define the outcome, relevant context, hard constraints, approval boundaries, evidence requirements, success criteria, and required output format. Include process instructions only when they encode a real requirement or correct a measured failure.

Should I delete all prompts written for earlier GPT models?

No. Start from a prompt that already works, remove one group of instructions at a time, and rerun the same evaluations. Keep anything that protects safety, permissions, product behavior, output requirements, or a known edge case.

Does lean prompting mean giving the model unrestricted autonomy?

No. The model should have freedom only within clearly defined boundaries. External writes, destructive actions, purchases, production changes, or scope expansion should still require explicit approval when appropriate.

Are the reported token and cost reductions guaranteed?

No. OpenAI describes the 10–15% score improvement, 41–66% token reduction, and 33–67% cost reduction as directional results from internal coding-agent evaluations. Actual results depend on the application, prompt, tools, reasoning settings, and evaluation criteria.

Which reasoning effort should I use with GPT-5.6 Sol?

Start with the setting used by your current production workflow and compare it with one level lower. Increase reasoning effort only when representative evaluations show a useful improvement that justifies the additional latency and cost.

Related Tools

• ChatGPT Work: An agentic workspace for completing documents, research, spreadsheets, presentations, and other end-to-end tasks.
• OpenAI Codex: OpenAI’s coding-agent environment for understanding, changing, testing, and reviewing software.
• OpenAI API Platform: The official platform for building applications with GPT-5.6 and other OpenAI

models.

• OpenAI Evals: Tools for testing prompt and model changes against repeatable evaluation criteria.
• OpenAI Prompt Optimizer: A tool for improving prompts against defined graders and evaluation examples.

Related Links

• GPT-5.6 Official Announcement: OpenAI’s overview of the GPT-5.6 family, performance, availability, and pricing.
• GPT-5.6 Model Guidance: Official prompting, migration, reasoning, caching, and tool-use guidance for GPT-5.6.
• OpenAI Prompt Engineering Guide: General guidance for writing and managing prompts with current OpenAI models.
• OpenAI API Pricing: Current official token and service pricing for OpenAI API products.
• ChatGPT Overview: Official information about ChatGPT, ChatGPT Work, and Codex capabilities.
• Tibo’s 8 Million User Announcement: The post announcing 8 million active users and another usage-limit reset.
• Sam Altman on GPT-5.6 Sol Efficiency: The post comparing GPT-5.6 Sol pricing and token efficiency with Fable.

Summary

The original report captured two related developments: the rapid growth of Codex and ChatGPT Work, and a shift in how OpenAI recommends prompting its newest model.

GPT-5.6 Sol is designed to handle more of the planning itself. The most effective prompts increasingly focus on the required result, constraints, evidence, approvals, and completion standard rather than prescribing every step.

Teams should simplify prompts gradually and validate each change with representative evaluations. Shorter is not automatically better; clearer, non-redundant, measurable instructions are.

The core lesson is to define the destination precisely, set the boundaries clearly, and stop micromanaging the route.