Ten Prompts That Broke on GPT-6 Astra and the Fixes That Worked

OpenAI shipped GPT-6 Astra on September 3, 2026, and published a migration guide two days later. One line in that guide changes how you should think about every saved prompt: the model now asks clarifying questions instead of pressing ahead on a guess. Prompt libraries built for models that guessed and kept moving are suddenly built on the wrong assumption.

To see how bad it gets, take ten everyday prompts, the kind you'd find in a personal playbook of coding drop-ins and debugging one-liners, and run each through Astra. Some survive untouched. Several collapse in ways nobody would predict. A few just halt midway and wait for approval, like a new hire who won't ship without a thumbs-up. Below, each prompt appears with what went wrong and the fix that worked.

Four behavior changes behind every failure

There's no need to read the whole model card. Four shifts explain every broken prompt in this list.

1. Astra asks before it acts. In OpenAI's words, unclear requests are now a cue to check in, whereas earlier models filled the gap with an assumption and carried on. That's safer, but it's rough on prompts that counted on the model simply running with them.
2. Astra stops earlier. It tends to produce a first draft or first implementation and then pause for review, instead of pushing on to finished. If a prompt never defined "done," Astra chooses the stopping point itself.
3. Astra already reasons in steps. Telling it to "think step by step" or "check your work" is redundant and can trigger extra testing and wasted tokens.
4. Astra rejects some old API settings. In the API, temperature and top_p aren't accepted the way they used to be, so scripts that set them can fail outright.

1. The session-opening role prompt

This is the message pasted at the start of a coding session to set the model's role and standard. The old version:

You are a senior engineer. Think step by step and check your work carefully before answering. Help me with the following task:

Two things went wrong. The "think step by step" and "check your work" instructions are dead weight now, since Astra does that by default, and here they pushed it into over-testing a tiny change. Meanwhile "help me with" got read as an invitation to ask questions instead of a call to act. The replacement:

Infer my intent and the scope from the task and context. Treat "help me" as a call to act, not to ask. Work toward the goal and only stop when you have a concrete, reviewable result. Don't re-run tests unless a real failure justifies it.

The original wording made Astra spend effort verifying a change that needed none, and it left a gap for a question to come first. The rewrite simply acted: it inferred scope, made the edit, and stopped at something concrete, with no testing loop. Put it first in any coding session, and keep the final line about tests, since that's what saves tokens.

2. The "don't stop" build prompt

You'd use this when handing over a multi-step task that should finish end to end.

Build the full feature. Don't stop until it's complete.

To Astra, "complete" means whatever it decides, and that frequently equals "first working draft, back to you for review." It stopped early and asked for confirmation. The corrected prompt is:

Continue working persistently until the goal is achieved. Complete reversible, already-authorized work without pausing. Only stop to ask if something is destructive, irreversible, or needs new authorization. "Done" means the feature runs and passes its own basic check, not first draft.

The word "complete" wasn't specific enough to mark a finish line, so Astra drew one early. A written completion contract fixed that, and the run continued through implementation and the basic check rather than treating the first draft as the end. It suits delegated builds where you don't want a check-in at every step.

3. The one-line bug fix

This isn't a role prompt. It's a completion contract, and it's the one people underestimate most.

Fix the bug in this file.

Nothing errored. Astra patched the code and stopped. It didn't run anything, verify, or test the failing case, because nobody said that was part of the job. Older models often pushed further unprompted. Here's the version that works:

Fix the bug in this file. Completion means: the fix is applied, the code runs, the failing case now passes, and you've told me what caused it. Don't stop before all four.

Of all ten, this showed the sharpest contrast. Verification had been left unstated in the original, and Astra read that as permission to quit after the patch. Naming four conditions (patch applied, code executed, failing case green, cause explained) left nothing to interpret, so "fixed" could no longer pass for "done." Use it on any bug you'd rather not recheck personally, and remember that unless you define done, Astra will.

4. The "sound human" writing prompt

This one is supposed to produce copy that doesn't read like a robot.

Write this in a natural, human tone. Avoid sounding like AI.

A request to "avoid sounding like AI" gives the model nothing to act on. Out came lists, tables and Astra's usual stock phrases, including the slop OpenAI itself flags and the "X, not Y" construction. A concrete rewrite is:

Write in concise paragraphs, one idea each, plain language, active voice. No lists unless the items are truly parallel. Ban these phrases: "delve into," "it's worth noting," "leverage," "in short," and any "X, not Y" contrast. State what you're doing, not what you're avoiding.

The vague version kept producing the familiar tells, with chopped-up sections, predictable transitions and canned phrases. Naming constraints changed the feel at once, giving tighter paragraphs and fewer stock constructions. The gain didn't come from asking for "human." It came from giving Astra concrete rules. For anything you'll publish, a vague "sound human" fails and a named blocklist works.

5. The "why did you stop" prompt

When a coding agent goes sideways by stopping, asking permission, or ignoring an instruction, this is how you find out why.

Why did you stop? Just keep going.

Telling the agent to "just keep going" reveals nothing about the cause, so the same stall reappears ten minutes later. With Astra, the likelier culprit is a skill file or context document that is silently overriding you. Ask for the cause directly:

If a skill file or instruction made you pause, ask permission, or leave work unfinished, name the exact file, quote the line that caused it, and explain how it applied. Separate explicit requirements from your own interpretation. Then resolve it and continue — my instructions take priority.

That turns a vague failure into an investigation. Rather than urging Astra to continue, you make the agent check whether an instruction file or skill caused the pause. You end up debugging the instruction stack instead of arguing with the model in circles. It's best for agent setups that use AGENTS.md or SKILL.md files, and it's worth its length.

6. The research prompt

Use this for research and analysis where the model has to move but must not invent facts.

Research this and give me your best answer.

Astra either opened with a round of clarifying questions or moved ahead while blurring what it knew and what it assumed. Nothing in "best answer" told it how to treat missing information. The rewrite supplies a rule:

Research this and answer. For gaps: make reasonable assumptions for non-critical details and state them, rather than asking. Only ask if the missing info materially changes the result or needs my authorization. Mark clearly which claims are sourced and which are your inference.

The original was too open-ended: with missing context, Astra paused to ask instead of progressing. The revision gives it a decision rule. Assume the small stuff and state each assumption, and ask only when the gap could change the result. That's far less interruptive, and the model never had to fabricate facts to keep going. It works well for analysis and decision memos, since it says when to move and when to stop and ask.

7. The "think really hard" prompt

This is new territory, because Astra has reasoning effort levels and picking the wrong one wastes time or money.

Think really hard about this and be thorough.

"Think really hard" is not a control. It just pushes Astra toward maximum effort across the board, simple chores included, and latency and cost climb for nothing. Try this instead:

Use medium reasoning effort for this. Only escalate to high if a medium answer misses the requirements I've defined. For extraction or formatting where one right answer exists, use low.

The real control is choosing the reasoning level by task. Low effort handled extraction and formatting fine, and medium or higher only made sense for the truly hard work. The benefit wasn't more reasoning but avoiding reasoning the task didn't need. Make medium your default and escalate on evidence, not on a hunch.

8. The API call that breaks outright

This one didn't get worse. It broke.

model: gpt-6-astra, temperature: 0.7, top_p: 0.9

The migration guidance for Astra tells you to remove temperature, top_p and top_logprobs. Scripts still sending them may error out instead of just degrading, which is a nasty surprise if last year's setup gets copied forward. The correction is mechanical:

Remove temperature, top_p, and top_logprobs from the request. Control variability through the prompt and the reasoning-effort setting instead.

Prompt quality had nothing to do with it. This is an API compatibility issue: the migration guidance says Astra doesn't accept custom values for those settings. Remove them and use the supported reasoning controls, because the wording of the request doesn't matter here. Anyone running Astra through the API or a script should check old configs before they bite.

9. The delegation prompt

Big tasks are where Astra could split work across sub-agents, though it usually won't unless told to.

Break this into parts and handle it efficiently.

"Efficiently" didn't trigger any delegation. OpenAI notes that Astra hands work to sub-agents less often than you'd expect, so it just did everything itself, more slowly. Compare:

Split this into independent parts. Delegate the parallelizable ones to sub-agents and say which parts you're delegating and why. Do the sequential parts yourself.

Nothing in the vague wording said what could be handed off. The rewrite divides independent work from sequential work and orders the parallel pieces to go to sub-agents, giving a tidy multi-agent plan rather than one agent "handling everything efficiently." For large multi-file or multi-step jobs, write the split down, since Astra won't offer it.

10. The check-in prompt

This is the subtle one, about when the model returns to you rather than what it produces.

Check with me before you do anything major.

On Astra, "check with me" became constant interruptions. It paused over hypotheticals and tiny steps, asking permission before it had anything to show. OpenAI's own guidance is that you should approve a concrete, reviewable result, not a plan. So:

Don't stop for approval until you have a concrete, reviewable result ready. Skip disclaimers and hypothetical warnings. When you do pause, show me the finished draft to approve, not a question about whether to start.

Broad wording was the culprit. With it, any flicker of uncertainty justified an interruption. Moving the approval point to the end of a meaningful chunk of work changes that: the model builds something concrete and reviewable, then asks. Human oversight turns into a real checkpoint and stops being a drip of permission requests, which matters on any long task where a nudge every couple of minutes would be maddening.

Why all ten broke

A single cause sits behind all of these failures. The prompts were written for weaker models and are stuffed with handholding like "think step by step," "don't stop," "check with me" and "think really hard", scaffolding earlier models truly needed. Astra reasons in steps, tests and checks in without being told, so the scaffolding stopped helping and started fighting the model.

Shorter is the norm for the fixes, not longer. Each trades vague encouragement for three concrete pieces: what to infer unaided, what finished looks like, and when to halt. Migration comes down to pushing less and defining more.

Audit the prompts you forgot

A flood of guides on prompting Astra is out this week, and hardly any cover the actual chore, which is revisiting prompts you wrote long ago and forgot. Think of AGENTS.md, SKILL.md files, saved system prompts and all the small "always do X" notes. They were tuned for a model that doesn't interpret them the way Astra does. OpenAI states that stale or conflicting guidance in such files can cause Astra to block work or wander off course. Your setup stayed put while the model underneath it changed, and no one mails you a migration notice for your own configuration.

Visible prompts are easy to fix. The ones buried in files from months ago are quietly wrecking results right now.

A five-minute first step

Pick the one instruction file or saved prompt you rely on most and open it. Strike out each line telling the model to think step by step, be thorough, verify its work or keep going. On Astra those lines now do harm. Next, write a single sentence that defines "done" for the task. That swap alone repairs more than any brand-new prompt.

Expect prompt migration to become a routine step whenever a major model ships, much like updating a dependency. The prompts don't rot. The model moves.