Log in

Codex operating guide · September 9, 2026

Codex Plan Mode: from a good idea to an implementation-ready plan

Use repository evidence to close the important decisions, then hand the accepted plan into implementation without losing its intent.

TM
Tony MartinsSeptember 9, 2026
13 min read
Build the plan
plan://implementation-readinessDecision gate
01
Goalframed
02
Evidenceinspected
03
Decisionslocked
04
Planaccepted
Evidence before questions · approval before implementation

Direct answer

Plan Mode creates a decision phase—not a correctness guarantee.

01Frame
02Inspect
03Decide
04Review
05Implement
06Verify

Give Codex the goal, relevant context, constraints, and observable finish line. Let it inspect the repository before asking you questions. Resolve the material decisions, review the proposal against a quality gate, then leave Plan Mode and authorize implementation separately.

01

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
02

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.

01

Plan Mode

The conversational investigation and decision phase before implementation.

Not a progress tracker or durable file by itself.
02

update_plan

A checklist that tracks task steps while ordinary execution is underway.

Not a switch into or out of Plan Mode.
03

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.

03

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.

Starting promptA minimal Plan Mode contract
/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.
01Goal

The user-visible or operational outcome.

02Relevant context

Known systems, history, and starting points.

03Constraints

Compatibility, policy, timing, and non-goals.

04Done when

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.

04

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.

Codex discovers
  • Existing abstractions and conventions
  • Call paths, schemas, and interfaces
  • Tests, configuration, and build boundaries
  • Current behavior and compatibility evidence
The user decides
  • 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.

05

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.

01

Outcome

The requested behavior is observable.

02

Evidence

Repository facts are separate from assumptions.

03

Decisions

Material choices are locked with rationale.

04

Boundaries

Interfaces, data flows, and dependencies are explicit.

05

Failure

Compatibility, migration, rollout, and rollback are handled where relevant.

06

Proof

Tests and acceptance criteria demonstrate the requested behavior.

Review promptRun before approval
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.

06

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.

Implementation handoffApproval is a separate action
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.

07

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.

Plan Mode symptom-to-correction matrix
SymptomFailed stageBounded correction
Shallow multiple-choice questionsInvestigationInspect relevant code; explain evidence and trade-offs first.
Architecture the repository does not useGroundingRequire file, symbol, and call-path evidence.
Thousands of lines of pseudo-codeSizingRequest decisions and interfaces—not implementation.
Planning repeats without convergingDecision closureAssign each open point to evidence or the user.
Implementation begins before approvalHandoffStop, restate the boundary, and inspect the diff.
A fresh chat loses key decisionsDurabilitySave context, rationale, acceptance criteria, and verification.
08

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.
09

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.

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.

Install Supercode for Codex