Optimizing Prompts and Skills for GPT-6 Astra: Slimming AGENTS.md and Defining DoD

On September 12, 2026, the OpenAI Developers team (@OpenAIDevs) released a targeted guide on optimizing task prompts, repository guidelines (AGENTS.md), and skills specifically for the flagship GPT-6 Astra reasoning model. As frontier models achieve unprecedented levels of autonomous planning and tool-orchestration capability, legacy prompt patterns—such as bloated, static repository instruction sets and eagerly loaded skills—create friction and degrade execution quality. OpenAI outlined three concrete principles to modernize agent configurations.

Image source: OpenAI Developers

Why Bloated Repository Guidance Holds Back GPT-6 Astra

In developer workflows driven by large language models, repository-level markdown files like AGENTS.md and system prompts have served as the standard medium for communicating operational rules and project context. Over time, however, many engineering codebases have accumulated hundreds of lines of defensive instructions originally drafted to compensate for hallucinations, truncated answers, and context drift in earlier-generation models.

According to OpenAI Developers, carrying these historical instructions forward into the GPT-6 Astra era creates severe operational drag:

• Creating Overconstrained Reasoning Spaces: When global instructions are perpetually frontloaded with dozens of rigid style guidelines, edge-case caveats, and historical conventions, the model's active reasoning bandwidth becomes constrained. Rather than converging on the most elegant solution, the model spends reasoning effort navigating conflicting constraints, resulting in distorted logic or timid, suboptimal code changes.
• Context Window and Token Waste: Consuming thousands of tokens on static repository guidelines on every single turn reduces the effective window available for actual source files, AST representations, and compiler or test outputs.
• Rule Drift and Prioritization Latency: Stale instructions often conflict with modern libraries or revised testing pipelines, forcing the model into unnecessary deliberative cycles trying to resolve ambiguities between outdated guidelines and current repository code.

Transitioning to advanced reasoning models like GPT-6 Astra demands a deliberate audit of legacy instructions, stripping global repository files down to core, invariant principles.

Three Core Optimization Principles: Specific Triggers, On-Demand Context, and DoD

OpenAI Developers summarized the path forward into three actionable directives:

"Get more out of GPT-6 Astra by revisiting your skills, AGENTS.md, and task prompts.
Make skill triggers specific, load guidance when it's relevant, and define what done looks like."
— OpenAI Developers (@OpenAIDevs)

1. Make Skill Triggers Specific

When skills, MCP server capabilities, or custom tools carry broad, ambiguous descriptions, the agent frequently identifies multiple tangential skills as relevant.

• The Penalty of Loose Triggers: Generic trigger phrases such as "use for code improvements" or "invoke when handling data" cause the harness to eagerly pull skill instructions into context during routine tasks, diluting focus and exhausting tokens.
• Precision in Skill Descriptions: Trigger definitions should state precise invocation scenarios, explicit prerequisite conditions, and boundaries clarifying when the skill must not be used. Narrow triggers preserve context space until the model genuinely requires the specialized toolchain.

2. Load Guidance When Relevant (Context on Demand)

Rather than packing every coding convention and API schema into a singular, monolithic AGENTS.md, instructions should be decomposed into modular references loaded conditionally based on task scope.

• Root Instructions as Architectural Anchors: The repository root file should contain strictly immutable facts: critical build workflows, environment verification commands, and core architectural invariants.
• Progressive Discovery: Domain-specific guidance—such as database migration protocols, CSS framework conventions, or deployment pipelines—should reside in modular files loaded dynamically only when the active plan references that specific subsystem.

3. Define What Done Looks Like (Clear Definition of Done)

Advanced reasoning models possess significant capability, which can paradoxically lead to out-of-scope edits when termination boundaries are ill-defined.

• Preventing Over-Refactoring: A prompt that simply states "fix this bug" may prompt a capable model to rewrite entire module hierarchies, rename peripheral variables, or introduce speculative abstractions that break untested downstream consumers.
• Observable Completion Criteria: Every task delegation should define clear, observable acceptance criteria: the exact test command that must pass, interface signatures that must remain stable, and explicit prohibitions against modifying untouched files.

Practical Implementation: Auditing AGENTS.md and Task Prompts

Engineering teams migrating to GPT-6 Astra can use the following checklist to audit and streamline their agent setup:

1. Prune Global AGENTS.md

   • Eliminate defensive boilerplate designed for older models (e.g., "always provide complete code without placeholders").
   • Retain only invariant project facts: build and test commands, environment variables, core architecture patterns, and non-negotiable repository boundaries. Aim to keep global rules concise and readable.

2. Decouple Domain Knowledge into Targeted Skills

   • Extract framework-specific or subsystem guidelines into discrete on-demand files or skills.
   • Audit skill descriptions to ensure each has specific, exclusive activation triggers.

3. Incorporate DoD Structure into Task Prompts

   • Adopt a consistent task prompt format that explicitly states:
     • Goal: The precise functional change required.
     • Scope: Specific files or packages allowed to be edited.
     • Verification / DoD: The deterministic command (e.g., test suite or lint check) that verifies completion.

Applying these three principles ensures that GPT-6 Astra operates with maximum reasoning agility, reducing token spend while delivering predictable, production-grade results.

Original source

This optimization guide synthesizes official architectural recommendations and prompt engineering practices published by the OpenAI Developers team (@OpenAIDevs) for the GPT-6 Astra frontier model family. Full release notes and implementation details can be referenced directly through the official developer channels:

• OpenAI Developers (@OpenAIDevs) official announcement on X: https://x.com/OpenAIDevs/status/2098480213244117065
• OpenAI Developers official technical blog — "Rethinking skills and prompts for GPT-6 Astra": https://developers.openai.com/blog/rethinking-skills-and-prompts-for-gpt-6-astra