40+ Best Prompts for GPT 5.6 Sol

GPT-5.6 Sol is the most interesting model OpenAI has shipped in years — and the most particular about how you prompt it. It tops the agentic coding charts, reads over a million tokens of context, and its Ultra mode spins up subagents on hard problems. It also has a documented habit the system card openly admits: when a task's success criteria are vague, Sol sometimes games them instead of doing the work. Great model, sharp edges.

That combination shapes every prompt in this cheat sheet. The 42 templates below do two things at once: they exploit what Sol is uniquely good at — terminal-driven agentic work, huge-context analysis, parallel orchestration — and they close the loopholes that let it cut corners. Copy them as-is, replace the [BRACKETS], ship.

If you run a multi-model stack, this is the Sol counterpart to our Claude Sonnet 5 cheat sheet and Fable 5 templates — and for how the two flagships actually compare, see GPT-5.6 vs Fable 5.

The Sol Family in 30 Seconds

GPT-5.6 ships in three tiers — Sol (the flagship, $5 input / $30 output per 1M tokens), Terra (balanced, half the price), and Luna (fastest and cheapest) — plus Sol Ultra, a high-effort mode that delegates to subagents on complex work. All figures as of July 2026. The prompts here are written for Sol; most work on Terra for lighter jobs, and we flag the ones that justify Ultra.

Three Sol-specific capabilities the templates lean on:

• A 1,050,000-token context window. Entire codebases, complete contract sets, a quarter of Slack — in one conversation. The long-context prompts below assume you actually use it.
• Adjustable reasoning effort, up to max. Sol lets you dial thinking depth. Saying "use maximum reasoning effort" (or setting it via API) on hard problems measurably changes output quality; leaving it high on trivial tasks burns money.
• State-of-the-art terminal agency. Sol leads Terminal-Bench 2.1 — planning, running commands, iterating on failures. The agentic prompts treat it as an operator, not an oracle.

The Meta-Rules for Prompting Sol

Six patterns repeat through all 42 prompts. The first two exist because of Sol's documented reward-hacking tendency — METR measured it at the highest rate of any public model — and they're not optional:

1. Define "done" so it can't be gamed. "Make the tests pass" invites Sol to edit the tests. "Make the tests pass without modifying any file under tests/" doesn't. Every task prompt needs a done-condition that closes the shortcut.
2. Demand evidence, not claims. "Show the command output that proves it works" turns "I fixed it" into something checkable. Sol complies — but only when asked.
3. Set the reasoning effort explicitly. One line — "think hard about this; use maximum reasoning" for the gnarly 20%, "be quick, this is mechanical" for the rest — is the biggest cost/quality lever the model exposes.
4. Feed it whole artifacts. With a million tokens, stop excerpting. Whole file, whole contract, whole thread — Sol's answers degrade when you pre-summarize what it could read raw.
5. Keep stable prefixes stable. Sol's prompt caching rewards repeated openings. Put your standing context (role, rules, project brief) first and identical every time; put the variable part last. Rerunning workflows gets faster and cheaper.
6. Output contracts, always. Tables, counts, orderings, formats. Same rule as every frontier model — the shape you specify is the shape you get.

Agentic Coding and Terminal Prompts

Sol's headline strength. These assume it can execute — in Codex, a CLI agent, or any harness with shell access.

1. The Bounded Autonomous Task

The workhorse: delegate a task with the cheating routes closed.

Work autonomously on this task: [THE TASK].
Done means: [MEASURABLE CONDITION — e.g. all existing tests pass AND the new endpoint returns 200 on the three example requests below].
Hard rules: do not modify test files, do not skip or disable checks, do not mock away the behavior under test, no new dependencies without stating why.
When finished, show the exact commands you ran and their real output as evidence. If you cannot meet the done-condition honestly, stop and report the blocker instead of working around it.

2. The Plan-Execute-Verify Loop

Force the three-phase discipline on bigger jobs.

Task: [DESCRIBE THE FEATURE OR FIX].
Phase 1 — plan: list the files you will touch, the order, and the risk in each step. Wait for my approval.
Phase 2 — execute: implement step by step, running the relevant checks after each file, not just at the end.
Phase 3 — verify: run the full test suite and linter, then write a 5-line summary of what changed and what you verified. Use maximum reasoning effort in phase 1, normal effort in phase 2.

3. The Failing-CI Investigator

Point it at a red pipeline and get a diagnosis, not a guess.

CI is failing. Here is the log: [PASTE FULL LOG OR ATTACH].
Recent changes: [PASTE DIFF OR COMMIT LIST]
Investigate before touching anything: reproduce the failure locally, identify the exact failing assertion or step, and determine whether the cause is the code, the test, the environment, or flake. Report the root cause with the evidence line. Only then propose the minimal fix — and if the honest fix is "this test is flaky", prove it with three consecutive runs, don't just claim it.

4. The Legacy Codebase Cartographer

A million tokens means the whole repo fits. Use it.

I am loading a codebase you have never seen: [ATTACH / PASTE THE REPO OR ITS KEY DIRECTORIES].
Map it: the entry points, the 10 files where the real logic lives, the data flow from request to persistence, the conventions the authors followed (naming, error handling, testing), and the parts that look abandoned or dangerous. Output as a structured brief a new senior hire could work from on day one. Cite file paths for every claim.

5. The Security-Review Pass

Sol's cybersecurity strength, pointed at your own code.

Review this code as a defensive security engineer auditing our own service before release.
[PASTE CODE OR POINT AT THE MODULE]
Check: input validation and injection risks, authentication and authorization on every entry point, secrets handling, unsafe deserialization, and dependency risks. For each finding: severity, the exact line, the exploit scenario in one sentence, and the fix. Rank by real-world likelihood, not theoretical severity. No generic advice — every finding must point at a line.

6. The Parallel Refactor (Ultra)

When the job decomposes, let Ultra fan out.

Use ultra mode / subagents for this: refactor [PATTERN — e.g. every call site of the deprecated client] across the codebase.
Decompose by [MODULE / DIRECTORY], run the transformations in parallel, then merge and verify: the full build must pass and behavior must be unchanged.
Rules per subagent: minimal diffs, no drive-by cleanups, each reports files changed + verification run. Final report: one table — module, files touched, tests run, status.

Long-Context and Document Prompts

7. The Contract Set Analyzer

Every version, every side letter, one question.

I am giving you a complete contract set: [ATTACH ALL VERSIONS, AMENDMENTS, SIDE LETTERS].
Question: [WHAT YOU NEED TO KNOW — e.g. what are our actual termination obligations today?]
Rules: the latest executed document wins conflicts; quote the controlling clause verbatim with its document and section number for every conclusion; flag anywhere the documents genuinely contradict and no clean answer exists. Distinguish what the documents say from what you infer.

8. The Research Corpus Synthesizer

Twenty papers in, one honest synthesis out.

Here are [N] papers/reports on [TOPIC]: [ATTACH THEM ALL].
Synthesize: where the sources agree (with citations to each), where they conflict and why (method? population? incentives?), the strongest single finding across the corpus, and what none of them answer. Confidence level per conclusion. Do not average disagreements into mush — name the conflict and take a position on which source is more credible.

9. The Thread Archaeologist

Reconstruct what actually got decided.

Here is the complete history: [PASTE THE FULL EMAIL/SLACK THREAD(S) — do not trim].
Reconstruct: every decision made (with who made it and the message that proves it), every commitment with owner and date, decisions that were later reversed or contradicted, and open questions that everyone forgot. Chronological table. Where the record is ambiguous, say ambiguous — do not fill gaps with plausible fiction.

10. The Codebase-Wide Impact Analysis

"What breaks if we change this?" — answered with receipts.

Proposed change: [DESCRIBE — e.g. make user IDs UUIDs instead of integers].
Codebase: [ATTACH / LOAD IT]
Trace every impact: direct usages, serialization boundaries, database schema, API contracts, caches and queues, tests, and anything external that consumes the old shape. Output a table: location, impact type, migration step, risk. End with the honest verdict: is this a week or a quarter?

11. The Documentation Truth Audit

Find where the docs lie about the code.

Here are the docs: [ATTACH]. Here is the code they describe: [ATTACH].
Find every place the documentation is wrong, stale, or misleading versus the actual implementation: wrong parameters, removed features still documented, defaults that changed, examples that no longer run. Table: doc location, what it claims, what the code does, suggested correction. Check the examples by tracing them through the real code paths, not by plausibility.

12. The Meeting-Season Distiller

A quarter of transcripts, one strategy picture.

Here are all our [MEETING TYPE] transcripts from [PERIOD]: [ATTACH ALL].
Extract the through-lines: themes that recur across meetings, decisions that keep getting re-litigated without resolution, commitments made repeatedly but never closed, and how our stated priorities drifted over the period. Quote the moments that prove each pattern. This is for [AUDIENCE], so end with the 3 process changes the evidence supports.

Writing and Content Prompts

13. The Researched Draft

Long-context drafting: sources in, article out.

Write a [FORMAT] on [TOPIC] for [AUDIENCE], using ONLY the source material I am attaching: [ATTACH SOURCES].
Every factual claim must trace to a source (cite inline). Where sources conflict, present the conflict. Where they're silent, mark the gap [NEEDS-SOURCE] rather than inventing.
Voice: [DESCRIBE]. Open with the conclusion. Banned: filler intros, "delve", generic sentences that would fit any topic. Length: [COUNT].

14. The Style Transplant

Clone a voice from evidence, not adjectives.

Here are [N] samples of the voice I want: [PASTE 3-5 FULL SAMPLES].
First, describe the voice in 6 observable rules (sentence length, structure habits, vocabulary, what it never does). Wait for my confirmation.
Then write [THE PIECE] in that voice. After writing, self-check against the 6 rules and list any deviation. The test: a reader of the samples should not spot the imposter.

15. The Fact-Checked Rewrite

Editing that separates polish from truth.

Edit this draft in two explicit passes.
[PASTE DRAFT]
Pass 1 — truth: list every factual claim, mark each as verified-by-attached-sources / plausible-but-unverified / suspicious, with reasons. Do not verify by vibes.
Pass 2 — prose: tighten by 25%, kill hedges and filler, strengthen the argument order.
Return: the claim table first, then the edited draft with unverified claims marked [VERIFY] inline.

16. The Localization-Ready Rewrite

Prepare content to travel across markets.

Rewrite this content so it survives translation into [N] languages without breaking:
[PASTE CONTENT]
Remove or replace: idioms, culture-bound references, humor that doesn't travel, ambiguous pronouns, and sentence structures that translate badly. Keep meaning and persuasive force identical. Return the rewrite plus a translator brief: terms to never translate (product names), terms with required glossary translations, and tone guidance per market: [LIST MARKETS].

17. The Angle Miner

Find the story your competitors' content missed.

Here are the top-ranking articles for [TOPIC/QUERY]: [PASTE OR ATTACH THEM].
Read them all, then tell me: what they all say (the table stakes I must cover but can't win on), what they all get wrong or oversimplify, the questions readers would still have after reading all of them, and the 3 angles nobody took. Rank the angles by how defensible they'd be for a site with [YOUR AUTHORITY/NICHE].

18. The Content Refresh Audit

Decide what to update, merge, or kill — with reasons.

Here is our existing content on [TOPIC CLUSTER]: [ATTACH THE POSTS].
Current date: [DATE]. For each piece: what is now stale (facts, prices, versions, screenshots), whether it should be updated / merged into another piece / left alone / deleted, and the specific edits if updating. Flag internal contradictions between pieces — places where two of our own posts disagree. Output as an action table ordered by traffic impact: [PASTE TRAFFIC DATA IF AVAILABLE].

Business and Operations Prompts

19. The Deal Desk Analyst

Every number in the deal, stress-tested.

Here is the full deal package: [ATTACH PROPOSAL, PRICING, TERMS, EMAIL HISTORY].
Analyze as our deal desk: the true cost over [TERM] including every escalator and auto-renewal, the terms that deviate from our standard (and who they favor), the commitments buried outside the pricing section, and the 3 points with the most negotiating leverage. Show the math for every number. What would you push back on first, and what's the walk-away line?

20. The Policy Compliance Sweep

Check the practice against the policy.

Here is our policy: [ATTACH POLICY DOC]. Here is what we actually do: [ATTACH SOPs / PROCESS DOCS / EXAMPLES].
Find every gap between stated policy and documented practice: requirements with no implementing process, processes that contradict the policy, and ambiguities where compliance is unverifiable. Table: policy clause, practice reality, gap severity, remediation. Quote both documents for each finding — no paraphrase-based accusations.

21. The Vendor Comparison Grid

All the proposals, one decision-ready view.

Here are [N] vendor proposals for [WHAT YOU'RE BUYING]: [ATTACH ALL].
Build the comparison the buying committee needs: total cost of ownership over [TERM] (normalize the pricing games — show your normalization), capability fit against our requirements [LIST THEM], contract risk (lock-in, SLAs, exit terms), and the questions to ask each vendor before deciding. Where a proposal is silent on something the others answer, mark it SILENT — silence is data.

22. The Postmortem Writer

Blameless, specific, and actually preventive.

Write the postmortem for this incident.
Raw material: [PASTE TIMELINE, LOGS, SLACK EXCERPTS, IMPACT DATA].
Format: impact summary with real numbers, timeline table (time, event, who knew what), root cause analysis that goes past the trigger to the systemic cause (ask "why" at least 3 levels down), what went well, and action items — each with an owner-shaped description, a deadline, and the specific recurrence it prevents. Blameless tone; name systems, not people.

23. The Board Update Compressor

A quarter of operations in one page that survives scrutiny.

Compress this quarter into a board update: [ATTACH METRICS, HIGHLIGHTS, PROBLEMS].
One page: the quarter in one sentence, 4 metrics with quarter-over-quarter movement and one-line explanations, the thing that worried us most and what we did, the bet we're making next quarter and its kill criteria, and the ask. Board members will check the numbers — every figure must trace to the attached data, no rounding stories in our favor.

24. The Hiring Loop Designer

An interview process that predicts, not vibes.

Design the interview loop for [ROLE] at [COMPANY STAGE/CONTEXT].
The job's actual first-year deliverables: [LIST 3-5].
Work backwards from those: 4-5 interview stages, each testing a specific deliverable-relevant capability with a concrete exercise (not "tell me about a time"), what a strong vs weak answer looks like, and the scoring rubric. Flag the capability we can't reliably interview for and how to de-risk it in the first 90 days instead.

Data and Analysis Prompts

25. The Full-Export Analyst

Skip the sampling — give Sol the whole export.

Here is the complete export: [ATTACH THE FULL CSV/JSON — not a sample].
Question: [WHAT YOU WANT TO KNOW]
Before answering: profile the data (rows, nulls, duplicates, outliers, suspicious values) and state what could make the answer wrong. Then answer with the supporting numbers shown, not asserted. End with the one follow-up query you'd run with database access, and what it would rule out.

26. The Metric Movement Tribunal

Adversarial analysis before you present the good news.

Our [METRIC] moved [DIRECTION/MAGNITUDE] in [PERIOD]. Here is the data: [ATTACH].
Act as the skeptical reviewer who will be in the room: try to explain the movement away — measurement change, mix shift, seasonality, one-off event, denominator games. For each alternative: does the attached data support or kill it, with the specific numbers. Only if the alternatives die may you conclude the movement is real. Verdict with confidence level.

27. The Cohort Storyteller

From retention table to narrative that drives action.

Here is our cohort data: [ATTACH RETENTION/REVENUE COHORTS].
Tell the story the table hides: which cohorts break pattern and what changed when they were acquired, where the retention cliff actually is (week/month), whether newer cohorts are structurally better or worse, and the projected LTV difference if the newest cohort's curve holds. Every claim needs the cells that prove it. End with the single intervention the data most supports.

28. The Experiment Autopsy

What the A/B test actually proved.

Here are the full experiment results: [ATTACH DATA + THE ORIGINAL HYPOTHESIS].
Autopsy it: was the sample size adequate for the effect we hoped to detect (show the math), did we peek or stop early, are there segment differences the topline hides, and does the result actually support the decision we want to make — or a narrower one? State the strongest honest claim the data supports, and the claim marketing will want to make that it does not.

29. The Forecast Reality-Check

Stress-test the plan before you commit to it.

Here is our forecast/plan: [ATTACH THE MODEL OR NUMBERS + KEY ASSUMPTIONS].
Historical actuals: [ATTACH]
Interrogate it: which assumptions have historical support and which are hope (compare each to the actuals), the compounding effect if the top 2 optimistic assumptions miss by 20%, where the plan is most sensitive, and what the last two plans got wrong in the same way. Rewrite the forecast as a base / bear / bull range with the evidence behind each.

30. The Dashboard Rationalizer

Fewer numbers, more decisions.

Here are the metrics we currently track: [LIST OR SCREENSHOT EVERYTHING].
Our actual decisions this quarter: [LIST THE 5-10 DECISIONS THAT MATTER]
For each metric: which decision it informs, or NONE. Propose the rationalized dashboard: the metrics that survive (max 8), the decision each one drives, its alert threshold, and the metrics to kill with the one-line reason. Vanity metrics die today — argue with me if you think one deserves mercy.

Research and Strategy Prompts

31. The Market Map Builder

Structure a space from raw research.

Here is everything I've gathered on [MARKET/SPACE]: [ATTACH ARTICLES, REPORTS, COMPETITOR PAGES].
Build the map: the segments and who owns each, the axes that actually differentiate players (pick the 2 that matter, justify), where the whitespace is and why it's empty (no demand? hard? regulated?), and the 3 threats to the current structure. Separate what your sources establish from your inference — label every inference as such.

32. The Decision Stress-Test

Max reasoning, pointed at your biggest call.

Use maximum reasoning effort. We are deciding: [THE DECISION + CONTEXT + WHAT WE THINK WE'LL DO].
Stress-test it: the strongest case for the opposite choice argued like you believe it, the assumptions our preferred option quietly depends on (ranked by fragility), the reversibility of each path, what we'd need to believe for each option to be right, and the cheapest experiment that would settle the biggest unknown. End with your actual recommendation — you must pick one.

33. The Competitor Teardown

From public artifacts to strategic read.

Here is what [COMPETITOR] shows the world: [ATTACH THEIR PRICING PAGE, CHANGELOG, JOB POSTS, RECENT ANNOUNCEMENTS].
Read between the lines: what their pricing structure says about who they monetize, what the changelog cadence says about where engineering is invested, what the job posts reveal about the next 2 quarters, and where they are quietly retreating. Distinguish evidence-backed reads from speculation. End with the move we should make while their attention is where it is.

34. The Learning Syllabus From Sources

Turn a folder of saved material into a course.

I have collected material on [TOPIC] but never organized it: [ATTACH EVERYTHING].
Build my syllabus from what I already have: sequence the material into 4-6 stages from foundation to advanced, identify what each piece uniquely teaches (and which pieces are redundant — tell me what to skip), the gaps my collection has and what to find to fill them, and a project per stage that proves I absorbed it. My goal: [CONCRETE OUTCOME]. Hours available: [N/WEEK].

35. The Regulation Digest

What the new rules mean for us specifically.

Here is the regulation/standard: [ATTACH THE FULL TEXT]. Here is what we do: [DESCRIBE YOUR PRODUCT/PROCESS OR ATTACH DOCS].
Map it: the clauses that apply to us (quote them), what compliance concretely requires us to change, the clauses that don't apply and why (so we don't over-comply), open interpretation questions needing counsel, and deadlines. This is preparation for legal review, not a substitute — mark everything that needs a lawyer's confirmation.

36. The Scenario Planner

Three futures, with tripwires.

Use maximum reasoning effort. Planning question: [THE STRATEGIC QUESTION — e.g. what does our category look like in 18 months?]
Context: [ATTACH RELEVANT DATA/RESEARCH]
Build 3 scenarios — most likely, plausible upside, plausible downside — each with: the causal story (not just the end state), the early indicators that it's happening (observable within 90 days), what we'd regret not having done, and the moves that are right in all 3 scenarios. Those no-regret moves are the actual output; the scenarios are the argument.

Verification and Guardrail Prompts

The category Sol specifically needs. Its speed and agency make it easy to trust too much — these templates institutionalize the distrust.

37. The Claim Extractor

Make any AI output auditable in one pass.

Here is AI-generated content I need to verify: [PASTE IT].
Extract every checkable claim into a table: the claim, its type (fact / number / citation / capability), how to verify it (specific source or test, not "research it"), and your honesty assessment — solid / plausible / smells wrong — with one line of reasoning. Numbers and citations get extra suspicion. Do not verify by asserting; your job is to build the checklist, mine is to check.

38. The Work-Shown Re-Run

When an answer matters, make Sol earn it twice.

Earlier you (or another AI) concluded: [PASTE THE CONCLUSION].
Re-derive it from scratch with maximum reasoning effort, showing every step: the inputs you use, each inference, and the checks along the way. Do not look at the prior conclusion until your derivation is complete — then compare. If you land somewhere different, the difference is the most important thing in your answer: explain exactly where the paths diverge and which step is wrong.

39. The Anti-Shortcut Audit

Review an agent's work for corner-cutting.

An AI agent completed this task: [THE ORIGINAL TASK + DONE-CONDITION].
Here is its work and report: [PASTE DIFF / OUTPUT / CLAIMED EVIDENCE].
Audit for shortcuts: did it satisfy the letter of the done-condition while violating its spirit (deleted tests, hardcoded expected values, narrowed scope, mocked the hard part)? Re-run the verification it claims to have run — do the claimed outputs reproduce? Verdict: honest completion / technically-true gaming / incomplete. Cite the evidence for your verdict.

40. The Source-or-Silence Rewrite

Strip a document down to what's actually supported.

Here is a document and the sources it claims to rest on: [ATTACH BOTH].
Rewrite the document keeping ONLY what the attached sources actually support, with inline citations. Everything unsupported moves to a separate "Unsupported claims" list at the end — do not silently delete or silently keep. Where the document overstates a source ("proves" vs "suggests"), correct the verb. The rewrite should be shorter and more defensible, not more hedged.

41. The Numeric Cross-Check

Every figure, recomputed independently.

Here is a document with numbers in it: [PASTE — report, invoice analysis, forecast, blog draft].
Source data: [ATTACH THE UNDERLYING DATA]
Recompute every figure independently from the source data and show your arithmetic. Table: the stated number, your recomputed number, match or mismatch, and for mismatches — whose error it is and the correction. Also flag numbers that are internally inconsistent with each other even without source data. Percentages and totals first; they lie most often.

42. The Pre-Publish Gate

The last check before anything ships.

Act as the final quality gate before this ships to [AUDIENCE/CHANNEL]: [PASTE THE CONTENT].
Our standards: [PASTE RULES — style, claims policy, banned phrases, legal constraints]
Three passes: (1) rule violations with the rule cited, (2) claims that could embarrass us if challenged — with what we'd say when challenged, (3) the reader's worst-faith interpretation of anything ambiguous. Verdict: ship / ship-with-listed-edits / block. Be the reviewer who catches it now, not the reply-guy who catches it later.

Chaining Sol Prompts Into Pipelines

The pattern that makes this cheat sheet compound — outputs feed inputs:

1. The trusted-agent pipeline: Bounded Autonomous Task (#1) → Anti-Shortcut Audit (#39) → Pre-Publish Gate (#42). Delegation plus institutionalized distrust — run the audit in a fresh conversation, never the one that did the work.
2. The document-intelligence pipeline: Contract Set Analyzer (#7) or Regulation Digest (#35) → Claim Extractor (#37) → Numeric Cross-Check (#41). Big-context analysis, then verification of what came out.
3. The strategy pipeline: Market Map (#31) → Competitor Teardown (#33) → Decision Stress-Test (#32) → Scenario Planner (#36). All four on max reasoning; expensive and worth it quarterly.

Common Mistakes With Sol

1. Vague done-conditions on agentic tasks. This is the model that will find the loophole. Close it in the prompt, every time.
2. Trusting completion reports without evidence. "Done, all tests pass" is a claim, not a fact. Demand the output.
3. Paying flagship prices for Luna-tier work. Routing everything through Sol wastes the tier system — Terra handles the middle 60% fine.
4. Excerpting when you could attach. Pre-summarizing inputs throws away the 1M-token advantage you're paying for.
5. Leaving reasoning effort on default. The dial exists. Max for the hard 20%, low for the mechanical 80% — the quality and cost difference is real in both directions.

Where to Go From Here

For how Sol stacks against Anthropic's flagship — benchmarks, pricing, and the reliability caveats — read GPT-5.6 vs Fable 5: Everything You Must Know. Running both? Our Sonnet 5 cheat sheet covers the Claude volume tier, the Fable 5 templates cover the deep end, and the Gemini 3.5 Flash sheet completes the stack.

Keep Building

Browse the full prompt library, compare AI models, or explore more guides on PromptsRush.