The decision
Use Plan Mode when a wrong assumption is expensive
Planning earns its cost when the work crosses boundaries or the requested outcome is not yet implementation-ready.
OpenAI recommends Plan Mode for complex, ambiguous, or difficult-to-describe work. In the current Codex CLI, /plan switches the active chat into Plan Mode and can carry an inline request. It is temporarily unavailable while Codex is already working. See the current command reference.
Use it
The task changes a system
- Multiple subsystems or owners
- Interface or data-model changes
- Migration, rollout, or compatibility choices
- Meaningful product or architecture ambiguity
Skip it
The next move is already bounded
- One obvious change boundary
- No unresolved behavior decision
- Known verification command
- Low cost to inspect and correct directly
The vocabulary
Three planning tools, three different jobs
Search results and team conversations often collapse these concepts into one. Keeping them separate makes the implementation handoff much easier to reason about.
Plan Mode
The conversational investigation and decision phase before implementation.
Not a progress tracker or durable file by itself.update_plan
A checklist that tracks task steps while ordinary execution is underway.
Not a switch into or out of Plan Mode.PLANS.md / ExecPlan
An optional living implementation document for work that must survive context boundaries.
Not required for every Plan Mode request.The archived OpenAI ExecPlan guide remains useful for the principle of a self-contained, living plan. Its older model recommendations should not be treated as current Codex guidance.
The input
Start with four signals, not a miniature specification
A useful starting request gives the investigation a destination without pretending you already know the implementation.
/plan Goal: Relevant context: Constraints and non-goals: Done when: Inspect the repository before asking questions. Resolve discoverable facts yourself. Ask me only about product intent or implementation trade-offs that materially change the plan. Do not finalize until the plan is decision-complete.
The user-visible or operational outcome.
Known systems, history, and starting points.
Compatibility, policy, timing, and non-goals.
Observable evidence that the work is complete.
This is a useful default derived from OpenAI’s current Codex best-practices guide, not a required schema. Its job is to make the destination testable.
The investigation
Repository facts come before user decisions
The current open-source Plan Mode contract directs Codex to investigate with non-mutating tools, resolve discoverable facts itself, and ask the user about intent or trade-offs that materially change the plan. That creates a useful ownership split.
- Existing abstractions and conventions
- Call paths, schemas, and interfaces
- Tests, configuration, and build boundaries
- Current behavior and compatibility evidence
- Product behavior and acceptable trade-offs
- Compatibility and migration appetite
- Rollout risk and operational policy
- Choices with no objective repository answer
“Which option do you want?” is weak when the options arrive without evidence. A useful decision prompt explains what Codex found, why the choice remains open, and what each option changes.
The quality gate
Review decisions, not plan length
A long plan can still be speculative. A short plan can be complete. Approve the proposal only when these six gates have defensible answers.
Outcome
The requested behavior is observable.
Evidence
Repository facts are separate from assumptions.
Decisions
Material choices are locked with rationale.
Boundaries
Interfaces, data flows, and dependencies are explicit.
Failure
Compatibility, migration, rollout, and rollback are handled where relevant.
Proof
Tests and acceptance criteria demonstrate the requested behavior.
Audit this proposed plan before I approve it. Find unsupported assumptions, unresolved decisions, omitted interfaces or data flows, missing compatibility, migration, rollback, failure, or observability concerns, weak tests or acceptance criteria, and steps that are too broad, duplicated, or code-heavy. Inspect the repository to resolve discoverable gaps. Ask me only for decisions I own. Then return a revised decision-complete plan.
This six-part gate is Supercode’s compact editorial synthesis of the current Plan Mode contract and durable execution-plan guidance. It is not an official Codex checklist and cannot guarantee a correct implementation.
A plan is ready when another executor can follow it without silently inventing the missing decisions.
The handoff
Choose continuity over same-chat dogma
Continue here
Stay in the same chat
Use one chat when implementation is a coherent continuation and the inspected context remains useful.
Persist it
Create a durable plan
Use a repository artifact when work spans chats, executors, milestones, or context compaction.
The plan is approved. Leave Plan Mode and implement it in the stated order. Track execution progress separately. Run the listed verification after each meaningful stage, and stop if repository evidence invalidates an accepted assumption.
During execution, a progress checklist can track pending, active, and completed steps. It does not replace the accepted plan. If repository evidence invalidates a decision, update the plan deliberately instead of allowing silent drift.
The corrections
Fix the failed stage instead of restarting everything
Public Codex issue reports show that shallow questions, plan bloat, transition friction, and an unexpected edit have all been experienced by individual users. They motivate bounded guardrails; they do not establish prevalence or reproduce every current version.
| Symptom | Failed stage | Bounded correction |
|---|---|---|
| Shallow multiple-choice questions | Investigation | Inspect relevant code; explain evidence and trade-offs first. |
| Architecture the repository does not use | Grounding | Require file, symbol, and call-path evidence. |
| Thousands of lines of pseudo-code | Sizing | Request decisions and interfaces—not implementation. |
| Planning repeats without converging | Decision closure | Assign each open point to evidence or the user. |
| Implementation begins before approval | Handoff | Stop, restate the boundary, and inspect the diff. |
| A fresh chat loses key decisions | Durability | Save context, rationale, acceptance criteria, and verification. |
The durable path
When the plan must outlive the chat
Native Plan Mode is enough for a bounded task that moves directly into implementation. When the plan must become repository knowledge, Supercode Specs & Docs provides a guided “Create implementation plan” workflow grounded in repository sources.
Specs & Docs
Turn the accepted direction into repository knowledge
- Start from a new Codex draft or an existing thread.
- Ground the plan in repository sources.
- Propose small, verifiable vertical steps.
- Approve before the canonical plan is written.
- Authorize product-code changes separately.
The preflight
Approve only what implementation can prove
- The outcome can be observed or tested.
- Repository findings and assumptions are visibly different.
- Material decisions include rationale.
- Interfaces, dependencies, and change boundaries are explicit.
- Failure, compatibility, migration, rollout, and rollback are covered where relevant.
- Verification commands and acceptance criteria prove the requested behavior.
- The implementation handoff is explicit.
- Durable context exists if another chat or executor will continue the work.
If a material answer is no, the plan remains in review.
Evidence boundary
Sources and version notes
Reviewed September 9, 2026 against current first-party documentation and implementation sources. Codex behavior is version-sensitive; public issue reports are used only as directional evidence of failure modes.
- OpenAI — Codex best practices
- OpenAI — Codex CLI developer commands
- OpenAI Codex — current Plan Mode template
- OpenAI Codex — update_plan tool specification
- OpenAI — Codex configuration reference
- OpenAI Cookbook — archived execution plans guide
- Codex issue #18611 — context in Plan Mode questions
- Codex issue #34659 — oversized code-heavy plans
- Codex issue #32594 — reported write during Plan Mode
A durable next step
Keep the plan available after the planning chat ends
Add the guided Specs & Docs workflow when an accepted plan needs to become durable repository knowledge.

