How to Use Codex (2026): The Delegation Loop, Not the Install Guide

TL;DR: The Skill Changed When the Tool Stopped Needing You

Codex is the first of these tools that is genuinely good at working while nobody is watching. That sounds like a feature. It is actually a change in what you have to be good at.

When an agent needs you in the loop, your skill is steering — nudging, correcting, catching it mid-mistake. When it doesn't, none of that applies. You get one shot at the instructions and one shot at the review, and everything in between happens without you. The people getting real leverage out of Codex are not better prompters. They are better at scoping work they can verify after the fact.

That is the whole guide. The rest is detail.

The Loop: Scope, Set Approvals, Run, Verify

1. Scope one task with a boundary you could say out loud. "Add rate limiting to the public API endpoints and cover it with tests" is a task. "Clean up the API" is a wish. Scope is the variable that predicts whether the diff is mergeable, and it is entirely under your control.
2. Set the approval mode to match the blast radius. This is the step most people set once and never revisit, and it is where both the speed and the accidents come from. More on it below.
3. Let it run — actually let it. Interrupting a delegated agent halfway through is how you get half-finished work with none of the benefit. If you didn't trust the scope enough to walk away, the problem was step one.
4. Verify before you merge. Run the thing. Read the diff. "The tests pass" is necessary and nowhere near sufficient, because it wrote the tests.

Habit One: Write AGENTS.md, Then Keep Pruning It

AGENTS.md in your repo root is read as standing instructions every session. It is the only place where fixing a mistake once actually stops it recurring.

What earns a line in it:

• The exact commands for your tests and your dev server, as typed.
• Conventions you genuinely enforce in review — not the ones in the style guide nobody follows.
• The traps. The thing that took production down once. The dependency that behaves nothing like its docs. This section is worth more than the other two combined and almost nobody writes it.

What ruins it is length. Once the file is long enough that a reader would skim it, you have buried your six real rules under ninety decorative ones, and the agent has no way to tell which is which. Prune it as often as you append to it.

Habit Two: Use the Cloud for the Work You'd Otherwise Not Do

The CLI runs locally, in your repo, with your commands — you watch it work. The cloud side runs tasks in its own sandbox and hands back a diff or a pull request.

Most people underuse the second one, and the reason is emotional rather than technical: watching feels like control. But delegated execution is not less control, it's deferred review — and it unlocks the category of work that otherwise never gets done. The dependency bump nobody wants to babysit. The test coverage on the module everyone avoids. The four small refactors you keep deprioritising.

Send several of those at once and review them like a morning inbox. That is the workflow that actually changes your week, and it is available to anyone already paying for it.

Habit Three: Set Approvals Per Task, Not Once

The rule I use is one sentence: automatic execution is safe in exact proportion to how easily you can undo the result.

Feature branch, clean tree, tests that fail loudly — let it off the leash, that's where the speed is. Anything touching production, deleting data, or pushing to a remote — approvals stay on, no exceptions, no matter how routine it looks. And notice what the safety net actually is: not the permission setting, which only governs what happens next. Git is what governs what you can take back.

The failure mode is picking a comfortable mode in week one and never thinking about it again. Both directions cost you — too tight and you're clicking approve on a hundred file reads, too loose and you find out what "and also I refactored the auth layer" means on a Friday.

Habit Four: Review Like It Wrote Plausible Code, Because It Did

Read the diff the way you'd read a pull request from a fast, competent, slightly overconfident junior — because functionally that is what arrived. Ask why for anything you don't recognise. Be most suspicious of the parts you would have found tedious to write yourself, since that is precisely where your attention wants to slide off.

The real risk with delegated agents was never that they write bad code. It is that they write plausible code into a codebase nobody is reading closely anymore, at a rate no one is reviewing at. If that already describes your situation — a working app whose internals nobody can vouch for — the vibe coding security checklist is a twenty-point self-audit rather than a sales page. And if you're trying to work out how much of an inherited codebase came from an agent in the first place, that's what telling whether code is AI-generated is for.

What It Costs to Run Daily

The CLI is free and open source. What you pay for is the model behind it, billed one of two ways.

Bundled: ChatGPT Plus at $20/month includes Codex credits that cover light-to-moderate daily use, and Pro at $200/month is the tier for heavy agentic work. Metered against an OpenAI API key instead: roughly $5–$15/month light, $30–$60 moderate, $80–$250 full-time.

If you already pay for Plus, Codex is included at the margin, which is the closest thing to free that exists here — the full breakdown of that question is in is Codex free, and the credit mechanics and overage traps are in Codex pricing.

Where Codex Stops Being the Right Tool

Being honest about the ceiling is what makes the rest of this worth reading.

It is strongest where the task has a hard boundary and a fast, objective check — a scoped feature, a migration you can roll back, test coverage, a mechanical refactor. It is weakest exactly where delegation is weakest generally: architecture decisions whose cost surfaces in six months, anything requiring taste about your specific users, and any change where "did this work?" cannot be answered in under a minute. Delegation needs a verification step, and where you can't build one, don't delegate.

If you'd rather stay in the loop and steer line by line, a different shape of tool fits better — the honest three-way comparison is Cursor vs Claude Code vs Codex, and the equivalent working loop for the terminal-agent alternative is how to use Claude Code.

The Micro-Action

Before you close this tab: find one task you have been deprioritising for a month because it's tedious rather than hard — the dependency bump, the missing tests, the rename you keep flinching at. Scope it in two sentences, put it on a branch, and delegate it. Then review what comes back. Whether you merge it or bin it, you'll have learned the only thing that actually matters here, which is how good your scoping is.