Lesson 1: Meet Codex: Its Forms, Plans and Beta Labels

Before we start

This course is independent. OpenAI did not write, review or endorse it, and none of its documentation is copied here. Codex changes almost every month, so treat each lesson as a guide to where to look and check commands, plan details and labels against OpenAI's current docs. Those docs now live at learn.chatgpt.com. The old developers.openai.com/codex links redirect there.

Think of Codex as one coding agent that you can reach through several doors. The agent works the same way behind each one. What changes is where the code runs, how closely you watch it, and how the result gets back to you. If you pick the wrong door, you spend the afternoon fighting your tools.

The forms of Codex

Here's an analogy. The CLI and the IDE extension are a colleague sitting at your desk, using your checkout. Codex cloud is a contractor working in their own office from a fresh clone, who sends you a pull request when they're done.

Gotcha: Local and cloud forms see different things. A cloud task only sees what is pushed to the connected repository and whatever its environment setup installs. Your uncommitted changes and local .env files never reach it. Most "it works locally but Codex can't build it" surprises come from this.

How it compares with alternatives: Claude Code (Anthropic) is the closest match to the Codex CLI, a terminal agent working in your own repo. Cursor is a whole AI-first editor, and the Codex extension can run inside it. You don't have to choose only one. Plenty of teams use an editor agent for small edits and a cloud agent for background work.

Which plan includes which form

Codex comes with ChatGPT plans: Free, Go, Plus, Pro, Business, Edu and Enterprise. Not every plan includes every form. When this was written, OpenAI's pricing page showed roughly this:

Surface         Free/Go               Plus, Pro, Business, Enterprise
-------------   -------------------   -------------------------------
Desktop app     yes (subject to       yes
                rollout)
CLI             no                    yes
IDE extension   no                    yes
Web / cloud     no                    yes
Code review     no                    yes

You can also sign in with an API key instead of a ChatGPT account. In that case usage is billed at standard API rates instead of counting against your plan's included limits, and cloud features such as the GitHub integration are not available.

Best practice: Don't trust this table, or any blog post, for your own plan. Open the pricing page on learn.chatgpt.com and read the row for your plan before you budget time or money. Plan details change without much notice.

Reading the maturity labels

OpenAI marks Codex features with a maturity stage. Learn these stages, because they tell you how much to rely on a feature:

Under development -> Experimental -> Beta -> Stable   (and later, Deprecated)
     don't use      may change or    fine for pilots;  fine for production;
                    vanish; your     expect small      removals go through
                    own risk         changes           deprecation

In practice:

• Experimental: use it on a scratch branch and never let a team workflow depend on it.
• Beta: use it in pilots, and pin down what you rely on, because flags and config keys may still be renamed.
• Stable: safe to build a team process around.
• Deprecated: it still works so old setups don't break, but don't use it in anything new.

Whenever a lesson in this course touches a feature, check its label in the docs that day. Some integrations, such as GitLab support and certain plugins, have carried Beta labels, and labels move as features mature.

Hands-on: set up the practice repository

Every lesson ends with a task on the same small repo. Build it now. Use bash, Git Bash or WSL; on Windows PowerShell, create the same files by hand. You need Git, Python 3.10+ and pytest (pip install pytest).

mkdir codex-practice && cd codex-practice
git init                       # Codex works best in a git repo: every change becomes a diff
mkdir textstats tests

# A tiny module with room to grow in later lessons
cat > textstats/__init__.py <<'EOF'
def word_count(text: str) -> int:
    """Count whitespace-separated words."""
    return len(text.split())
EOF

# Tests give Codex (and you) an objective pass/fail signal
cat > tests/test_textstats.py <<'EOF'
from textstats import word_count

def test_simple():
    assert word_count("hello codex world") == 3

def test_empty():
    assert word_count("") == 0
EOF

touch tests/__init__.py
printf '.venv/\n__pycache__/\n.env\n' > .gitignore   # keep secrets and clutter out from day one

python -m pytest -q            # expect: 2 passed
git add -A && git commit -m "Baseline: textstats with tests"

Why commit a clean baseline? Every later lesson asks Codex to change this repo, and you'll judge the result with git diff against a known-good starting point. If you have no baseline, you can't tell what the agent did.

Your task

Add a file called PLAN.md to the repo. In it, write your ChatGPT plan, which Codex forms it includes (taken from the current pricing page, not from this lesson), and one feature you found labelled Beta or Experimental. Then commit it.

Check your result

python -m pytest -q   # still 2 passed
git log --oneline     # two commits: baseline + PLAN.md
git status            # "nothing to commit, working tree clean"

Key takeaways

• Codex is one agent with several forms: the CLI, the IDE extension, the ChatGPT desktop app (which absorbed the old Codex app), ChatGPT web and mobile, Codex cloud, and GitHub code review.
• Local forms work on your checkout. Cloud tasks work on a fresh clone in a sandbox and only see what you've pushed.
• All ChatGPT plans include some Codex access, but Free and Go are limited (currently the desktop app, subject to rollout). The CLI, IDE extension, cloud and code review need Plus or higher. Always check the live pricing page.
• Signing in with an API key means paying API rates, and you lose cloud features like the GitHub integration.
• Maturity labels go Under development → Experimental → Beta → Stable, with Deprecated at the end. Build team processes only on Stable features.
• Your practice repo needs a clean, tested git baseline before you delegate anything.