GPT-6 Astra Prompting: Lean Skills, Fewer Rules

OpenAI Told Developers to Write Less, Not More

In the second week of September 2026 OpenAI published two documents that point in the same, slightly counter-intuitive direction: the more capable the model, the less scaffolding it wants. On September 11 the company's model documentation spelled out where GPT-6 Astra tends toward unwanted behaviour and how to work around it. On September 12, OpenAI engineer Eric Provencher extended that guidance to the files most teams never think to update: skills, AGENTS.md, and the task prompts that have accumulated over a year of model switches.

His central claim is blunt. Instructions that have piled up over time can eat up context or cause GPT-6 Astra to stop work too early, and more capable models need less hand-holding. That inverts the instinct most teams have when a new frontier model lands. The default move is to add guardrails: more examples, more reading requirements, more explicit approvals. For Astra, OpenAI says the default move is wrong.

This article works through what to cut, what to add instead, and how to trace the specific file that is causing the model to stall. It is written for the people who own an API integration or an agent harness, because that is where the cost of over-prompting shows up first.

Two Documents, One Day Apart

It helps to separate the two publications, because they cover different layers of the stack.

The September 11 model-documentation guidance covers how the model itself behaves. OpenAI reports that GPT-6 Astra asks clarifying questions more often than GPT-5.6 Sol instead of making assumptions on its own, which the company frames as the model being a more effective collaborator. The trade-off is the one developers feel immediately: the model sometimes stops where the user expected it to keep going. OpenAI's fix is prompt-level, and the company publishes the text.

The September 12 skill and project-instruction guidance covers the environment around the model. Provencher's argument is that skill files and AGENTS.md are prompts too, and they carry the same risks as any other prompt. Skills whose names and descriptions are too broad get loaded when they should not fire. Detailed step-by-step sequences slow newer models down. Approval rules written to contain an earlier, less predictable model now read as hard stops.

The reason the two matter together is that a fix at one layer does not survive a problem at the other. You can write a perfect action-bias prompt and still watch the agent stop halfway through, because a note in AGENTS.md told it to check in after the first implementation.

What to Cut

OpenAI names three patterns specifically, and each maps to something you can grep for today.

1. Overly broad skill scopes

Skills are prompts stored as Markdown files, and their names and descriptions go into the model's context so the harness can pick the right one. When there are too many skills, the descriptions get truncated and the model loses the information it needs to choose correctly. Conflicting descriptions, or a scope broad enough to match unrelated tasks, load instructions the model does not need.

Provencher's corrective is precision about when a skill fires. His worked example: a skill for Postgres schema migrations should only trigger when creating or modifying a migration, or when checking its rollout. If a skill legitimately covers several workflows, its main document should briefly point to the right supplementary docs and scripts rather than inlining all of them, so the model reads only what the task needs.

2. Blanket read requirements

The canonical offender is a rule that forces a full project orientation before every change. Requiring the model to read multiple documents or a complete project overview before every commit is overkill for a typo fix, and Astra can figure out what it needs on its own.

The replacement is selective pointing. Instead of mandating architecture.md, database.md, and deployment.md on every task, the instructions name each document in the context where it applies: architecture info when working on service boundaries, database docs when changing schemas, deployment notes when shipping. Every avoided read is context the model does not spend, and context it does not get pushed toward summarising mid-task.

3. Approval rules that outlived their model

This is the pattern with the sharpest edge. Teams that watched an earlier model go rogue locked things down with strict approval rules, and those rules have been carried forward ever since. OpenAI's position is that switching to Astra is the moment to revisit them, because the model can interpret old restrictions so literally that it stops even when you want it to keep going.

The counterweight is explicit permission for known-safe operations. The published example is local tests using throwaway data with no production access: AGENTS.md can state outright that the agent may run those tests, fix errors caused by the requested change, and re-run the affected tests without asking again. The rule is narrow, written in the file the model actually reads, and scoped to operations where the downside is bounded.

What to Add Instead

Cutting scaffolding is only half the change. OpenAI's guidance pairs every removal with a replacement, and the replacements are short.

An action-bias instruction

To push Astra toward initiative, OpenAI recommends a prompt that tells the model to infer intent from context and show a bias towards action. The company publishes the wording, and the load-bearing sentences are the ones about scope and follow-through: the model should demonstrate a tendency to act and to follow the user's intended task through to completion, working independently unless an action is clearly destructive or irreversible.

The same guidance reclassifies a class of user phrasing. Phrases like can you, I want to, or help me should be treated as calls to act, not as invitations for follow-up questions. That single clarification removes a whole category of round-trips for anyone building on top of the API.

An explicit definition of done

Provencher notes that even without restrictions Astra may stop earlier than GPT-5.6 Sol, so the prompt needs to define upfront what done means. If the agent is supposed to implement something, run it, check the results, and fix errors, all four steps have to be stated. His specific warning is worth quoting in spirit: a requirement to check in after the first implementation sets an earlier stopping point, which turns a helpful-sounding rule into a premature exit.

A rule about when approval is requested

OpenAI's phrasing here is precise: the user should be approving a concrete, reviewable result. That reframes the confirmation loop from “ask before doing” to “prepare, then ask.” The companion instruction is to drop unsolicited warnings, disclaimers, and safety checklists that are based on hypothetical risks rather than the task at hand.

A debugging prompt for stalls

The most practical item in the set is a prompt that makes the model explain itself. When a skill causes it to ask for permission or confirmation, pause, leave requested work unfinished, or diverge from the user's intent, the model should name and link to the exact SKILL.md file it read, quote the relevant instruction, and briefly explain how it applies. The published version also asks the model to distinguish explicit skill requirements from its own interpretation of guidelines.

That distinction is what makes the tool useful. A stall caused by an explicit rule is a rule you should probably delete; a stall caused by the model's interpretation is a wording problem you should probably tighten.

An output-style instruction if you want prose

One smaller finding worth acting on: Astra tends to structure responses with lists, tables, and Markdown formatting, and it reuses the same phrases across sessions. If the deliverable is prose, OpenAI's guidance is to say so explicitly, asking for concise paragraphs in plain language and the active voice. Left unspecified, you get the formatting-rich default.

The Migration Checklist

Assembling the guidance into an order of operations, the sequence that fits an existing agent harness is:

1. Audit every skill file the model can reach. Shorten scope descriptions to the trigger conditions. Check for descriptions that conflict with each other.
2. Delete blanket read requirements. Replace each with a pointer that fires in the context where the document matters.
3. Re-read AGENTS.md for approval rules written before this model existed. Delete the ones that no longer describe a real risk, and keep the ones that do with tighter wording.
4. Add the action-bias instruction and the definition of done. Both are short, and they operate at the prompt layer rather than the environment layer.
5. Add the stalled-skill debugging prompt. It converts an opaque behaviour into a file path and a quoted line.
6. Set explicit permissions for known-safe operations so the agent stops re-asking about local tests on throwaway data.
7. Re-test the workflow end to end. The failure mode of over-prompting is silence, not an error, so the check is whether the task completes without a check-in, not whether the command exits zero.

Why This Matters for API Teams

For a pure API integration — a proxy, a RAG service, a classification pipeline — the skill-file guidance is less directly applicable, but the underlying economics still are. Astra lists at $10 per million input tokens and $50 per million output tokens, with cached input at $1.00 per million and cache writes at $12.50 per million. Context that stays stable across calls is cheap to read; context that churns is charged at the full input rate.

That asymmetry means instructions that exist because a previous model needed them are not free. They are re-sent, re-read, and in many setups re-billed. The five-minute audit OpenAI is recommending is, read literally, a context-reduction exercise with a measurable line item attached.

The second-order effect is subtler. In an agent harness, a premature stop costs a full round-trip plus the user's attention, and it can cost the whole task if nobody notices. A check-in rule that made sense for an unpredictable model becomes an expensive interruption for a more reliable one. That is the whole argument for treating prompt and skill files as versioned artifacts tied to a model version, not as configuration written once and inherited forever.

Sources

• THE DECODER, “GPT-6 Astra needs leaner prompts and fewer guardrails, OpenAI recommends” — Matthias Bastian, September 12, 2026 (covering OpenAI engineer Eric Provencher's guidance on skills, AGENTS.md, and task prompts)
• THE DECODER, “OpenAI shares prompting tips for GPT-6 Astra, including a blocklist of slop words” (covering OpenAI's model-documentation prompting guidance: clarification behaviour, action bias, approval timing, output style)
• OpenAI news feed, “Perplexity trusts GPT-6 Astra with end-to-end systems” — September 14, 2026 (third-party production case study: communications, software changes, production monitoring, reduced check-in frequency)
• OpenAI news feed, “Cognition helps Devin test its own work with GPT-6 Astra” — September 11, 2026 (companion case study on agentic testing)
• OpenAI GPT-6 Astra API pricing, as documented on this site (September 2026 verification): $10/$50 per million input/output, $1.00 cached input, $12.50 cache write