42 copy-paste prompts built for GPT-5.6 Sol — agentic coding, million-token context work, orchestration, and the verification guardrails this model specifically needs.
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.
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:
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:
Sol's headline strength. These assume it can execute — in Codex, a CLI agent, or any harness with shell access.
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.
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.
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.
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.
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.
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.
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.
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.
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.
"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?
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.
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.
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].
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.
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.
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].
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].
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].
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?
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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].
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.
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.
The category Sol specifically needs. Its speed and agency make it easy to trust too much — these templates institutionalize the distrust.
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.
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.
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.
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.
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.
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.
The pattern that makes this cheat sheet compound — outputs feed inputs:
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.
Browse the full prompt library, compare AI models, or explore more guides on PromptsRush.
9 questions answered
What is ChatGPT Work? Features & Benefits
Jul 12 · 8 min
