On November 17, 2026, OpenAI released GPT-6.2 Astra and GPT-6.2 Sol. Benchmark numbers looked strong, yet early testing by developers triggered sharp criticism: users complained that the models gave overly terse replies, stalled mid-task to ask unnecessary questions, and drifted during longer workflows.
In response, OpenAI published and updated its official Using GPT-6.2 guide (updated November 18–21, 2026). Rather than giving vague high-level advice, OpenAI included copy-paste system prompts tailored to GPT-6.2 Astra and Sol. I broke down those recommendations and paired them with two hands-on experiments on GPT-6.2 Astra - along with a baseline comparison against GPT 6 Astra and Claude Fable 5.2 - to see how the vendor's advice holds up in practice.
Why OpenAI Published These Tips: Release Context
Right after the November 17 launch, several well-known developers and teams publicly criticized the models' real-world behavior (see our GPT-6.2 Astra and Sol review roundup):
- Theo Browne shared a telling failure: Astra spent two hours building an Outer Wilds level with subagents, then stopped and asked the user for an internal video filename it could have looked up in the project itself.
- Matt Shumer noted that while raw intelligence was high, the models felt "practically unusable" in daily work due to frustrating communication habits and instruction-following issues.
- The Every team reported regressions in writing quality and visual design.
In its Prompting best practices section, OpenAI explicitly notes that the prompts below address specific behaviors observed when working with GPT-6.2 Astra and Sol.
1. Writing Style and Fixing Overly Brief Answers
By default, GPT-6.2 Astra and Sol write more concisely and directly than earlier models. Because of this, OpenAI's first migration recommendation is to revisit legacy instructions like "be concise" in your system prompt, otherwise the model may clip useful context.
To tune tone and completeness, OpenAI provides three verbatim prompts for different use cases.
Option A - Collaborator and Thought Partner
Official OpenAI prompt:
Write using terminology the user and sources use. Keep technical details and use domain-specific language when they make the explanation more precise. Use the active voice and keep closely related details together. Cover the key points up front, and avoid references that the reader can only make sense of later in the response. Give the user enough context to follow your reasoning.Why it helps: keeps domain-specific accuracy intact, places key conclusions upfront, and ensures the reader has enough context without hunting through the rest of the reply.
Option B - Drafting Material for External Audiences
Official OpenAI prompt:
When drafting a message or any other material on behalf of the user to be sent to an external audience, consider who will read it and tailor the content to that intended audience. The intended audience likely does not have the same context as the user, so ensure that you provide the background information or reasoning required for the audience to understand the content. When reviewing or editing existing content, preserve the author’s content and wording, and follow the user's instruction carefully for what edits they want.Why it helps: stops the model from assuming external readers share your internal context, and prevents unwanted rewrites when editing existing drafts.
Option C - Self-Contained Final Answers After Long Tasks
Official OpenAI prompt:
Treat your final answer as the user's first look at your work, and not as a continuation of intermediate commentary. The final answer must always be fully self-contained: users should never need to read earlier commentary updates for context, since they are collapsed when the final answer is shown to the user.
Write the final answer and all other human-facing material anew for the intended reader. Do not copy or closely paraphrase your reasoning or adopt its writing style. Do not carry over working shorthand, jargon, or abbreviations from your reasoning, tool calls, or instructions to subagents and automations.Why it helps: in multi-step agent runs, models often leak intermediate shorthand or subagent jargon into the final answer; this forces a clean, self-contained summary written from scratch for the reader.
2. Stopping Unnecessary Questions and Mid-Task Pauses (Task Completion)
When intent is slightly unclear, GPT-6.2 may propose a next step and pause for confirmation. To prevent stalled workflows, OpenAI provides three official prompt blocks.
Option A - Clear Stopping Boundaries
Official OpenAI prompt:
Avoid stopping to end the turn while the task is incomplete or if there is an authorized next step you can take, and instead take the next steps within task scope to progress the user's request. If your final response before ending the turn is a suggested next step, a plan, a request to the user for a routine decision, instructions for a task to execute, or similar handoff to the user, take these steps yourself to make progress towards what the user asked for. Make sure that you have authorization to do so, and flag any assumptions or decisions you maketo the user.
Only stop to clarify with the user if there is significant change in task scope, you are concretely blocked, have a decision that the user needs to resolve, or before irreversible or destructive actions.(Note: OpenAI's published guide contains the typo maketo - change it to make to when pasting into production.)
Option B - Bias Towards Action and Final Verification
OpenAI pairs this block with setting a higher reasoning.effort on complex tasks so the model completes final checks:
Bias towards action, and persist until you've completed the task the user asked for. Avoid stopping to end the turn while the task is incomplete or if there is an authorized next step you can take, and instead take the next steps within task scope to progress the user's request. Make sure that you have accounted for every part of the user's request, and persist until you've delivered a result that fully satisfies the user's goal. If a task requires sustained work, do all the necessary work until the intended outcome is completely fulfilled.
Progress autonomously towards the user's goal (e.g. creating isolated worktrees / checkouts if needed, resolving merge conflicts, creating draft PRs etc) unless they are clearly destructive or irreversible. Before ending a turn or calling your work complete, check that your work fully satisfies what the user asked for. If any steps remain or any part of the result still needs verification, follow through on this work before finishing.Option C - Short Rule for Reversible Assumptions
Official OpenAI prompt:
Make reasonable, reversible assumptions to carry work forward and state them if it progresses the task within scope. Do not second guess yourself, stop after describing what you could do, offer to do the work, or provide a partial answer unless there is no way you can proceed.OpenAI also notes that integrating an async clarification tool such as request_user_input_async lets GPT-6.2 ask the user while continuing independent parts of the job in parallel.
3. Coding Style: Reusing Logic, Skipping Unneeded Tests, and Readability
OpenAI focuses on keeping generated code maintainable, avoiding over-engineering, and preventing unnecessary test bloat. Here is the official Coding style prompt:
Above all, be thorough in producing high-quality, correct code that completely fulfills the user's task. Keep the code easy to read and verify that the user-requested outcome works as they intend. Follow these instructions when coding:
(a) Reuse existing logic in the user's repo when you can. You should reuse existing classes, methods, representations, and APIs in the codebase as long as they preserve correctness. Before consolidating or removing code, preserve the behavior its callers rely on unless the task requires changing it.
(b) Skip new tests unless requested, required by the repo, or needed to catch a specific regression existing tests would miss.
(c) Make sure that code is human readable. Do not use fewer lines, shorter variable names, minified formatting, or dense one-liners as substitutes for simplicity. Ensure that comments and variable names are readable and understandable to a human. Code-golfed expressions count as overly complex when they encode many branches, conditions, or hidden assumptions.
(d) Avoid unnecessary indirection and abstraction. Helper functions, utility functions, and class abstractions can add cognitive complexity even when they do not add branches.4. Frontend Design: Cutting Clutter and Defining Visuals
If an interface needs a specific look, OpenAI advises specifying image types and typography (including exact typefaces when relevant) alongside this official Frontend design prompt:
When generating webpages or apps with a frontend user interface, follow these instructions:
- When choosing visuals, generally prefer realistic images from ImageGen or image search that suit the project's style and purpose. Use SVGs when the user specifically asks for them.
- Include a text element only when it provides information the user needs, helps them navigate or act, or fulfills an explicit content request. Remove decorative numbering, filler badges, redundant headings, and explanatory copy that merely restates what the surrounding interface already makes clear, while preserving necessary labels, instructions, and status feedback.For complex UI work, OpenAI also recommends passing a visual reference from your design tool or giving GPT-6.2 access to the image generation tool.
5. Responses API Changes and Migration Rules
In What's new and Migration quickstart, OpenAI highlights four critical API updates for gpt-6.2-astra and gpt-6.2-sol:
- Prefix edits drop reasoning items: Editing earlier conversation turns (including past
developermessages or tool outputs), changing the end user/organization, or certain model switches cause the Responses API to drop saved reasoning items - lowering answer quality and wasting tokens. Keep the prefix unchanged. - Top-level
instructionsmoved afterinput: Starting with GPT-6.2,instructionsis appended after theinputarray. To keep reusable rules eligible for prompt caching, put them in adevelopermessage as the first item ininput, and reserveinstructionsfor per-request guidance. When migrating from GPT-5.5 or earlier, replaceprompt_cache_retentionwithprompt_cache_options.ttlset to"30m". - Reasoning effort and removed parameters: Start with
medium; replacenoneorminimalwithlow(reasoning.effortin Responses orreasoning_effortin Chat Completions). Removetemperature,top_p,logprobs,top_logprobs, andmessage.output_text.logprobsfrominclude. Tool calling requires the Responses API. - Background mode instead of Flex: GPT-6.2 Astra and Sol do not support
service_tier: flex; use Background mode (public beta) for 2-hour or 8-hour completion windows on Standard processing.
Example Payload (My Illustration Based on OpenAI's Docs)
OpenAI describes these fields in prose without a standalone JSON snippet - here is how they fit together in a Responses API request:
{
"model": "gpt-6.2-astra",
"reasoning": {
"effort": "medium"
},
"input": [
{
"role": "developer",
"content": "Reusable project rules and official OpenAI prompt blocks (eligible for prompt caching)..."
},
{
"role": "user",
"content": "User request..."
}
],
"instructions": "Per-request guidance only"
}6. My Experiments on GPT-6.2 Astra: Default vs. OpenAI vs. Hybrid Prompts
To see how much OpenAI's official templates change day-to-day outputs - and where extra prompt tuning still helps - I ran two live experiments on GPT-6.2 Astra (November 22–23, 2026; originally run in Russian, metrics reflect the original outputs).
Experiment 1. Client Delay Notice (Cross-Model Baseline + 3 Runs on GPT-6.2 Astra)
I used a short, realistic request packed with raw developer jargon that shouldn't be sent verbatim to a client:
"Write a message to a client: we are moving the launch from Friday to Tuesday because the database migration failed and the CDN cache got stuck."
First, I sent this bare prompt with no system prompt at all to three models - GPT 6 Astra (previous generation), GPT-6.2 Astra, and Claude Fable 5.2 - to compare their out-of-the-box defaults. Then I ran two more sessions on GPT-6.2 Astra: once with OpenAI's official Writing style Option B (for external audiences), and once with my own rules layered on top (warm professional tone, translating tech issues into business risk, and ending with a clear status-update schedule and contact option).
| Model & Run | Words | Characters | Completion tokens | Latency |
|---|---|---|---|---|
| GPT 6 Astra (default, no system prompt) | 36 | 263 | 66 | 3.2 s |
| GPT-6.2 Astra (default, no system prompt) | 39 | 272 | 73 | 2.8 s |
| GPT-6.2 Astra + official OpenAI prompt (Writing style B) | 44 | 330 | 84 | 7.1 s |
| GPT-6.2 Astra + OpenAI + my business-writing rules | 99 | 723 | 167 | 7.4 s |
| Claude Fable 5.2 (default, no system prompt) | 162 | 1,151 | 612 | 7.6 s |
Default outputs with no system prompt (translated from Russian):
GPT 6 Astra (previous version) - 36 words:
Hello! We are moving the launch from Friday to Tuesday: during prep, issues came up with the database migration and the CDN cache refresh. We need extra time to fix them and verify stability before launch. Sorry for the delay.
GPT-6.2 Astra - 39 words (almost the same abrupt note with raw tech jargon):
Hello! We are moving the launch from Friday to Tuesday. The database migration failed with an error, and the CDN cache did not update. We need time to fix both issues and verify the service before launch. Sorry for the delay. We will let you know when verification is complete.
Claude Fable 5.2 - 162 words (full email with user impact, client schedule check, and a shorter messenger option):
Subject: Moving the launch to Tuesday
Hi [Name],
Unfortunately, we have to move the launch from Friday to Tuesday, [date].
During release prep, two technical issues came up:
- The database migration failed with an error. We need to fix the root cause and re-run the migration to guarantee data integrity.
- The CDN cache is not updating properly. Some users would see an outdated version of the site.
Launching in that state is risky, so we want to fix both issues and run a full check before release. I'll let you know right away if anything changes.
Apologies for the inconvenience. If the shift affects your plans, such as email blasts or ads, let us know and we'll help adjust the schedule.
Best regards, [Name]
(Plus a ready-to-paste shorter version for messenger apps right underneath.)
How GPT-6.2 Astra evolved with prompts:
GPT-6.2 Astra + official OpenAI prompt - 44 words (jargon translated, but still very brief):
Hello! We are moving the launch from Friday to Tuesday. During launch prep, the data transfer could not be completed, and the content delivery network (CDN) kept serving outdated files. We need extra time to finish the transfer, refresh the CDN cache, and verify that the service works properly. Sorry for the schedule change.
GPT-6.2 Astra + OpenAI + my additions - 99 words (clear user impact, rationale, and next step):
Hello! We are moving the service launch from Friday to Tuesday. During launch prep, the database update could not be completed and the content delivery system kept serving outdated file versions. If we launch on Friday, users may hit errors or see outdated information.
We need the extra time to complete the database update, refresh the cache, and verify that everything works properly from the user's perspective. Sorry for the schedule change.
On Monday we will send an interim status update covering what has been fixed and what checks remain before launch. If the delay affects your plans and you want to discuss details earlier, reply to this email to schedule a call.
My custom additions paired with OpenAI's prompt in Run 3
Additional rules for a client-facing message:
- Write in a warm, respectful business tone rather than a dry automated notice.
- Explain technical causes in terms of business value and risk: why extra time is needed and why delaying is safer than launching with errors.
- End with a clear next step: when you will share an interim status update and how to reach you if the client wants to discuss details.Takeaway from Experiment 1: Out of the box, GPT-6.2 Astra (39 words) is nearly as terse as the older GPT 6 Astra (36 words). OpenAI's official prompt immediately fixes internal jargon ("database migration failed" → "data transfer could not be completed"), yet keeps the message almost just as brief (44 words). Meanwhile, Claude Fable 5.2 produced a thoughtful 162-word email (plus a messenger alternative) with zero system prompting - even though it kept the technical terms while explaining their impact. To get comparable polish from GPT-6.2 Astra, I still had to layer my own structure rules on top of OpenAI's template.
Experiment 2. Everyday Troubleshooting Without Device Context (GPT-6.2 Astra vs. OpenAI Guide vs. Claude Fable 5.2)
In the second test, I chose a question that intentionally omits the phone model - testing both depth and whether the model pauses to ask clarifying questions:
"Why does my smartphone drain battery faster after a system update, and what can I check myself before taking it to a repair shop?"
On GPT-6.2 Astra, I ran it twice (bare default and with two official OpenAI blocks: Writing style Option A + Task completion Option C), and also ran the same bare prompt on Claude Fable 5.2 with no system instructions.
| Model & Run | Words | Characters | Completion tokens | Latency |
|---|---|---|---|---|
| GPT-6.2 Astra (default, no system prompt) | 239 | 1,746 | 430 | 10.7 s |
| GPT-6.2 Astra + OpenAI prompt blocks | 308 | 2,233 | 585 | 15.1 s |
| Claude Fable 5.2 (default, no system prompt) | 323 | 2,363 | 1,586 | 16.6 s |
What changed:
- None of the runs stalled on clarifying questions upfront - both Astra and Fable 5.2 covered iPhone and Android automatically (Fable only offered at the end to give exact menu paths if the user shares their model).
- On GPT-6.2 Astra, OpenAI's templates added concrete diagnostic checks rather than fluff: leaving the phone charging overnight on Wi‑Fi if it isn't overheating, isolating weak cellular signal by comparing a normal night with airplane mode + Wi‑Fi, pointing to the exact iOS Battery Health menu, and explicitly stating not to factory reset yet.
- Claude Fable 5.2 out of the box delivered the most comprehensive structure (323 words split into 5 causes, 9 self-checks including Android Safe Mode and the 80% battery health threshold, and 4 repair-shop triggers), though at a noticeably higher output token count (1,586 completion tokens).
Side-by-side summary of GPT-6.2 Astra and Claude Fable 5.2 in Experiment 2
Run 1 - GPT-6.2 Astra Default (no system prompt, 239 words in original):
- Explains that for the first day or two after an update, re-indexing files/photos and background app sync increase drain, and service isn't needed if usage returns to normal.
- Points to battery usage stats on iPhone and Android and highlights background activity vs. expected drain (e.g., navigation during a trip).
- Lists 3 checks: (1) reboot and update outlier apps, trimming background access selectively; (2) compare drain under similar conditions and overnight with the screen off; (3) check battery health settings for degradation warnings or sudden drops.
- Advises saving a screenshot after 2–3 days if drain persists, and stopping use immediately if the chassis swells or overheats at rest.
Run 2 - GPT-6.2 Astra with OpenAI Writing Style + Task Completion blocks (308 words in original):
- Leads immediately with an actionable step: if the update happened yesterday and the phone isn't overheating, leave it charging overnight on Wi‑Fi so background indexing finishes over 1–3 days.
- Provides 4 detailed self-checks: (1) correlate battery timeline with active screen time to spot idle background drain; (2) update a culprit app, reboot once, and warn that restricting background access globally can delay messenger notifications; (3) isolate weak cellular signal drain by comparing one regular night with one night in airplane mode + Wi‑Fi, or checking screen brightness/auto-lock if drain happens during active use; (4) check iPhone Battery Health or Android built-in diagnostics, noting an OS update may simply coincide with battery wear.
- Concludes by advising screenshots for diagnostics, explicitly stating not to factory reset yet, and warning to unplug immediately if the chassis swells, the screen lifts, or the device overheats while idle.
Run 3 - Claude Fable 5.2 Default (no system prompt, 323 words in original):
- Splits the reply into three clear sections: Why it happens (5 causes including post-update indexing, unadapted apps, reset settings like Always-On Display, firmware bugs, and battery wear), What to check yourself (9 numbered steps including waiting 2–3 days, Android Safe Mode, checking the 80% battery capacity threshold, and a factory reset only as a last resort), and When to visit a repair shop (4 warning signs including shutting down at 20–30% or chassis swelling).
- Closes by offering exact menu steps if the user names their phone model and OS version.
Final Takeaway: Better Control, or Just More Homework for Humans?
Putting OpenAI's guide together with my live tests on GPT-6.2 Astra (and comparing against GPT 6 Astra and Claude Fable 5.2) leaves a mixed impression. On one hand, the official templates genuinely help: in the smartphone test they added concrete diagnostic checks and 29% more actionable detail; in the client email they cleaned up raw engineering jargon right away; and for coding and UI they set clear guardrails against boilerplate tests and visual clutter. On the other hand, OpenAI's templates alone still fall short on brief day-to-day writing - out of the box both GPT 6 Astra (36 words) and GPT-6.2 Astra (39 words) gave blunt notices, and OpenAI's prompt only nudged it to 44 words. To match the thoughtfulness Claude Fable 5.2 delivered with zero prompting (162 words covering client schedules and a messenger variant), I still had to tack on my own rules for tone, business risk, and follow-up steps.
On paper, this gives engineers and power users tighter control over how the model reasons, writes, and decides when to pause. Still, it raises an obvious question: does all this explicit prompt engineering simply shift the cognitive load back onto the human - leaving me to think through and spell out half the task upfront instead of letting the model figure it out on its own?
You can try GPT 6.2 Astra and GPT 6.2 Sol on GPTunneL with a single pay-as-you-go balance and no subscription lock-in.
Sources
- OpenAI Developers: Using GPT-6.2 - official prompting guide, verbatim prompt templates, and API migration instructions.
- The Decoder: OpenAI shares new prompting tips for GPT-6.2 Astra and Sol - overview of OpenAI's guidance on brief answers and follow-up questions (November 21, 2026).
