Claude Code vs Codex vs Qwen Code: Which AI CLI Should You Use?

Three CLIs, three price points, three personalities. I've been running Claude Code, OpenAI Codex CLI, and Qwen Code side by side in a grid for the better part of a quarter, and the answer to "which should you use" is no longer "Claude Code, obviously."

The honest answer is that they're good at different things, they fail differently, and you should probably run all three — just not all at once for the same task. Here's what I've learned from putting them in the same 3-pane grid for ninety days.

The one-line summary for each

Claude Code — the judgment engine. Best at understanding a large codebase, making architectural calls, and refusing to do dumb things when you ask. Expensive.

Codex CLI — the fast typist. Great at "just write this, stop thinking about it" tasks. Good tool-use discipline, excellent at shell-driven workflows. Middle cost.

Qwen Code — the dark horse. Surprisingly strong on mechanical tasks, cheap, and the only one of the three that you can run against a local or self-hosted endpoint without much fuss. Weakest on judgment.

If you read nothing else, the takeaway is: Claude Code for the pane you're driving, Codex for the "do this now" pane, and Qwen for the "run this boring thing twenty times" pane.

Reasoning quality

Claude Code wins here, but by less than the benchmarks suggest in day-to-day work. Its real edge is in two places: declining to do things that would break the build, and proactively reading files it hasn't been pointed at when it suspects they're relevant.

Codex is competitive on reasoning when the task is well-specified. It's worse when the task is ambiguous — it'll pick a direction and commit to it rather than asking. Sometimes that's what you want. Sometimes it's not.

Qwen is a step behind on reasoning. It handles "implement this function, here's the signature, here are the tests" well. It struggles with "refactor this module to be cleaner." It doesn't have a strong sense of what "cleaner" means and will often make changes that satisfy the letter of the request and miss the point.

Tool use and the shell

This is where Codex shines. Its tool-use loop is tight and it's less chatty than Claude between tool calls. For pure "run this command, react to the output, run the next command" workflows, it's the fastest of the three.

Claude's tool use is thoughtful in a way that costs you tokens and wall-clock time. It often reads files it didn't strictly need to read, "just to be sure." This is usually a feature — it catches issues — but it means a simple task runs slower than in Codex.

Qwen's tool use is functional but occasionally literal-minded. If you say "run the tests," it will run npm test even if your repo uses pnpm test. It's improved a lot over the last year and it's no longer embarrassing, but it still trails the other two.

Cost

Rough cost orientation, per the typical agentic day (four hours active, tool calls included):

Numbers are directional. If your day is mostly Opus, the other three all look like bargains. For a full cost breakdown see cutting your AI coding bill in half.

Codebase understanding

Claude Code's large context and its habit of reading supporting files make it the clear winner when you're working in an unfamiliar repo. The first hour in a new codebase is where the Opus premium pays for itself.

Codex is workable in unfamiliar codebases if you do a bit more hand-holding — point it at the right files explicitly rather than letting it explore. Its exploration heuristics are weaker.

Qwen benefits enormously from a good QWEN.md or equivalent context file. Without one, it does not explore well. With one, it can do mechanical work on a codebase it's never seen.

Personality and push-back

Claude pushes back. It'll tell you your idea is bad, or that a safer approach exists. For senior developers this is gold; for those of us who want the agent to just shut up and do it, it's occasional friction. You can prompt your way around it.

Codex rarely pushes back. It'll do what you ask, including things it shouldn't. This is faster when you're right and painful when you're wrong. It's also less likely to catch a subtle bug by questioning your premise.

Qwen lands between them and has the least distinct personality. It's business-like and shorter with its responses. For some workflows that's a relief.

Which one to run in each pane

Here's the assignment I've settled on for a 3-pane grid:

1. Driver pane: Claude Code (Opus or Sonnet depending on task).
2. Implementer pane: Codex CLI, for "I have a spec, do it."
3. Backfill pane: Qwen Code, for tests, docs, and boring migrations.

For 4+ panes I add a second Claude (Sonnet) as a second implementer. The multi-model code review post covers running all three on the same diff.

Installation and ergonomics

All three install cleanly. Claude Code is npm install -g @anthropic-ai/claude-code. Codex CLI is npm install -g @openai/codex (or the pip equivalent). Qwen Code has both npm and binary releases.

Day-to-day ergonomics, which matter more than anyone admits:

• Claude Code has the best --continue ergonomics of the three. You can rewind and resume naturally.
• Codex has the best shell-first ergonomics; it was built for terminals, not ported to them.
• Qwen has the best offline-ish story; point it at an OpenAI-compatible endpoint and you can run it against a local model.

For the specifics of each in SpaceSpider, see the Claude Code integration docs. The getting-started guide at /docs/getting-started covers assigning any of these to a pane.

The long-context question

Claude's context is the largest of the three and it uses it well. Codex's context is competitive on paper but in practice I hit context-management issues on large repos earlier than I do with Claude. Qwen's context varies with the model you pick — some variants are fine, some are cramped.

For repos over ~100k lines of code, I run Claude as the Driver and have it summarize context for Codex and Qwen when I hand off. For smaller repos, all three can hold the relevant context in a single session.

What each one breaks on

Claude: over-thinks small tasks. Burns tokens re-reading files. Occasionally gets into "let me propose three options" loops when you want one answer.

Codex: commits to a direction without asking. Will happily write code that doesn't match the existing style because it didn't bother to read the neighbors. Tool-use is fast but occasionally over-eager.

Qwen: weak on abstract reasoning. Literal-minded with instructions. Needs more explicit context than the other two. Its diff quality is the roughest of the three.

Key takeaways

Claude Code is the best all-rounder and the most expensive. Codex CLI is the best fast-implementer. Qwen Code is the best cheap-backfill tool and your best bet for local-ish workflows. Run them in a grid, assign each one the pane role it fits, and you'll beat any single-CLI setup.

The biggest mistake is loyalty. Pick one and you're either paying too much (all Opus) or doing too little (all Qwen). The grid is the point: different jobs, different tools, same workspace.

FAQ

Can I use Claude Code for the whole workflow and skip the others? You can, and it's fine if cost isn't a factor. For most budgets, mixing saves real money without losing much quality.

What about Aider and Cline — where do they fit? Both are solid and have different philosophies (Aider is commit-centric, Cline is editor-integrated). They're covered in the 9 best AI coding CLIs.

Is Qwen Code private enough for work code? Depends on which endpoint you point it at. The hosted Qwen API has its own data policy; a self-hosted Qwen model keeps code on your machine. Read the endpoint's policy; don't assume.