
- BenCodexThe Zero Basic Introduction program ensures that you and your brothers and sisters can read, as long as you finish primary school. It's not a functional dictionary, it's an ordinary learner who has been able to transmit to you in the most common and understandable language from the first time that Codex was opened to the complete path that really enabled it to perform an acceptable task. I suggest you start with the collection and look back slowly
The first time I opened Codex, I made the same mistake as many people: to think of it as a "ChatGPT" better coded. I wrote a line in the input box, "Do me a website," and then I looked at it to generate the file. The page does open in a few minutes, but some buttons do not work, the moving end spills, and then the data disappears, and I don't know which files it changes。
And that was the moment I realized that the code would be generated, not the delivery of the project. Codex's real strength is not how beautiful a response is, but its ability to access a real project, to read documents, to understand constraints, to change codes, to run commands, to check results, and to repeat them on the basis of feedback. It's more like a robot that can operate a computer and project environment, rather than just a question-and-answer robot in a chat box。
But this also means that the threshold for the use of Codex is not just "can you write a hint?" You also have to learn to give it the right job catalogue, the right authority, a sufficient but not excessive context, and a clear acceptance standard. As long as these four things are not handled, the stronger model may run fast in the wrong direction。
This lesson doesn't require you to be a programmer. You just have to create folders, install software, copy commands and be willing to view the results at every step. I will use a “personal task board” as a practice project, which will combine installation, first dialogue, demand dismantling, document modification, running testing, code review, long-term rules and duplicate work. After that, you get more than just a Demo, you get a way of replicating a future web page, automated scripts, data tools and AI products。
First of all, Codex: It's not "writes for you, but completes a loop for you."

WHEN I USED TO USE THE NORMAL AI PROGRAMMING TOOL, THE PROCESS WAS USUALLY: I DESCRIBED THE PROBLEM, AI GAVE THE CODE, I COPIED IT TO THE EDITOR, AND THEN I COPIED IT BACK. THE CONTEXT IS MOVING BACK AND FORTH BETWEEN CHAT FRAMES, EDITORS AND TERMINALS, AND THE HARDEST PART IS NOT WRITING CODES, BUT EXPLAINING “WHAT I HAVE JUST DONE”。
Codex put this link up. It can view project files, search codes, edit files, execute build or test commands within its mandate and continue to use the results as a basis for further judgement. A complete cycle is usually:
- Understanding the goal: to see what you're going to solve。
- Examination of the environment: Reading directories, key documents, project descriptions and reliance。
- Plan development: Disassembly big tasks into small, verifiable steps。
- Execute changes: Create or edit files and run commands as necessary。
- Validation results: Perform tests, build, type checks or actual previews。
- Review discrepancies: confirm that no document was altered and no visible return was introduced。
- Delivery statement: Tell you what has been changed, what has been verified and what risks remain。
The real value is the fifth and sixth steps. Agent, which generates code only, can easily give you a "completed" illusion, and a qualified Agent should prove the result. I'll add the following sentence to the end of every mission I'll take
Please run a check related to this change and tell me which documents have been modified, which validations have been performed, what results have been obtained and which risks remain unverified. Don't just say “completed”。
This sentence, which appears to be ordinary, can significantly reduce the number of “codes written but not usable”。
Two or four entry points: the one that's the closest to the job first

Codex is not a single form. You will see desktop applications, IDE extensions, CLI command lines and Web/ Clouds. They are not who replaces who, but fit for different jobs。
Desktop application:Fits for first contact with Codex. You can choose local projects, see file changes, start multiple tasks, and you don't have to be familiar with terminals. It is more like an "AI desk " that handles not only code but also documents, tables, web pages and other file-type tasks。
IDE EXTENSION:Suits people who have written codes in VS Code, Cursor or Windsurf. It directly uses the currently open file, the selected code and the context of the editor. The IDE entrance is usually the most successful when small-scale modifications, explanations, and fixes the current error。
CLI: Fits for someone who wants to put Codex in a terminal workflow. It functions directly in the project directory and is suitable for batch changes, scripting, CI or tasks requiring frequent commands. This paper focuses on the CLI because it is the best way to show how Codex can read the project, apply for permission and verify the results。
Web/Log:It is appropriate to entrust tasks to a remote environment for long periods of time or to deal with multiple project issues in parallel. Its advantage is not that it is a simpler interface, but that the mission can be carried out on a continuous basis, independently of your current computer. But the cloud environment is not exactly the same as the local environment, and dependency, key, network privileges need to be configured separately。
MY CHOICE IS SIMPLE: FIRST LEARNING WITH A DESKTOP APPLICATION OR CLI; IDE WHEN WRITING A CODE; AND THEN CLOUD WHEN RUNNING IN PARALLEL OR LONG. DO NOT START WITH ALL FOUR PORTALS. THE MORE ENTRANCES, THE MORE EFFICIENT THEY ARE, THE EASIER THEY ARE TO FOCUS ON THE CONFIGURATION。
Three things were prepared before the start: project folders, Git and a verifiable small target
Many of the courses come up with models, MCP, Skills and complex configurations. I set up a bunch of things, and I didn't even get through the first one. I then reduced the preparatory work to three。
First, prepare a separate project folder. Do not let Codex scan the desktop, download the directory or the whole hard drive for the first time. The catalogue determines what it sees and what it defaults on. The new guy better create a special practice directory:
mkdir codex-first-project
cddex-first-project
Second, the installation of Git and the development of pre- and post-mission screening habits. Git, which is not an exclusive programmer tool, is more like the “hidden history” of the project. The difference is presented once before the Cordex move, after the mission is completed, and even if the modification is unsatisfactory, it will be possible to know exactly what happened。
oh, shit init
i don't know.
"before codex ask"
If the directory is still empty, you can first create a `README.md ' and then make the first submission. You can also use graphic Git tools, without forcing yourself to back off. The core is not an order, but leaves a recoverable boundary for each automatic modification。
Third, select a small target that can be accepted in 30 to 60 minutes. For the first time, no “complete power company platform” “micro-credit alternatives” or “full automated money-making systems” should be used. The bigger the target, the harder you can judge whether the problem comes from demand, model, environment or code. The objectives of the exercise are:
Do a locally run task viewer: add new tasks, mark them and delete them; keep the data after the page is refreshed; interface fit the cell phone; no backend, no login required。
THIS GOAL IS SMALL ENOUGH TO INCLUDE UI, INTERACTIVE, DATA-STORAGE AND RESPONSIVE LAYOUTS THAT ALLOW FOR THE EXERCISE OF A COMPLETE DELIVERY CHAIN。
Installation of Codex and CLI: Officially, before processing system differences

The official currently provides independent installation scripts for MacOS and Linux. Run in terminal:
curl-fsSL https://chatgpt.com/codex/install.sh
Implementation after installation:
codex
On the first start, select the " use ChatGPT login " or other available login method by UI tip. After login is complete, check the version and help information:
@codex_version
@codex_help
If you already have a Node.js environment, you can also choose npm from the official installed page; if you are used to Homebrew, you can also choose Homebrew from the page. Do not install it in three ways at the same time, otherwise there may be multiple `codex ' implementable documents in the system and the old version is still being updated。
Windows users give priority to the official Windows desktop application or the Windows installation path currently available on the official page. WSL can also be used if your development project is mainly run in Linux environment. The key is not “what is more advanced”, but Codex, Git, Node/Python and the project document must be in the same accessible environment. The most common Windows pit is where the project is on the Windows Disk, dependent on being installed in the WSL, and the terminal is activated from another environment, lastly as an order cannot be found or as an error of authority。
Do not start any directory directly after installation. Let's go to the practice directory
cddex-first-project
codex
The Codex startup interface displays the current model, work catalogue and context status. Confirm that the directory is correct. If the directory is wrong, exit immediately and restart in the correct directory. Making Agent work in the wrong directory is far less dangerous than a hint。
For the first time, don't let it write the code: let it explain what it sees
For the first time, I really built trust, not because Codex created a page, but because I made it do a read-only check first. I entered:
Do not create or modify any files first. Please check the current directory and tell me:
1. What documents are available
2. What is the status of this project
What are the minimum technical options you propose to use in order to fulfil the “local personal task board”
4. What options do I need to identify。
This step has three effects. First, make sure it's really in the right directory. Secondly, to confirm that it understands the goal. And third, let me see the technical choice before writing the code. If it comes up with advice on databases, account systems, Docker and micro-services, I'll know that the program is over-designed。
An ideal answer should be to press the program to a minimum, for example, using Vite + React, or simply using HTML, CSS, JavaScript and `localStorage ' . For the first exercise, I would prefer to have three original sets because of the low level of reliance, the simplicity of start-up and the understanding of each document。
Then it turns the target into a receiving and inspection list:
Change the demand to a verifiable acceptance list. Each must be checked by page operation or command and not write unjudgeable descriptions such as “exhausted” “code grace”. Just get out of the list and don't start developing。
you should get a similar result: the page was opened without error for the first time; the task could be entered and added; the empty content could not be submitted; the completed status could be changed; the task could be deleted; the refreshed data retained; no horizontal spill at 375 px width; and there were no unprocessed control table errors。
It's only then that the demand goes from "I want to do something" to "what's done."。
VI. Not to write in papers, but to complete four fields

I later found that the main problem with the novices was not that they were not long enough, but rather that they were missing fields. Official best practices also summarize high-quality tasks in four parts: objectives, context, constraints and completion criteria。
Target(Goal): Answer “What to change”. Instead of saying “optimize”, it would say “support the submission of return vehicles when new tasks are added and prevent pure space content”。
**Context(Context): Answer “Where should we look first”. You can specify a file, directory, screenshot, error reporting, interface document or reference realization. The more context the better, the more important thing is to have Cordex read the material。
**Constraints(Constraints): The answer is “Nothing to destroy”. For example, no new framework is introduced, no public interfaces are modified, no `.env ' is read, current visual style is maintained and only current modules are modified。
**Completion standards(Done when): Answer “how to prove it”. For example, test pass, build success, specify interactive recurrences, screenshots are consistent with reference diagrams, no Lint errors are added。
Put the four parts together, and this exercise can say:
Objective: To complete a local personal task board in the current empty directory, to support the addition, completion/cancellation, deletion and permanence of the localStorage。
Context: Read README.md first; the project currently has no code. Prioritize primary HTML, CSS, JavaScript to ensure that I can understand it。
Constraint: No backend, no login, no frontend frame, no remote CDN; interfaces keep white bottom, blue emphasis; no horizontal scrolling at 375 px width of the moving end。
Completion standards: Local start-up and validation after creation of necessary documents; item-by-case check for new, empty-value intercepts, state-to-state switching, deletion, refreshing and moving-end layouts; final list of modified documents, validation steps and uncovered risks. A maximum of 6 steps plan was given before the start, and it was confirmed that the programme had not exceeded requirements before implementation。
Such hints are not fancy, but they are more useful than “You are a world-class insular engineer, please think in depth”. Role-setting cannot be a substitute for project facts, nor can emotional emphasis be a substitute for acceptance standards。
VII. APPROACH OF THE APPROACH: IT'S NOT THE BIG BUSINESS, IT'S THE COURSE

For the first time, when I saw a power hint, my instinct was to allow it in its entirety, lest it be repeated. And then I realized that Codex was able to execute orders, modify documents and access the network, and that excessive access not only increased risks, but also deprived you of the opportunity to observe its work。
Current Codex permissions can be understood as three:
- `:read-only`: Fit to read codes, explain projects, do programmes, check risks. It cannot modify the working area directly。
- `:workspace`: Allows for writing in the current working area and is limited to the selection and suitable for most day-to-day development tasks。
- `_other organiser`: Remove local sandbox restrictions. Only when you clearly need extensive access and fully understand the implications。
It is enough for the newcomer to default on the selection of working-level privileges. Read-only when exploring strange warehouses; confirm the program and then cut to the work area for writing. Do not give full permission for less than two confirmations and do not direct the directory containing private keys, wallets, production vouchers or a large number of personal documents as a workspace。
There are two different concepts:Sandbox BorderIt's not like it's the same thing. To decide where to order access,”Approving Policy”Decide when to suspend and ask you. Even in sandboxes in the work area, a mission may request authorization because of the need to network, to write an off-site directory or to perform high-risk operations。
My simple rule is to read the code only, to change the workspace for normal items, to install a dependency and access network to be confirmed on a step-by-step basis, and to remove files, reset history, enforce delivery and perform a separate check of the production environment. The purpose of the permission is not to stop the Codex job, but to make the impact radius of the error manageable。
VIII. Orders that must be known: 8 first, and other if necessary
Cordex's slash command will change with the entry and version you use. Enter `/ ' commands that can see what the current environment really supports. The new guy doesn't need a complete back list
`/status ' : view the current session, the context and the restricted status. the longer the task, the more it should be seen once in a while。
`/model ' : select a model for the current task. do not superstitiously always use the most heavy model; clear minor modifications can give priority to speed, complex structures, difficult debugging and long missions that increase the strength of reasoning。
`/ressoning ' : adjustment of reasoning input. low intensity is appropriate for well-defined tasks, medium and high intensity is appropriate for cross-document modification and debugging, and the highest is better for truly difficult and deserving tasks。
`/missions ': select the range of operations permitted by the current task. the different entry points may vary slightly, depending on the actual interface options。
`/init ': Generate an initial template `AGENTS.md ' for the current project. It is not completed after its creation and must be adapted to the actual circumstances of the project。
`/plan ' : to enter the planning model, tailoring to needs is not clear, or to set a course when the mandate has multiple phases。
`/review ' : code review for failure to submit changes, designated submissions or baseline branches. its value is to replace the “review perspective” of the examination, not to repeat what has just been achieved。
`/compact ' : compress early context when talking long, keep targets, constraints, decision-making and progress, and reduce interference with old information。
If you are in the CLI, you often resume sessions, fork sessions, etc. Official best practice refers to orders such as `/resume ' , `/fork ' , but the available orders will vary depending on the client and the environment, so the most reliable practice remains to enter `/ ' or to view the official current order page。
IX. `AGENTS.md ' : Translating repeated words into project rules

I understood the value of `AGENTS.md ' when I reminded Codex, “Don't use npm, use pnpm” “Modified Run Test” “Don't touch the Generating Directory”. It is equivalent to a project description written to Agent, and Codex automatically reads the rules at the relevant level when entering the project。
you can run `/init ' drafts in the root directory and then compress them into really useful content. a suitable version of the academy project could be:
# AGENTS.md
## PROJECT OBJECTIVES
– This is a zero-dependent local task board exercise。
– Prefer to keep the code simple, readable, and avoid excessive abstraction。
## MODIFICATION RULES
– Use original HTML, CSS, JavaScript without new frames or remote dependence。
– Do not modify files unrelated to the current task。
– Do not read or output any key, environmental variables or personal files。
## CERTIFICATION RULES
– When JavaScript is modified, check that no errors were added to the browser console。
– Validation of new, completed switching, deletion and refreshing per delivery。
- The final statement must set out the changes to the document, the validation results and the remaining risks。
`AGENTS.md ' is the easiest to make two mistakes. The first is a list of wishes written in thousands of words, filled with vague requirements such as “quality” “best practices” “deep thinking”. Too long a rule would take its context and could conflict with one another. The second is to include one-off requirements, such as “to make the button green today”. Long-term rules should be stable, enforceable and repeated。
Larger warehouses can be layered with rules: global file-keeping personal habits, common norms for the warehouse root catalogue preservation team, subdirectories with local service or modular rules. The closer to the specific rule of the current document, the higher the priority. You don't need to design a complete system on the first day; when the same error happens the second time, you add the corresponding rule。
X. REAL RUNNATION: PLAN, IMPLEMENTATION, VERIFICATION, REVIEW

Now go back to the mission board. Read-only inspections, acceptance lists and project rules have been completed, followed by Codex。
In the first round, there was no simultaneous pursuit of functionality and vision. Let's get it done with the minimum ring:
The first edition is now on the confirmed acceptance list. Availability completed without additional animation and complex components. Inspections that can be implemented at each stage of completion are run; if the environment lacks the necessary tools, the minimum solution is indicated and no unauthorized increase in dependency is allowed. Stop after completion and wait for my acceptance。
Codex should create the necessary documents `index.html ' , `styles.css ' , `app.js ' and initiate or inspect them in a manner appropriate to the current environment. You need to see which orders it actually runs. Don't just look at the final response, because the execution log tells you if it's really validated。
Once the first edition comes out, I will do a round of manual check-ups myself: three new tasks; enter spaces to see if they are stopped; finish one mark; delete the other; refresh the page to see if the status is maintained; zoom in the browser width to the cell phone size; open the console to see if it is reported。
When problems are identified, do not rub the whole phenomenon in the words “is not working”. Give Codex a minimum recurrence:
I FOUND A REPLICABLE PROBLEM: THE NEW TASK “A”, MARKED AS COMPLETED, CONTINUED AFTER THE PAGE WAS REFRESHED, BUT THE COMPLETION STATUS WAS LOST. PLEASE LOCATE THE ROOT CAUSE AND EXPLAIN WHICH STEP THE DATA IS NOT SAVED BEFORE MAKING THE MINIMUM MODIFICATIONS. DO NOT RECREATE IRRELEVANT CODES. THIS SET OF STEPS WAS RETESTED AFTER THE REPAIRS AND A CHECK WAS COMPLETED TO PREVENT THE RETURN OF THE SAME TYPE。
this formulation makes clear the phenomenon, the re-emergence steps, the expected behaviour, the modification of the boundary and the means of verification. it is easier to achieve stable results than “upload the bug, fix it”。
Once the function is completed, the visual wheel is done separately:
optimizing the interface level without changing the current functionality and data structure: white background, dark grey text, blue emphasis; maximum width of content area 720px; no spill in input area and task card below 375px width; clear but not diluted completion status. changes only styles and necessary semantic labels. compares the changes before and after completion and again validates all functions。
Finally run `/review ' , allowing Codex to check from a review point of view that no changes were submitted. The focus of the review can be on the reliability of data sustainability, the security of user input, the existence of inoperable interactions, the spillover of the mobile end, and the availability of irrelevant changes. The review found that the problem was not entirely mechanical, but whether it was real or not。
The key to this link is not “Codex right at a time”, but to turn failure into a problem of locatorability, repairability and reversion. What you really train is delivery capacity, not card draw。
XI. Context management: Too little guess, too much gets lost
The quality of Codex's output depends heavily on what it sees now. The two extremes common to newcomers are to give a single message of need and to expect it to find everything by itself, or to stuff dozens of documents, all chat records and the whole demand library at once。
I now divide the context into four layers。
- The first level is the current task: what this side does, how the problem is repeated and what the criteria are for its completion. It should be short and clear。
- The second level is the project rules: placed in `AGENTS.md ' , including the catalogue structure, operating orders, project constraints and certification requirements。
- The third level is reusable: when the same set of steps is repeated, it is sealed with Skill. For example, a fixed code review list, issuance of notes generation, log referencing process, content layout specifications。
- The fourth level is external dynamic information: links through MCP or plugins when data are available in GitHub, Setry, Figma, Notion, database or other systems and are subject to continuous change. Do not access all tools for “looks professional”; each additional tool adds a set of privileges, methods of failure and context noise。
When the session gets longer, let Codex sort it out and then use `/compact':
Please organize the context of the current mandate and retain only the objectives, core constraints, confirmed decisions, modified documents, validated results, unresolved issues and next steps. Delete the overturned formula and repeat the discussion。
If the task has been split into two separate issues, it is cleaner to use a new session or `/fork ' than to continue stacking in a chat. A session would best revolve around a coherent goal, rather than a front end in the morning, an analysis of stocks in the afternoon and a continuation of the Bug at night。
XII. Modelling and reasoning intensity: Selecting by task difficulty, not using the highest level as default
Model selection is the most easily influenced by marketing. At first, I felt that it would be best if the strongest model and the highest degree of reasoning were always chosen. When actually used, it was found that small tasks would slow down, with a larger number of long answers and not necessarily a significant improvement in quality。
My division is:
- Document interpretation, fine-tuning of text, clear single document modification: low priority or medium reasoning。
- Multi-document function, conventional re-construction, test completion: medium or high reasoning。
- It is difficult, Bug, structural migration, long-link missions, security clearance: high or higher reasoning。
The model is selected on three dimensions: whether the task is complex, whether the cost of the error is high, whether you can quickly verify it. A button text modification does not need to be configured at the slowest; the migration of production data, even with few codes, deserves more careful reasoning and review。
adjustments to the current session through `moder ' and `/researching ' are more appropriate for the learning phase than frequent changes to the global configuration. when you know what type of task you're in, write the stability preference in ~/.codex/config.toml'. the global configuration saves the individual default, the project level `.codex/config.toml ' saves the specific settings of the repository, and the one-time command line parameters only deal with temporary exceptions。
XIII. MCP, Skills and Plugins: Run manual processes and automate

I USED TO INSTALL A LOT OF MCPS AND PLUGINS AT ONCE, AND THE RESULTS LIST BECAME LONG, AND REQUESTS FOR AUTHORIZATION INCREASED, AND WHEN I ACTUALLY DID THE JOB I DIDN'T KNOW WHICH TO CALL. I THEN MADE A RULE FOR MYSELF: ** THERE WAS NO MANUAL REPETITION OF THE PROCESS THREE TIMES AND THERE WAS NO AUTOMATION. **
MCP is suitable to connect to an external system, allowing Codex to access real-time information outside the chat box and the warehouse. For example, read the draft, see error monitoring, search the worksheet or access the internal knowledge base. It addresses the question of where the context is。
Skill is suitable for encapsulation repetition. It combines the trigger conditions, steps, input output and necessary scripts so that the long hints are not repeated. It addresses the question of “how this should be done in a stable manner”。
The plugins typically package Skills, MCP and associated capabilities and are suitable for the installation of a set of capabilities related to a service or workflow. It addresses the issue of “how to more easily distribute and activate a set of capabilities”。
Three questions can be asked as to whether access is worth it: whether the data is outside the project; whether the data are constantly changing; and whether the connection will save the possibility of continuous replication of paste. If all three answers are not, the ordinary documents and the hints are sufficient。
The most rational sequence of upgrades to a newcomer is to complete a purely local project; to write `AGENTS.md ' ; then to make a re-emergence review or release process into a Skill; and finally to access only one external tool that is really needed. It's a layer of power, not a pile of it。
Fourteen, ten pits I stepped on, and more direct modifications
- Start in error directoryI don't know. Amendments: Check the work catalogue and list of documents first after start-up。
- One sentence requires the completion of large projectsI don't know. Amendment: Define the minimum closed ring and break the target into a round of acceptable tasks。
- No Git checkpointi don't know. amendments: a mission is submitted once and diff is examined after completion before a decision is made to retain。
- Just describe what you want. You can't change anythingI don't know. Amendments: Clear dependencies, interfaces, directories and data security boundaries。
- "Having success" as "demand completion"I don't know. Amendments: Write the receipt and inspection list using a user action and run the test is only one of the evidence。
- Found Bug and made it large-scaleI don't know. Amendments: Require root-cause analysis before minimum modifications are made and final re-entry check。
- From the beginning, you're given full authorityI don't know. Amendments: Read-only exploration, work area implementation, high-risk actions identified separately。
- Put all the rules in every hintI don't know. Amendments: Long-term rules are written in `AGENTS.md ' , which repeats the process into Skill。
- The same long session handles unrelated tasksI don't know. Amendments: A session corresponds to a coherent goal, organized and compressed too long, and opened fork。
- Trust in the final summary, without the actual differenceI don't know. Amendments: View the modified file, command output, test results and Git diff. Agent's statement is not evidence, but the execution record。
Fifteen, five introductory phrases that can be copied directly
1. Quick Understanding of Strange Projects
Do not modify a document first. Please identify from the current project: the purpose of the project, the main directory, the start-up entrance, the reliance on management, the build/test command and the three areas most likely to have problems. Each conclusion is documented. Finally, give me a shortest path from zero to start a project; if there is not enough information, make it clear what is missing, do not guess。
2. Translating vague ideas into enforceable needs
I'd like to do it. Do not write a code, but consider the needs, like the product manager and the engineer: indicate the target user, the core scene, the minimum functional closed loop, a clear range of not to do, key risks and verifiable acceptance standards. Up to five key issues affecting the programme were raised with me; after I had responded, a phased implementation plan was exported。
3. Safely achieve a function
Target: [Function]. Context: [relevant documents/faults/references]. Constraints: [Non-changed interface, dependence, directory and style]. Completion standard: [test, build and user operations results]. Read the document and give a maximum of 6 steps plan; make only the minimum changes related to the target; run the relevant validation after completion, listing the modified document, the command results and the remaining risks。
4. Recoverable restoration Bug
Problem phenomenon: [actual results]. Retrogressive step: 1. [step] 2. [step] 3. [step]. Expected outcome: [what should happen]. Please first locate the root causes and indicate the evidence, and do not reconstruct them immediately; then propose a minimal repair programme. It is then validated in the same set of steps, supplemented by tests or inspections that prevent return. Do not modify unrelated files。
V. Self-examination before the end of the mandate
A delivery review is performed before the end: article by article against the original target and acceptance criteria; see if Git diff contains irrelevant modifications; run tests, build, Lint or type checks related to this change; check error handling and boundary scenes. The final output is only four parts: completed, validated, not completed, risk and next step. Items without evidence are not marked as completed。
Think after
After some time, the biggest change in Cordex's perception was that the hint was just the mission entrance, and the real decision was the work system。
A reliable system includes a correct catalogue of work, recoverable Git checkpoints, sufficiently clear targets and boundaries, just enough authority, acceptance and inspection standards that can be implemented, project rules that are continuously updated, and post-mission testing and review. The stronger the model, the more important the system is, because the powerful Agent can magnify the right direction more quickly and the wrong assumptions more quickly。
So the new guy doesn't have to go after "Let Codex produce the whole product at a time." Let it do a small task in the correct catalogue, produce verifiable evidence and gradually expand the mandate. You can see why it's changed, how it's withdrawn and how it's done。
If you remember only one sentence, you can remember this formula:
> Codex 's delivery quality = a clear target x a valid context x a reasonable authority x an enforceable acceptance。
ANY ONE IS CLOSE TO ZERO, AND THE END RESULT WILL BE A DISCOUNT. YOU KNOW, WHEN YOU GET THESE FOUR, YOU GET NOT JUST AN AI THAT CAN WRITE CODE, BUT A WAY OF WORKING THAT CAN CONTINUOUSLY EXPAND PERSONAL EXECUTION。