How to use Codex during a working day, with six practical prompts
You open a project, find a half-finished task and spend the first part of the morning remembering what changed. Later, a test fails. By the afternoon, someone needs a clear update. Codex can help at each point, provided the work has a clear purpose and something you can check.
Codex is OpenAI’s coding agent. With the appropriate tools and permissions, it can inspect project files, change code and run commands. The Codex CLI overview describes these capabilities. Access depends on your setup; a prompt cannot give it a missing connection or permission.
Here is a practical way to use it across a working day, with one project example and six prompts you can adapt. The aim is to finish a useful, reviewable piece of work and understand what happened along the way.
Set up the project context once
Open the correct project folder or repository, the collection of files and version history for the project. Point Codex to the current requirements, relevant design and instructions for running the application. Check whether someone already has work in progress before starting your change.
An optional AGENTS.md file can hold shared instructions such as the project layout, test commands and coding conventions. Keep it short and accurate. Today’s task belongs in the task brief; stable team guidance belongs in the shared instructions. OpenAI’s workflow guide distinguishes this recognised file from other optional planning conventions.
Use your organisation’s approved account and access settings. Give the task only the information it needs, using sanitised examples where appropriate. Keep passwords and production customer data out of prompts. Written instructions guide behaviour; configured permission boundaries control what local commands can access.
Follow one change through the day
Example: an internal task dashboard needs an “Overdue only” filter. For this exercise, the team agrees that overdue means an unfinished task with a due date earlier than today in Europe/London. Tasks due today, completed tasks and tasks without a due date are excluded. Existing search must still work.
These are example product rules, not universal definitions. Agree your own before building. The times below describe a sequence you can fit around your day, rather than a timetable or a promise about how long the work takes.
1. Start the morning by getting oriented
Purpose: Find the relevant code and uncertainties.
Ask Codex to explain the existing behaviour and name the files behind it. This is useful when you are new to a codebase or returning after time away. Check that its explanation points to files it actually inspected.
A useful answer might identify the task-list component, a date helper and the current search tests. If it cannot find the due-date definition, that is a question to resolve before implementation.
2. Before building, make success observable
Purpose: Turn an idea into behaviour you can assess.
Acceptance criteria are the observable conditions a change needs to meet. A Product Owner can check whether they reflect the user need; a developer or tester can check whether they cover awkward cases. Codex can help make those questions visible.
With the example date fixed at 21 October 2026, an unfinished task due on 20 October should appear. One due on 21 October should not. A completed task due on 20 October should also stay out. These expected results give you something more specific than “the filter works”.
3. During focused work, delegate one change
Purpose: Produce a small implementation with relevant checks.
Once the rules are settled, authorise implementation clearly. For a routine change, Codex can inspect, edit and run checks within the agreed scope without needing a new prompt for every file. OpenAI’s best-practice guidance recommends clear task context and verification; planning first is particularly useful when a task is ambiguous or complex.
Keep unrelated improvements out of the request. A filter task should not quietly become a dashboard redesign. Ask for a short explanation of the approach so you can follow the code rather than only accept the result.
4. If something fails, investigate the evidence
Purpose: Understand a failure before changing more code.
A failed check needs a diagnosis. Share the exact command, error and expected behaviour, with sensitive details removed. Distinguish a defect in the change from a missing dependency or a test that already failed beforehand.
For this dashboard, a failure around midnight could involve the date comparison, the chosen timezone or the test clock. Ask Codex to follow the evidence. Do not ask it to weaken a test simply to make the result green. Skip this prompt when there is no failure to investigate.
5. In the afternoon, review the change itself
Purpose: Check behaviour, scope and the limits of the evidence.
Read the diff, the lines added, changed or removed. Run the application and try the important cases yourself. For the filter, use the keyboard, combine it with search, check an empty result and confirm that switching it off restores the expected list.
Ask Codex for a review focused on defects and missed requirements. Its review can help you find questions, but it is not independent proof that its own implementation is correct. OpenAI also documents repository-specific review guidance, which can preserve important project rules.
6. Before finishing, prepare tomorrow’s starting point
Purpose: Leave a truthful update and a usable handover.
Ask for an update tied to files and check results. “Implemented locally, awaiting review” means something different from “released to users”. Keep that distinction in a stand-up note or project update.
Continue the same task conversation while the work remains connected. If you start a new task or return later, supply the current brief and a short handover, then ask Codex to recheck the files. Treat yesterday’s note as context that may need updating.
Use the same approach beyond coding
If you work in product or delivery, use Codex to compare agreed requirements with project documentation, prepare a test checklist or draft a stakeholder explanation from verified results. Supply the relevant files and define the output. Connections to a board or messaging tool need to be available and authorised; they are not implied by asking for a draft.
Keep decisions with the right people. Codex can highlight ambiguity in “overdue”, but the team still needs to decide what that means for its users. If you are learning to code, ask it to explain one changed function and then trace an example through it yourself.
Try it on one small task
Choose a reversible change you understand well enough to assess. Replace the dashboard rules in these prompts with your own project brief, keep the context current and reserve time to review the result.
- Before: name the outcome, relevant sources, permitted changes and evidence needed.
- During: resolve important uncertainty, inspect progress and record real check results.
- After: review the change and leave an accurate status with the next step.
At the end of the day, compare the whole experience: time spent explaining, building, correcting and reviewing. Use that evidence to decide where Codex helped and what to improve tomorrow.


