For Coding, Should You Use Codex, Claude Code or GitHub Copilot?

Geoffrey Chen

Choosing the Right AI Tool · Article Five

A few years ago, comparing coding AI was relatively simple: which tool provided faster, more relevant completion beside the current file? The question has changed. AI can now read a repository, propose an implementation plan, run commands and tests, alter many files together and eventually return a branch or pull request for review.

Codex, Claude Code and GitHub Copilot all participate in this kind of work, but they do not occupy three identical positions. Codex and Claude Code are readily understood as coding agents that act within projects and terminal environments. GitHub Copilot has expanded from IDE completion into chat, code review, IDE agents and a cloud agent on GitHub. GitHub can now also host third-party coding agents from Codex and Claude.

“Which one of the three?” is consequently sometimes the wrong question. A developer may use Copilot for continuous completion and delegate a bounded refactor to Codex. A GitHub issue might be assigned to a Claude agent from inside the same repository workflow. Models, agents and the platforms that carry their work are overlapping. A more stable question is where the work should occur and how a person intends to supervise the changes.

Begin with the location of work

Programming is not one activity. Writing the next line, understanding an unfamiliar repository, changing an interface across twenty files, repairing a CI failure and reviewing a pull request demand different context and control.

Location of work Relationship between person and AI Tasks that fit naturally
Beside the cursor The person keeps writing while AI predicts a continuation or next edit Small implementations, repetitive forms and everyday flow in familiar code
IDE or terminal session The person states a goal; the agent reads files, runs commands and iterates Debugging, refactoring, testing and understanding a local project
Separate worktree or cloud environment The agent completes a longer task in isolation; the person reviews later Delegable features, migrations and parallel exploration
GitHub issues and pull requests Assignment, change, discussion and review stay within repository records Team collaboration, asynchronous work, CI repair and governance

Skipping this layer produces poor comparisons. The response speed of completion is used to judge a long-running agent, or one impressive autonomous feature is allowed to erase the cumulative value of hundreds of small suggestions in a normal day.

Codex: managing whole tasks and reviewable file changes

Codex can currently be used through ChatGPT desktop, an IDE, the CLI and cloud environments. Official documentation describes a coding agent that can understand codebases, build and test features, fix problems and review changes. The desktop environment supports multiple tasks, Git worktrees, local or cloud execution, an integrated terminal and review of diffs.

The value of a worktree is not simply the ability to open more chats. Different agents can explore isolated working copies of the same repository without competing for the active directory. One can investigate a test failure while another prepares documentation or tries a different implementation. Parallel work pays off when tasks can genuinely be separated. If two tasks depend on the same unresolved architectural decision, starting them together merely produces incompatible assumptions sooner.

Codex’s AGENTS.md mechanism lets a repository store build commands, directory conventions, testing expectations and working agreements, applying them through the directory hierarchy. Repeated explanations become part of the project. These are behavioural instructions, however, not security enforcement. Files that must remain inaccessible, commands that require approval and network permissions belong in sandbox and policy controls.

Codex fits work whose outcome can be expressed as changes to actual files: repair a reproducible defect, add a feature with acceptance criteria, migrate an API, update a structurally consistent collection or review an existing diff. It can run tests and show changes, but “tests pass” means only that covered behaviours did not fail. Interpretation of requirements, architectural cost, security boundaries and missing tests still require human judgement.

For a person whose dominant need is very short completion while typing, a full agent may feel heavy. Codex’s distinct value is easier to see in task-level changes, file management, parallel delegation and visible review.

Claude Code: when the terminal is the main workbench

Claude Code enters a project from the current directory and can access files, the terminal, Git state and project instructions. It can use build tools and other commands. Although terminal-centred, it is also available through environments such as VS Code and JetBrains. For developers who already organise work around a shell, editor and Git, the entry point is direct.

Claude Code uses CLAUDE.md for project instructions and can extend its working environment with rules, skills, MCP, hooks and subagents. It also has automatic memory that can carry some project patterns and user corrections into later sessions. The convenience is clear, and so is the risk: automatically retained “experience” can become stale. Architecture and test requirements that matter to a team should live in reviewable project files rather than solely in a tool’s personal memory.

Checkpointing records changes made through Claude’s file-editing tools and allows the user to return to an earlier state. An important qualification is that file changes created directly by some shell commands may not be covered by the same mechanism. Git remains the fuller project history. Tool-level rewind cannot replace small commits, branches and review.

Claude Code permissions can distinguish reading, shell execution and file modification, with allow, ask and deny rules. As with any agent that can run terminal commands, permissions should not be expanded to the maximum merely to remove prompts. Dependency installation, network access, production environments, secrets and data migration warrant different boundaries. The product is not simply a chat that writes code; it is a system permitted to act on a computer.

When a workflow is terminal-first and the desired agent should reason continuously across local Git state, command-line tools and code, Claude Code deserves an early trial. The trial should use the developer’s languages, frameworks, repository size and actual assignments. Vendor benchmark numbers do not guarantee a fit with the peculiarities of one project.

GitHub Copilot: when development already revolves around GitHub

The old picture of GitHub Copilot is now incomplete. It still provides inline suggestions and next-edit predictions in supported IDEs, helping a developer who remains at the cursor. Copilot Chat can explain and discuss code. IDE agent mode can choose files, propose terminal commands and iterate. On GitHub, the cloud agent can research a repository, plan a change, work on a branch and produce a pull request for review.

Copilot therefore increasingly functions as a development workflow layer. An assignment can begin as an issue. Changes enter a branch. A CI failure can be addressed in the same record. Discussion stays with the pull request. For organisations, accounts, repository permissions, policy and audit are in a familiar GitHub environment. Its suitability cannot be reduced to the code-writing quality of one underlying model.

The more consequential change is GitHub’s support for third-party coding agents. Paid Copilot plans can use Claude and OpenAI Codex agents on GitHub. An issue or prompt can be assigned to an agent that creates or updates a pull request. GitHub also runs checks such as secret scanning, dependency security validation and CodeQL over agent changes. These controls catch some known problems. They do not replace human review or the repository’s own tests.

“Copilot or Codex?” is therefore no longer always an exclusive subscription question. Copilot may be the GitHub surface through which a Codex task is run. The meaningful comparison is between using Codex independently and using an agent through GitHub, including differences in permissions, usage accounting, model selection, logs and team collaboration.

Copilot’s breadth also brings complexity. Features may differ in maturity, and individual and organisational plans have different allowances, policies and model availability. Cloud agents can consume AI credits and GitHub Actions minutes. A plan saying that an agent is included does not by itself reveal the cost of sustained use.

Testing code quality on work that matters

Public benchmarks can show performance over defined task sets. A private repository contains another reality: incomplete documentation, compatibility history, special build conditions, tacit business rules and missing tests. The most informative personal comparison uses three repository tasks rather than one algorithm puzzle.

The first should be a small genuine bug with reproduction steps and a regression test. The second should be a refactor across several files with no intended behavioural change. The third should ask the system to explain an unfamiliar module and propose a plan while explicitly forbidding modification. Together they examine diagnosis, execution and understanding.

Fix the repository commit, environment and acceptance commands before beginning. Give each tool the same goal and permission boundary while allowing its native workflow. Record more than whether tests pass. Consider the size of the diff, irrelevant changes, failed attempts, number of human interventions, usage cost and the time required to review the result.

Repeat at least once. On the first run, an agent may happen to locate the decisive file immediately or be diverted by a temporary environment problem. A tool that completes seventy per cent of ordinary assignments consistently and fails intelligibly can be more useful than one that occasionally completes a spectacular task.

Permissions and recovery matter more than a slogan of autonomy

Vendors naturally demonstrate progress through longer autonomous tasks. For a user, the important matter is what surrounds that autonomy.

Which directories may the agent read? Is network access open by default or approved? Can secrets be encountered? Does each change produce a clear diff? Can the user redirect the task while it runs? If the objective was misunderstood, how many steps return the project to its earlier state? What is preserved in a cloud environment and what remains local? These questions determine how much work the system can responsibly carry.

A default refusal to perform some operations does not show that a tool is unsophisticated. Approval creates a visible moment when action crosses a boundary. The quality of that moment matters. If harmless commands constantly require confirmation, users learn to click. If the system pauses when permissions genuinely expand, a network is accessed, a dependency is installed or a sensitive path is approached, confirmation can retain its role as judgement.

Recovery should not mean merely asking AI to undo its own work. A fresh generation can conceal the earlier error while introducing another set of changes. Git branches, small commits, worktrees, checkpoints and pull requests provide different layers of recovery. Consequential work should preserve at least one project state independent of the active agent conversation.

Individuals, projects and organisations will reach different conclusions

An individual developer working in one local repository may value low friction and a terminal agent that runs tests continuously. When several tasks need to proceed separately, Codex’s project and worktree management becomes attractive. A terminal-first developer will compare Claude Code seriously.

If most daily work happens beside the IDE cursor, Copilot completion and chat may save more time than an agent launched occasionally. The cloud agent can then be reserved for bounded issues suitable for asynchronous delegation.

A team must add governance. May source code leave a particular environment? Who authorises agent access to a repository? How does the organisation control models and MCP? Who reviews an agent’s contribution, and where are usage records retained? GitHub-native processes may reduce institutional change for a GitHub-centred organisation, while a team using another platform may gain less. The strongest model cannot compensate for confused permissions and missing tests.

Conclusion: choose how you will supervise before choosing an agent

If you need to manage substantial tasks across file diffs, local and cloud environments, with project instructions and worktrees for parallel changes, Codex is a natural candidate. If the terminal is the primary workbench and the agent should remain close to the current directory, Git state and command-line tools, Claude Code deserves priority in testing. When development already revolves around GitHub issues, pull requests, CI and organisational policy, the workflow integration of GitHub Copilot is difficult for a single independent entry point to reproduce.

The three can also be combined. A combination is coherent only when responsibilities are distinct: completion helps a person keep writing, a task agent implements a bounded change, and GitHub preserves a team-reviewable delivery record. If several agents alter the same workspace, carry opaque memories and exercise different permissions, more capability produces state that is harder to reconstruct.

The central question in coding AI is no longer whether a system can generate code. It is the environment in which the task is understood, what the system is permitted to change, how the change demonstrates that it meets the requirement, and whether a person can see a failure before it enters the main branch. A choice built around those questions will survive the next model leaderboard.

Primary sources

Continue reading: Choosing the Right AI Tool

Discover more from Geoffrey Chen

Subscribe to get the latest posts sent to your email.