Part of the Codex mini-series and the broader Claude Code workflow series. If you've run through the install primer, all three of these CLIs are on your machine. This post is about knowing which to reach for when.
The install primer ends with four CLIs on your PATH: Claude Code, Codex, ChatGPT CLI, and GitHub Copilot CLI. Three of them are associated with "GPT-like" tooling and they sound similar enough that people routinely confuse their roles. They shouldn't — they do barely-overlapping jobs.
The three-minute positioning:
- Codex CLI — OpenAI's agentic coding tool. Reads / writes files, runs shell commands (with approval), plans and executes multi-step tasks. The OpenAI-ecosystem equivalent of Claude Code.
- ChatGPT CLI — OpenAI's terminal-friendly chat interface. One-shot or multi-turn conversations with a GPT model, without the agentic file/shell access. Think "ChatGPT, in your terminal, for quick questions."
- GitHub Copilot CLI — a separate tool under GitHub that suggests shell commands from natural-language descriptions. Model-agnostic from the user's perspective; it's a shell-command translator, not a general agent.
Different jobs. Different trade-offs. Different times to reach for each.
Codex CLI — the agentic one
What it does: acts on your repo. Reads files, writes files, runs commands, plans refactors, iterates on tests until they pass. If Claude Code is on the GPT side of the aisle, Codex is it.
When to use it:
- You're about to do a task that touches multiple files.
- You want the CLI to execute steps, not just suggest them.
- You want a session with back-and-forth iteration.
- You want OpenAI model reasoning inside the same agentic harness that Claude Code exposes for Claude models.
When not to use it:
- You just want a one-shot question answered. ChatGPT CLI is lighter-weight.
- You just want a shell command suggested. Copilot CLI is faster.
- You're doing long multi-hour agentic work. Claude Code's harness is meaningfully more tuned for that today.
Mental model: Codex is in the same product category as Claude Code. They compete head-to-head. Your CLI muscle memory transfers between them with minor adjustments (see prompt style differences).
ChatGPT CLI — the conversation one
What it does: exposes the same chat interface you'd get at chatgpt.com, but in your terminal. No file-editing by default. No shell-command execution. Conversational.
When to use it:
- "What does the
ORDER BY ... NULLS LASTclause do in PostgreSQL again?" — one-shot lookup. - "Explain this stack trace to me" — paste, get explanation, move on.
- "Draft three alternative phrasings for this error message" — creative riffs.
- "I need to think through a design decision. Let's chat about the trade-offs." — genuine conversation without needing repo access.
When not to use it:
- You want the model to actually change your code. Use Codex (or Claude Code).
- You want shell commands executed. Use Copilot CLI for suggestions or Codex/Claude Code for execution.
- You want long coherent planning across many turns. Both Codex and Claude Code handle this better because they can actually act on the conversation.
Mental model: ChatGPT CLI is a quick-reference chat window that happens to live in your terminal. The GPT model family is the same as what Codex uses; the difference is the harness around it.
Why it exists separately from Codex: some tasks don't need agentic execution and don't benefit from the agentic framing. "Explain Kubernetes StatefulSets" is a conversational query, not an agentic task. ChatGPT CLI is the right tool for that; launching Codex for it is like using a forklift to move a single box.
GitHub Copilot CLI — the shell-command translator
What it does: you describe what you want in natural language; it produces the shell command that does it. That's essentially the whole product.
$ gh copilot suggest "find all files modified in the last week under src/ that contain 'deprecated'"
find src/ -type f -mtime -7 -exec grep -l 'deprecated' {} +
Run the suggested command? [y/n]
When to use it:
- You know what you want to do but not the specific
find/awk/sed/jq/rsync/git/dockerincantation. - You're doing shell pipeline work and want the command rather than a full agent session.
- You're a front-end developer who doesn't live in the terminal daily and values knowing the incantation over memorizing it.
When not to use it:
- The task is genuinely agentic (multi-step, multi-file, needs the agent to make decisions as it goes). Copilot CLI gives you a command, not a workflow.
- You want the agent to both suggest and execute with observation. Copilot CLI suggests; it doesn't observe the output and adapt. Claude Code or Codex for that loop.
Mental model: Copilot CLI is gh copilot suggest as its primary function. Fast, narrow, useful. Model is GitHub/Microsoft-managed; from your perspective it's a shell-translation service.
Why it exists alongside Codex and Claude Code: the positioning is "command suggestion, not task execution." Simpler, faster, lower-overhead for that specific workflow. A senior engineer who writes find/awk from muscle memory doesn't need it. A productive developer who doesn't live in zsh daily uses it 10 times a day.
Overlap clarifications — the places people confuse them
Q: Aren't Codex CLI and ChatGPT CLI the same thing, since they use the same underlying model?
No. They use the same model family, but the harness around the model is completely different. Codex has tools (file read/write, shell execute), agentic iteration, and session state. ChatGPT CLI has conversation and that's it. You can't ask ChatGPT CLI to modify a file; you can't ask Codex to just chat without any agentic intent.
Q: Is Copilot CLI just a subset of Codex?
No. Copilot CLI is a GitHub product with a different model stack (historically OpenAI-based but now potentially multi-provider), a different positioning, and a fundamentally different interaction pattern. Copilot CLI is one-shot command suggestion; Codex is a multi-turn agent.
Q: If I have Claude Code, do I still need Codex?
Depends. Claude Code covers most agentic workflows. If your tasks benefit from GPT-family reasoning (see prompt-style differences) or if you want to use OpenAI-native integrations (Assistants API, embeddings), keep Codex installed. If you never reach for it in the first two weeks, you probably don't need it.
Q: If I have Codex, do I still need ChatGPT CLI?
Often yes. ChatGPT CLI is faster and lighter for one-shot questions. Using Codex for "explain regex lookbehind" is overkill and slower than asking ChatGPT CLI. The two coexist.
Q: Does GitHub Copilot CLI compete with Claude Code?
No. They do different jobs. Copilot CLI suggests one shell command; Claude Code runs multi-step agentic tasks. Not competing; orthogonal.
The decision guide in practice
A new task lands. You're at your terminal. Which do you reach for?
- Task is "explain / look up / answer a question / brainstorm" and doesn't need repo access: → ChatGPT CLI.
- Task is "give me the shell command for X": → GitHub Copilot CLI.
- Task is "change files / implement a feature / debug across the codebase": → Claude Code or Codex (pick based on the comparison post).
- Task is "help me think through this architecture": → Could be any of them, but ChatGPT CLI or Codex's o-series reasoning are usually the fit. Claude Code is overkill for pure architectural brainstorming that doesn't yet need to touch files.
After a week the muscle memory is automatic.
Alias setup
If you don't want to remember which binary is which, alias them to intent-names:
# ~/.zshrc
alias ask='chatgpt' # quick questions, conversation
alias shellcmd='gh copilot suggest' # shell command suggestion
alias code-agent='claude' # Claude Code for long agentic work
alias code-fast='codex' # Codex for short agentic work
ask "what's a Kubernetes StatefulSet" — ChatGPT CLI.
shellcmd "find all .log files over 100MB" — Copilot CLI.
code-agent — open Claude Code for real work.
code-fast — open Codex for a quick focused task.
After two weeks your hands know which is which.
Related reading
- AI Terminal Kickstart — install all four CLIs.
- Codex CLI after install — Codex-specific habits.
- Codex vs Claude Code — the deeper comparison between the two agentic CLIs.
- Two-CLI workflow — running both Codex and Claude Code in parallel.
- Multi-model routing — the overarching "use different tools for different jobs" framing.
Fact-check notes and sources
- OpenAI: ChatGPT + API platform docs, Codex product page.
- GitHub: GitHub Copilot CLI documentation — canonical reference for Copilot CLI.
- Anthropic: Claude Code documentation — for contextual comparison.
- Augment Code: Google Antigravity vs Claude Code — adjacent comparison of the broader agentic-CLI landscape.
Informational, not engineering consulting advice. CLI command names, product positioning, and feature sets evolve quickly; specific flag syntax may change between releases. Verify against current vendor docs before depending on any specific command. Mentions of OpenAI, GitHub / Microsoft, Anthropic, and linked publications are nominative fair use. No affiliation is implied.
