How to Use OpenAI Codex: A Developer's Guide [2026]

Per Harald Borgen -

For about a decade, AI in the editor meant autocomplete. You started a line, the tool guessed the rest, and you stayed in the driver's seat for every keystroke. OpenAI Codex asks for something different. You hand it a whole task, it goes off and writes, runs, and revises the code, and then you review what comes back. The work that used to be typing becomes two other things: describing the task clearly enough for an agent to execute, and reading the result closely enough to trust it.

Codex is also no longer one tool. In 2026 it is a family of surfaces that share a single account: a terminal CLI, an editor extension, a cloud agent that opens pull requests, and a GitHub bot you summon with a mention. Most developers have heard the name. Far fewer have actually run it.

This guide walks through all of it in plain language: what Codex is, what it can and cannot do, how each surface works, a real first-task walkthrough in the CLI, and the skills that decide whether its output is safe to ship. If you only take one thing away, take this: Codex changes where your effort goes, not whether your judgment matters.

What Is OpenAI Codex?

OpenAI Codex is OpenAI's coding agent for software development. It plans and runs multi-step coding tasks - writing, reading, reviewing, and debugging code - across the terminal, your editor, the cloud, and GitHub.

OpenAI describes it plainly: Codex is "OpenAI's coding agent for software development". The word that matters is agent. A traditional assistant responds once - you ask, it suggests, you decide. An agent works in a loop: it breaks a goal into steps, takes an action, looks at the result, and keeps going until the task is done or it gets stuck. For a deeper look at that loop and how the wider field works, see What Is Agentic Coding?.

Codex is included with paid ChatGPT plans - Plus, Pro, Business, Edu, and Enterprise - so if you already pay for ChatGPT, you likely already have access (OpenAI).

What Can Codex Do?

Codex can write code, read and explain unfamiliar codebases, review code for bugs, debug and fix problems, and automate routine development tasks like refactoring and testing.

Those five capabilities are the ones OpenAI names for the tool (OpenAI).

In practice, that breaks into two buckets. Codex is strong at well-scoped, multi-step work: scaffolding a feature, applying the same change across many files, writing a first pass of tests, or tracing a bug through code you have never read. It is weaker, and riskier, the moment a task is vague or the stakes are high.

The data backs up the caution. Among developers who use AI agents, 70.7% say agents reduced the time they spend on tasks, per the 2025 Stack Overflow Developer Survey. In that same survey, only 32.7% said they trust the accuracy of AI output. Codex can do a lot of the work. Deciding whether the work is correct is still your job.

How to Use OpenAI Codex: The Four Surfaces

Codex runs in four main places, and the right one depends on how much you want to watch the agent work versus hand it a task and walk away.

Surface Where it runs How you hand off work Best for
CLI Your terminal Run codex, type a task, approve actions Local, hands-on work where you watch each step
IDE extension VS Code or JetBrains A side-panel agent that reads your open files Staying in your editor while delegating tasks
Cloud A remote sandbox Describe a task; it returns a pull request Background work you review later, not in real time
GitHub Your repository Tag @codex on an issue or pull request Turning issues into proposed changes

The CLI is the most direct surface. Described in its repository as a "lightweight coding agent that runs in your terminal", it reads your repo, runs commands, and edits files in place while you watch.

The IDE extension brings the same agent into VS Code or JetBrains editors, where a side-panel agent can take your open buffers as context (OpenAI). The surfaces share one account, so you can start a task in the editor and hand it off to the cloud to finish.

The cloud agent works on its own in a remote environment and hands back a proposed change rather than editing your local files (OpenAI). And from GitHub, you can tag @codex on an issue or pull request to kick off work without leaving the repository (OpenAI).

How Do You Get Started With the Codex CLI?

To start with the Codex CLI, install it, sign in with your ChatGPT account or an API key, open a project, and run codex to launch the agent in your terminal.

The CLI is the best place to learn how Codex behaves, because you see every action before it happens. Here is the path from nothing to a first task.

  1. Install it. The quickest route is npm install -g @openai/codex. The CLI also ships via Homebrew (brew install --cask codex) and a standalone install script, with platform binaries on GitHub Releases (openai/codex).
  2. Authenticate. The first time you run codex, you sign in with either your ChatGPT account or an API key (OpenAI). The paid ChatGPT plans include Codex access, so most people use the account login.
  3. Open a project and run it. From a project's root, run codex. It launches an interactive terminal interface, inspects your repository, and works within the directory you point it at.
  4. Pick an approval mode. Before Codex changes files or runs commands, you "choose the approval mode that matches your comfort level". The CLI is sandboxed to your selected directory and respects that setting, so you can review actions before they run. New to the tool? Start in a mode that asks before acting, and loosen it only once you trust the pattern.
  5. Give it a bounded task, then read the diff. A good first task is small and specific: "add input validation to the signup form and a test for it" beats "improve the app." When Codex proposes changes, read the diff before you accept it. This is the step that separates a useful agent from a risky one.
  6. Steer it with an AGENTS.md (optional). For repeatable behavior, an AGENTS.md file lets you customize how Codex works in your project (OpenAI), so you are not re-explaining your conventions every session.

The commands are short, but the habit is the point: delegate a clear task, watch what the agent does, and own the review.

How Does the Codex Cloud Agent Work?

The Codex cloud agent runs a task in an isolated remote environment where it can read, edit, and run code, then opens a pull request you review before merging.

This is the surface for work you do not want to babysit. You connect your GitHub account, describe a task, and Codex spins up a cloud sandbox where it can "read, edit, and run code" against your repository. You can start a cloud task from the web interface, from your IDE, or by tagging @codex on a GitHub issue or pull request.

When it finishes, Codex can "create pull requests from its work", and when you delegate from your editor you can monitor progress and apply the resulting diffs locally. You also control the environment - which repository, which setup steps, and whether the agent has internet access during a run. The appeal is parallelism: the agent handles background work while you stay focused on review and integration. The catch is the same as everywhere else - a pull request that looks finished is not the same as one that is correct.

When Should You Use Codex, and When Not?

Use Codex for well-scoped, repetitive, or exploratory work; be cautious with load-bearing code where a plausible-but-wrong change can ship quietly.

The sweet spot is work that is tedious but low-stakes: boilerplate, scaffolding a component, applying a rename across a dozen files, writing test stubs, or making an exploratory change you are happy to throw away. Here, an agent that is occasionally wrong costs you a quick correction, not a production incident.

The danger zone is anything load-bearing.

An agent can produce code that runs, passes a glance, and is still wrong - a subtle auth gap, a misread requirement, a query that works on ten rows and falls over on ten million. The agent will not flag its own blind spots. You will.

Authentication, data handling, payments, and performance are exactly the places where a confident-but-wrong change does the most damage and is the hardest to spot. Codex can absolutely help there too. It just means the bottleneck moves from writing the code to reviewing it, which leads to the skills that make all of this work.

What Skills Do You Need to Use Codex Well?

Using Codex well depends on two skills it cannot do for you: writing a clear, bounded task spec, and reviewing the code it returns. Both are reading-and-judgment skills, and both get sharper with practice.

A vague task produces a vague pull request. A clear one - "paginate the orders endpoint, 20 per page, with a test" - gives the agent something it can actually execute and you something you can actually check. And no matter how good the spec, you still have to read the result. An agent that hands you a 300-line diff is only useful if you can tell good from bad inside it. Adoption is still early - 84% of developers use or plan to use AI tools, but only about 23% use agents weekly - which means the developers who get fluent at directing and reviewing agents now are building a genuinely scarce skill.

This is where passive learning falls short and interactive learning pays off. Watching a tutorial teaches you to recognize code; editing code teaches you to judge it. Scrimba's scrim format is built on that difference - you pause a screencast and change the instructor's code in the browser instead of watching it scroll past - which is the same read-and-correct muscle Codex asks of you on every diff.

A sensible way to build that foundation:

  • Start with the language an agent will most often write for you. The free Learn JavaScript course (9.4 hours, built with Mozilla's MDN) covers the fundamentals you need to read and review web code. Complete beginners who want to build with AI help from day one can start with the free Learn to Code with AI course, which teaches HTML, CSS, and JavaScript while using AI to generate and debug code.
  • Learn to use generative AI to write and debug code. No course anywhere is named for Codex, and you should be wary of any site that claims one. The closest current course is Scrimba's "AI for Web Developers" specialization on Coursera, which teaches using generative AI - including Anthropic's Claude - to write, document, and debug code.
  • Then learn to build AI-powered apps yourself. Scrimba's AI Engineer Path (Pro) covers agents, RAG, context engineering, and the Model Context Protocol, and the "AI Engineering" specialization on Coursera covers building agents that use tools and interact with APIs.

For the tool-by-tool view, Claude Code vs Codex vs Cursor compares the leading agents head to head, and How Web Developers Can Use AI zooms out to the broader workflow.

Frequently Asked Questions

Is OpenAI Codex free?

Codex is included with paid ChatGPT plans - Plus, Pro, Business, Edu, and Enterprise - rather than sold separately. If you already subscribe to ChatGPT on one of those plans, you have Codex access. You can also authenticate the CLI with an OpenAI API key instead of a ChatGPT account.

Is Codex the same as GitHub Copilot?

No. Codex is OpenAI's own coding agent, available across a terminal CLI, an IDE extension, the cloud, and GitHub. GitHub Copilot is a separate product from GitHub. Both can write and edit code, but they are different tools from different companies with different surfaces and workflows.

Do I need to know how to code to use Codex?

You can start without knowing how to code, but you cannot ship safely without it. Codex writes and runs code, yet you still decide whether its output is correct. Reviewing a diff, catching a bug, and redirecting the agent all require reading code, which is why the fundamentals still matter.

Does Codex write the code for you or just suggest it?

It does the work, not just the suggesting. Given a bounded task, Codex edits files, runs commands, and in the cloud opens a pull request with its changes. Your role shifts from typing each line to specifying the task and reviewing what the agent returns before it merges.

Key Takeaways

  • OpenAI Codex is OpenAI's coding agent for software development, running multi-step tasks across the terminal, your IDE, the cloud, and GitHub.
  • It does five core things: write code, understand unfamiliar codebases, review code, debug and fix problems, and automate development tasks.
  • The CLI quickstart is short: npm install -g @openai/codex, sign in with a ChatGPT account or API key, run codex, pick an approval mode, then review the diff.
  • The cloud agent works in an isolated remote environment and returns a pull request you review before merging.
  • Codex shines on boilerplate, cross-file edits, and tests; be cautious with auth, data, payments, and performance, where wrong-but-confident changes ship quietly.
  • Using Codex well comes down to two skills it cannot do for you: writing a clear task spec and reviewing the result.
  • No course is named for Codex; the closest current learning is Scrimba's "AI for Web Developers" specialization on Coursera, with foundations via free courses like Learn JavaScript.

Codex moves more of the typing to the machine and more of the value to the developer who can direct it and check its work. The fastest way to become that developer has not changed: learn the fundamentals by doing, get fluent at reading code, and let the agent handle the parts you could already do in your sleep.

Sources