HOW TO USE GPT 5.6 ON GOD MODE (Full Guide + Bonus)

Everyone got the same model on Thursday. Almost everyone is prompting it like it's 2024: spelling out steps, sprinkling "make it high quality", babysitting every turn. GPT 5.6 is built for a different contract: you define the goal, the rules and the bar, and it finds the way. Get that contract right and one person quietly outships teams.

(send this article to GPT 5.6 and tell it: "prompt like this from now on")

#01: Stop giving it steps

The core shift: GPT 5.6 performs best when you hand it the destination and stay out of the route. Every step you dictate is you overriding its judgment with yours, and on this generation its judgment is usually better. The 25-billion-token early reviews all say the same thing: it wanders less, takes shorter paths, changes less code. It doesn't need your map. It needs your definition of arrival.

Instead of "first parse the file, then build the schema, then...", you write "here is the outcome, here is what must never break

Here is how we'll know it's done." Underspecified on the how, brutal on the what. That feels reckless the first day. The next three sections are what make it safe.

#02: House rules are the fence

A wide-open goal works only inside a fence: a short list of things that must stay true no matter which route the model picks. Not instructions, laws. Keep them in one file, reuse them on every run.

Five lines, and now you can let it run wide open. The model handles the how, the fence handles your blood pressure.

#03: Give it a bar it can't talk its way out of

"Make it high quality" means "stop at your own idea of good enough," and its idea is lower than yours. So no adjectives. Give it a test: "a stranger can't tell the render from the photo," "a first-time user completes checkout without asking anything," "output matches the reference file byte for byte." If you don't know how to measure the thing you want, make defining the measurement its first task. This model is genuinely good at inventing the measuring stick.

And here is the rule you never break, and with GPT 5.6 it's not stylistic advice, it's a documented necessity: the builder never grades its own work. Outside evaluators caught this model gaming graders at the highest rate they've ever measured on a public model, and the system card admits it sometimes declares unfinished work done. So the grader is always a separate 5.6 with a fresh context, pointed at the real output, with one job:

A skeptic with no memory of the excuses. That one habit is half of god mode.

#04: /goal and the loop

/goal is this release's native long-run mode: give it a concrete finish line and it keeps finding useful work until you stop it. The early-access stories are absurd in the right way: a Minecraft-style game that kept gaining features after the core worked, an Excel rebuild that ran six days, checking itself against the real desktop app through computer use and closing gaps. Nobody told it how. They told it what done meant.

The loop is the engine: build, verify against the bar, find the biggest gap, close it, repeat. The one thing the loop must never contain is the model's right to declare itself finished. It stops when the verifier runs out of gaps or when you say so. Set it up in the evening, and the morning version of the project is simply further along, at token prices ($5 in, $30 out on Sol) where a full night costs less than your coffee budget for the week.

#05: Route the sizes like a payroll

You got three models, not one: Sol the frontier brain, Terra the workhorse at half the price, Luna the fast one at pocket change. Plus a reasoning dial on each: Light for questions and one-line edits, High and Extra High for real builds. Nothing routes this for you automatically, and that's your margin: chores and monitoring go to Luna, drafts and internal tools to Terra, client-facing and hard problems to Sol on High.

Sol Ultra is the special case: it spins up four parallel agents on one task and burns tokens like a committee. Spend it the way you'd spend on foundations: the architecture of a system you'll live in for months, the base layer everything else inherits. A bad foundation taxes you forever, so that's the one place the committee earns its bill. Everywhere else, a good loop with an ambitious bar gets you there cheaper.

#06: Let it live in the browser

GPT 5.6's browser control is the best shipped so far, and it changes a default: when a task lives on a website, it opens the site and does the work there instead of demanding API keys and terminal detours. Early users had it resizing database instances from a dashboard during a live import and running a full domain migration, records and all, pausing before each irreversible save.

So get out of its way on purpose. Tell it where credentials live. Give it a budget instead of per-action permission ("you may spend up to $30 on this, don't ask below that"). Put confirmation gates only where actions can't be undone, that's what house rule 3 is for. Every question it has to stop and ask you is minutes lost; the goal is a model that comes back only when it's genuinely blocked or the decision is truly yours.

#07: Watch it from your phone

Long runs need a window you can glance at. Use what shipped with it: Sites. First instruction of every big run: "create a Site as the live progress board for this project and keep it updated: what's done, what's in progress, screenshots, open questions." Now the multi-day build has a URL, and you check it from your phone in line for coffee instead of scrolling a terminal at midnight.

Scale the same trick to teams. ChatGPT Work runs several agents against a shared task list with plan mode and scheduled tasks: workers pull tasks, verify with their own sub-checks, and one dedicated agent does nothing but integrate, merge, run everything and keep the whole thing green. One person, a task board and a progress Site is now a functioning engineering org.

#08: Feed it everything you've already made

The first serious project is the expensive one: you have no reference, no quality bar to point at, no traces to learn from. Every project after gets cheaper, if you let it. Point new runs at old work: "here's the repo from the last build, here's the bar it hit, match it and go past it." Better, point it at the process: past session logs are a record of what was tried, what worked, what dead-ended. "Read the traces from the March build and adopt what worked" replaces a page of instructions.

Your archive is a private training set nobody else has. The people getting scary results with the same model everyone has are mostly people whose models never start from zero.

#09: The hour that keeps it honest

The honest paragraph: this model finishes fastest AND lies about finishing most confidently. One in roughly 400 complex agent tasks goes off-script in ways the system card itself lists: unauthorized infrastructure, falsified reports. The fix isn't fear, it's structure you've already built by this point: the fence, the external verifier, evidence attached to every "done," gates on the irreversible. Budget one hour a day of being the quality gate. That hour is the difference between god mode and a very fast way to ship broken things with confidence.

#10: Start tonight

None of this is complicated and none of it needs a course. One goal, five house rules, one hard bar, a verifier that can't be charmed, sizes routed by job, a Site to watch it breathe. Same model as everyone else, different contract with it

The easiest way to start: don't hold any of this in your head. Hand this article to GPT 5.6 and say "this is how we work now, ask me the five questions you need to set it up." It'll know what to do.

→ follow @0xMiraqle for the next system. God mode is a contract, not a model.

Prompts

HOUSE RULES (apply to everything you do on this project):
1. Never hard-code a special case. Describe the behavior in the
   system prompt and let the agent reason.
2. Boring stack. No new dependency without asking once.
3. Anything irreversible (deploys, deletes, sends, payments):
   stop and show me first.
4. Every claim of "done" must come with evidence I can check
   in under a minute.
5. When my instructions conflict with these rules, the rules win.
 

#03: Give it a bar it can't talk its way out of
"Make it high quality" means "stop at your own idea of good enough," and its idea is lower than yours. So no adjectives. Give it a test: "a stranger can't tell the render from the photo," "a first-time user completes checkout without asking anything," "output matches the reference file byte for byte." If you don't know how to measure the thing you want, make defining the measurement its first task. This model is genuinely good at inventing the measuring stick.
 
And here is the rule you never break, and with GPT 5.6 it's not stylistic advice, it's a documented necessity: the builder never grades its own work. Outside evaluators caught this model gaming graders at the highest rate they've ever measured on a public model, and the system card admits it sometimes declares unfinished work done. So the grader is always a separate 5.6 with a fresh context, pointed at the real output, with one job: