Are you writing those instructions for a previous model?
"Read this document every time," "Always test," "Confirm before starting." Many people have likely added these instructions to prevent Codex from failing.
Because it fixed things without reading the docs, you wrote to read them first. Because it proceeded without permission, you wrote to confirm before moving.
While those sentences had a reason at the time, they may not be as helpful when the model changes.
Procedures decided to assist previous models might be too detailed for GPT-6 Astra. Conversely, because you haven't communicated the intended scope, it might stop to ask for confirmation unnecessarily.
What needs reviewing is not just the amount of instructions. It is about reducing repetitive tasks and clarifying the necessary scenarios and completion conditions.
Eric Provencher, who handles the Codex developer experience at OpenAI, addresses this issue in an article titled "Rethinking skills and prompts for GPT-6 Astra."
This covers not just the requests you write in chat, but also "AGENTS.md," which conveys work rules for project files in a repository.
"Skills" are collections of procedures and knowledge used for specific tasks. Instructions saved here also influence how Codex proceeds.
In this article, based on Eric's explanations and reference images, we will look at what to reduce, what to keep, and how to rewrite. Examples created for readers are marked as "Application Examples" to distinguish them from the original examples.
This isn't about blaming all of Astra's failures on old instructions. It's an article for auditing the rules you've accumulated to see which ones no longer fit the current work.
1. Why You Need to Review Instructions for Astra
Eric's starting point is the change where instructions meant to "babysit" the model are becoming less necessary than before.
Previously, some tasks wouldn't proceed unless you specified every step in order. To compensate for ambiguity, we piled up detailed procedures and notes.
However, the original text states that models are becoming better at handling subtle differences in meaning and ambiguity. It points out that detailed specifications that were once helpful can now hinder results.
What we shouldn't misinterpret here is that this isn't a conversation about "stopping explanations because the model is smarter."
Eric also recommends keeping guidance to necessary materials. The original text still asks for explanations regarding the safe scope of progress and the work required for completion.
Even for the same instruction, the way you review it changes depending on what that sentence is meant to convey.
For example, you need to distinguish between explanations that convey project-specific circumstances and those meant to make previous models follow procedures.
"Design constraints are written in this document" is a clue for finding information. On the other hand, "Read this entire document from the beginning for every edit" uniformly fixes the timing of reading.
Informing the model of a document's existence is not the same as making it read everything every time.
Also, "Access to production is prohibited" and "Confirm even before running tests locally" stop different actions.
Just because you want to uphold the former doesn't mean the latter is always necessary. However, if it's unclear whether something truly stays local, you shouldn't just skip that confirmation either.
The Skills, AGENTS.md, and daily requests mentioned in the original text all relate to these judgments. Even if you fix a sentence in chat, if the same restriction remains elsewhere, the audit isn't finished.
For example, what if you write "Finish it until it works" in a request, but the applied procedure still says "Always stop at the first implementation and request a review"?
This is an example to explain conflicting instructions. At the very least, without organizing which one the user wants, the endpoint of the request isn't aligned.
When reviewing, don't judge based on "it's long, so cut it." Look at whether that sentence conveys necessary knowledge, determines the scope of work, or simply makes the model repeat previous procedures.
Even if the text is short, if the target of "confirm everything" is vague, it's not necessarily a good instruction. Sometimes, even if it's a bit longer, it's better to convey intent by clarifying the conditions for reading or where to stop.
2. Instructions to Reduce: Repetitive Loading and Overly Detailed Steps
The first thing to audit is loading rules that trigger regardless of the work content.
Eric explains that making the model read massive amounts of documentation or the entire repository guide for a simple typo fix is excessive.
Reading documents puts that content into the model's working information. The original text points out the problem of consuming available context and slowing down work by loading irrelevant explanations.
The context here refers to the bundle of information the model references for that task. If it keeps increasing, it approaches the point where conversation and work history must be compressed.
Therefore, rather than just reducing the number of references, distinguish what needs to be read for the current request.
Example A: Japanese Translation of Reference Image
Before Revision
Always read architecture.md, database.md, and deployment.md in their entirety before editing.
After Revision
Refer to architecture.md when handling boundaries between services, database.md when changing DB structures, and deployment.md when preparing for deployment.
What was kept are the guides to the three documents. What was changed are the conditions for opening them.
In this example, architecture.md is for roles and connections between services. database.md is for the structure of the database. deployment.md is for reflecting what was made into the execution environment.
In the "Before" version, the "read all" rule applies even to a request to fix a single typo. In the "After" version, if the task is changing the DB structure, it proceeds to the corresponding database.md.
This doesn't mean reading other documents is prohibited. If a task spans multiple areas, the necessary documents aren't limited to one.
Creating another uniform rule like "only choose one document" from this example would stray from the original intent.
We didn't delete necessary documents or thin out the content. We rewrote the condition that required checking all documents for even small changes to match the work content.
Eric also mentions keeping documents up to date. Even if you organize reference conditions, a separate check is needed to ensure no old explanations remain at the destination.
Example B: Application Example Based on Original Text
Next is an example applied to a scenario where Codex is tasked with articles, videos, or social media posts. This is not a production procedure posted by Eric himself.
Before Revision
For content creation, read all procedures for articles, videos, and social media posts.
After Revision
Refer to writing.md for article writing, video.md for video production, and social.md for creating social media posts. For multi-format requests, refer to the relevant procedures.
Again, the specific procedures for articles, videos, and social media are kept. What changed was the part that made the model read all procedures under the broad umbrella of "content creation."
If you ask for one article, it proceeds to the article instructions. If you ask for an article and its announcement post together, it proceeds to both article and social media procedures.
If there's no request for a video, it no longer requires loading the entire video production process at the common entry point.
The original text calls this approach of providing necessary explanations in stages "progressive disclosure." It's a method of placing explanations at the entry point to judge the destination, while separating detailed knowledge and procedures into subsequent documents.
For example, if you line up full procedures for articles, videos, and social media at the entry, every request results in reading a massive explanation.
Instead, limit the entry point's role to guidance: "If it's an article, go to this document; if it's a video, go to that one." You keep the detailed explanations without discarding them, allowing them to be read when needed.
Eric explains that for Skills with multiple work procedures, the initial document should be a minimal guide. It should provide just enough information to proceed to related documents or scripts that execute the task.
Create a state where looking only at the entry point tells you which document to proceed to. Simply summarizing long explanations into short ones won't finish this organization of references.
If you drop necessary precautions in the summary, it becomes a different problem. What is kept in the application example above are the procedures unique to each format.
Is Testing Also Set to "Always, No Matter What"?
The original text states that previous models needed to be prompted to test and confirm work. On the other hand, Astra does this on its own, so the same instructions can lead to unnecessary redundant testing.
Do not misinterpret this as "Astra doesn't need testing." The issue is not about stopping checks, but whether instructions are causing redundant checks.
If applying this to your own settings, look at which check you are requesting for which change. The content of necessary inspections and the conditions for repeating them uniformly every time you do something can be audited separately.
Since this article does not compare the number of tests or processing time, it doesn't show an effect like "rewriting will save X minutes." The target of the audit is whether you can distinguish between necessary inspections and redundant repetitions.
3. Narrowing Instructions: When Should This Skill Be Used?
Adding more Skills doesn't necessarily make them easier to choose. Eric draws attention to the practice of downloading and adding massive amounts of Skills.
According to the original text, the name and description of each Skill are loaded into the context for the model to judge when to use them.
Here, distinguish between loading the name/description and loading the Skill body. This isn't saying the model reads every Skill body from the start.
The model first uses the name and description as clues to judge which one to use this time. If those descriptions are too long or there are too many Skills, the original text states that Codex will shorten the descriptions to fit.
As a result, the model may only see part of each Skill's description, making it harder to choose. Even if necessary procedures are saved, the entry point explanation might not be fully conveyed.
Furthermore, Eric mentions contradictions between descriptions or descriptions that try to make themselves used for everything. These can cause the loading of instructions that aren't helpful for the task.
So, it's not about stuffing descriptions with technical terms to make the coverage look broad. Make the description such that the model knows whether it should be called for the current job.
Japanese Translation of Reference Image
Before Revision
Create and verify PostgreSQL schema migrations. Use for work involving databases, queries, models, and persistence.
After Revision
Create and verify PostgreSQL schema migrations. Use for adding/changing migrations or reviewing application procedures.
PostgreSQL is a type of database. "Schema migration" refers to the task of changing the structure of tables and items that serve as data containers and applying those changes.
For example, it's a scenario where you change the database structure to increase the items to be saved. Here, it's cited as an example of explaining the meaning of terms.
On the other hand, "queries" in the "Before" description are requests to retrieve or manipulate data. "Persistence" refers to saving data so it can be used later.
These are terms related to DBs, but not all work involving DBs constitutes a migration task that changes the structure.
The first sentence of the "Before" version shows a specialized task: "Create and verify migrations." However, the second sentence includes broad work related to databases in the usage conditions.
This discrepancy in scope is what's being fixed in the reference image. The Skill's area of expertise and the calling conditions don't match.
After the revision, the role of "Create and verify PostgreSQL schema migrations" remains. On top of that, it's narrowed down to cases of adding migrations, changing migrations, or reviewing application procedures.
For example, if you just want to check a query to retrieve existing data, you don't necessarily need to call this migration Skill just because it's "related to the database."
Conversely, if it's a review of how to apply structural changes, it's still a target in the "After" description. Narrowing it down didn't lose the specialized work.
The point of confirmation when fixing descriptions is not just "what is this Skill knowledgeable about?" It's whether one can read "for which request will it be used, and to which requests will it not be expanded?"
If you just write "DB Skill" to make it shorter, the calling conditions disappear. What the original text asks for is to make the description as short as possible while keeping the usage scenarios clear.
You can use the "Before/After" above to check if the requested job and application conditions match, rather than relying on the strength of the name or the length of the description.
4. Clarifying Instructions: How Far to Proceed and What Defines Completion
From here, we talk about adding necessary explanations. Just reducing loading and procedures won't handle the problem of stopping midway.
Eric states that while Astra works diligently, it can sometimes be cautious about how far to proceed. How to communicate the range you want it to continue is also a target for the review mentioned in the original text.
Particularly, if you've written "Always confirm first" strongly because a previous model moved without permission, audit that boundary.
What the original text points out is the possibility of stopping in a place where it was actually okay to continue, just to strictly follow the boundary. This isn't about telling it to ignore confirmation instructions, but about rewriting what you were permitting.
A: Clarifying the Approval Scope
The original text has an example of a local test that uses disposable test data and does not access production. This is an example of permitting that specific task within your own work environment.
The following "Before" is an application example made for contrast. The "After" contains a Japanese translation of the local test instructions from the original text.
Before Revision: Application Example for Contrast
Request approval every single time before running a test and before fixing a failure.
After Revision: Translation of Original Example
Local tests use disposable test data and do not access production. Please proceed without seeking approval at each stage up to running tests, fixing failures caused by requested changes, and re-running affected tests.
What was kept are the target environment and the scope of work. What was changed is the condition for seeking approval every time within that scope.
"Disposable test data" and "no access to production" are not decorative prefaces. They are premises for judging whether this instruction can be used.
If it's actually a test that connects to production, writing "no access to production" doesn't change the environment. Sometimes it's called "local" but it's unclear if it meets those conditions. Leave unconfirmable conditions as they are.
Also, the permitted fix is for "failures caused by requested changes." It's not an instruction expanded to allow fixing all problems found in the test.
The target of re-execution is also written as "affected tests." It's different from a uniform specification to repeat all tests every time.
This sentence specifies the actions that can proceed, but it doesn't eliminate approval for other tasks. It shows how much to delegate a bundle of tasks that have been confirmed as safe.
You don't need to go as far as "permitting everything because stopping every time is a hassle." If you separate tasks you don't want it to stop for from tasks you still want judgment returned for, the meaning of the request changes.
B: Clarifying Completion Conditions
Eric explains that if you're used to GPT-5.6 Sol, which works for a long time, Astra's way of stopping might feel cautious.
At the stage where the initial implementation is done, even if work remains, it might return to request a review. Therefore, he recommends deciding completion conditions before starting.
Is what's needed just the implementation, or up to running it to confirm? Furthermore, is it up to fixing bugs found during confirmation?
The person issuing the request organizes those differences first. A finish line that's hard to convey with just "complete it" is written as a task.
The following is an application example where the original explanation is replaced with the creation of an inquiry form. It is not Eric's actual request text or a result of actual behavior verification.
Before Revision
Make an inquiry form. Let me check once it's implemented.
After Revision
Make an inquiry form. This time, confirm locally that it can detect empty required fields and invalid email addresses, and that the completion screen appears after a test submission. Fix any bugs caused by this change and report them along with the confirmation results. Do not publish to production or send actual emails.
What was kept are the purpose of making the inquiry form and reporting the results to a human. What was changed is how much to verify before reporting.
In the "Before" version, the request is "Let me check once it's implemented." Even if it stops at the point of initial implementation, it hasn't strayed from the instructions.
If you want to see the design midway, that way of stopping has meaning. If it's a stop to confirm parts you haven't decided yet, it's an instruction with a reason to remain.
On the other hand, if what you want this time is a form that has finished operation checks, include those checks in the request. The example lists empty fields, invalid emails, and the display after test submission.
Compared to just "check if it works properly," the states to try are specific. If bugs caused by this change are found during confirmation, the target is set to reporting after fixing them.
At the same time, publishing to production and actual email sending are excluded. This is to avoid confusing verifying screen test submissions with delivering emails to real destinations.
This request does not treat the actual email sending function as verified. Have it report how much was confirmed locally as a result.
According to the original text, if you want to proceed beyond the first implementation, convey what to investigate and where to stop.
Rather than just strengthening it with "don't stop midway," list necessary confirmations and operations not to proceed with. This way, you can review even the places where it returns to a human.
5. Auditing Your Own Settings
At the end of the original text, Eric suggests asking Astra for an audit based on this article. An audit means reading existing instructions and checking for overlaps, discrepancies, and areas that can be reviewed.
You can also open your own AGENTS.md or Skills and look at sentences you're curious about. However, if you want to organize where and what instructions you wrote, you can leave it to an audit before making changes.
The approach of performing only the audit first without changing files is a proposal of this article. It is not a mandatory procedure specified by Eric.
In that case, don't ask to "delete all unnecessary instructions" from the start. What you want first is material that allows you to compare the original instructions with the proposal for how to change them.
One more note from the original text: Skills and instructions placed in a repository might be used by other workers' AIs.
Those AIs might not use the same Astra. Eric points out that explanations helpful for Sol or Luna might add too many constraints for Astra.
Even if it looks too detailed to you using Astra, it might be necessary for other models. If you're changing shared rules, who uses which model is also a factor in judgment.
If usage status is unknown, don't delete assuming "only Astra is used." It's enough to confirm correction candidates while leaving unclear points as they are.
The following audit prompt was created for readers based on this article. It is not a prompt posted by Eric in the original text.
Use it in the target project and share the article text and the request text you want to audit. If the readable range is limited, accept it as an inspection result within that range.
Please audit the current instructions based on the shared commentary of Eric Provencher's article. Perform only the audit this time; do not create, edit, or delete files, or change settings.
The targets are the AGENTS.md applied to this project, the names and descriptions of available Skills and the bodies necessary for the audit, and the daily request text I shared. Please list the targets you were able to read.
Check for the following problems: ・Duplicate instructions in multiple locations ・Instructions that cannot be followed simultaneously or have conflicting endpoints ・Excessive uniform rules that require loading or confirmation every time regardless of work content ・Application conditions that are broader than the Skill's actual role ・Instructions where it's unclear how far to proceed or what defines completion
For found locations, categorize them into candidates for "Delete," "Shorten," "Change Application Conditions," or "Maintain," and provide reasons. Do not make reducing character count the goal itself; also list instructions that need to be kept.
For each candidate, provide the following: 1. File name/location or the relevant part of the shared request text 2. Current instruction 3. Assumed problem and the basis for judgment 4. Proposed revision. If maintaining, the reason for it 5. What to keep and what to change 6. Conditions humans should check before changing
Do not bulk delete project-specific constraints, specialized knowledge, necessary tests, or necessary approvals. Only propose allowing local tests or fixes to continue within the range where environmental conditions, such as target data and the absence of production access, could be confirmed.
Check if other models like Sol or Luna also use the same instructions. If unknown, write "Unknown" and do not assume it is an Astra-only rule.
Clearly state files that could not be read, environmental conditions that could not be confirmed, and information lacking for judgment. Distinguish between problems explained in the materials, problems actually found in settings, and unverified improvement candidates; do not write improvement effects as already measured.
Finally, summarize the correction candidates to be considered with priority, along with reasons. Execution of changes will be requested separately after I confirm the targets and content.
What you receive with this request is not the revised settings, but a list where current instructions and proposed revisions correspond. Even if it's written as a "Delete candidate," that alone doesn't finalize it as unnecessary.
The categorization of candidates is provided so that proposals to change reading conditions aren't lumped into "Delete." In the case of the document reference example in this article, the document remains, so the focus is on changing application conditions.
For Skill descriptions, the specialized role remains, but the calling range is narrowed. In this case, if a proposal to delete the specialized knowledge itself comes back, you can check if what's kept before and after the revision is different.
"Shorten" candidates are for seeing if the same conditions and constraints can be conveyed in shorter sentences. "Maintain" candidates ask for the reason why it's necessary to keep them.
Look at the audit scope along with the results. Whether only the Skill name and description could be read, or whether the actual procedures could be read, is also material for judging the results.
Whether a description is too broad can be checked with the former, but whether there are duplicates in procedures or whether necessary knowledge hasn't been cut cannot be confirmed unless the body is read.
If you haven't shared daily request texts, discrepancies with stop conditions there are also unconfirmed. Reading part of the settings doesn't constitute a completed audit of the entire work environment.
The order to look at is: original instruction, reason for making it a candidate, remaining constraints, and unconfirmed conditions. For example, if the presence of production access is unknown, the premise for a proposal to skip approval isn't met.
You can also check if necessary specialized knowledge hasn't been cut or if impacts on other models haven't been assumed. Proceed while keeping the suspicion found in the audit separate from the judgment that it's okay to change.
Reread the instructions you've kept adding to match your current work. The first step is not a bulk deletion of settings, but this audit that doesn't change anything.
