Developer Experience Analysis · April 2026

Three terminals,
three philosophies.

A close-read of OpenCode, Codex CLI, and Claude Code — the developer experience, not the model. How each one feels to live with day-to-day, where the friction is, and what kind of workflow each one quietly assumes you have.

Model-agnostic comparison Focus on DX, not benchmarks Terminal-first workflows
01 / Open source
OpenCode
anomalyco/opencode · MIT-licensed

The community-built TUI that treats model choice as a feature, not a coupling.

ProviderAny · BYOK · subscriptions
InterfaceFull TUI
ConfigJSON · JSONC
Lock-inNone
02 / OpenAI
Codex CLI
openai/codex · Apache-2.0

OpenAI's terminal agent — sandbox-first, opinionated about safety, quiet about everything else.

ProviderOpenAI-first · custom providers
InterfaceHybrid CLI/TUI
ConfigTOML
Lock-inLight
03 / Anthropic
Claude Code
anthropic/claude-code · Proprietary

Anthropic's vertically integrated agent — the most polished interaction model, the most rigid stack.

ProviderAnthropic
InterfaceRefined TUI
ConfigJSON · MD
Lock-inHeavy
§ 01 — First contact

Installation, auth, and the first thirty seconds.

The first command you type tells you a lot about a tool's philosophy. Here's what each one expects of you before you've done any actual work.

Dimension
OpenCode
Codex CLI
Claude Code
Install
npm i -g opencode-ai · curl script · brew · binary releases
npm i -g @openai/codex · brew · binary
npm i -g @anthropic-ai/claude-code · native installers
Runtime
TypeScript on Bun (single binary available)
Rust binary (recently rewritten from TS)
Node.js — native binaries now shipped too
Auth model
Flexible provider keys, Copilot, ChatGPT, env or config
OpenAI-first ChatGPT login, API key, Azure, or custom provider
Anthropic-bound Claude login or API key
First-run feel
Drops you into a TUI. Pick a model, start typing.
Asks for sandbox approval mode upfront.
Asks for working directory trust, then conversational.
Time-to-first-prompt
~2 min if you have a key already
~30 sec with ChatGPT login
~30 sec with Claude login
Subscription path
None required — BYOK, Copilot, or ChatGPT plans
ChatGPT Plus/Pro/Business unlock usage; API keys still work
Claude Pro/Max plans unlock usage
§ 02 — The interaction loop

How each tool asks for permission — and how often.

The single biggest DX differentiator isn't features. It's how the tool handles the moment between "I want to do this" and "I did it."

Dimension
OpenCode
Codex CLI
Claude Code
Default mode
Interactive TUI; approval is configurable, Plan is restricted
Suggest mode (read-only) → Auto-edit → Full-auto tiers
Plan mode → conversational with per-action prompts
Permissioning
Configurable permissions; Plan asks before edits and bash
Best-in-class sandbox tiers, OS-level isolation
Allowlist file + per-session approvals (granular)
Diff display
Inline TUI diffs with syntax highlight
Unified diffs in terminal; clear before/after
Color-coded inline diffs, very legible
Undo / rollback
Snapshots by default; rollback through the UI
Git-based; manual
/undo-style flows + checkpointing
Background tasks
Sessions can be backgrounded; multi-session UI
Cloud delegation via codex cloud
Backgroundable; remote session ecosystem emerging
Friction level
Medium tunable
Low when sandboxed
Medium-high by design
§ 03 — Extending the tool

Custom commands, MCP, and the long-tail of fit.

Out-of-box experience matters less over months. What matters is whether the tool grows with the way your team actually works.

Dimension
OpenCode
Codex CLI
Claude Code
MCP support
Yes as a client
Yes as client and (recently) server
Yes deepest integration of the three
Custom commands
Markdown-based prompts, project-scoped
Prompt files; AGENTS.md convention
Slash commands from Markdown · skills · subagents
Project memory
AGENTS.md / project rules
AGENTS.md hierarchy (now widely shared)
CLAUDE.md hierarchy with explicit precedence
Hooks / lifecycle
Hooks system (pre/post tool calls, etc.)
Documented hooks behind a feature flag
Mature hooks across many lifecycle points
Subagents / orchestration
Multi-agent patterns supported via configuration
Subagent workflows plus cloud sessions for parallelism
First-class subagents with isolated contexts
SDK / programmatic use
Open source — embed or fork freely
Rust crate + IDE extensions
TypeScript & Python SDKs · GitHub Actions
§ 04 — Living with each tool

What it actually feels like to use them.

The matrices are facts. This section is opinions — informed by what each tool prioritizes, what it sacrifices, and who it's clearly built for.

DEEP DIVE / 01

OpenCode

anomalyco/opencode

What it gets right

  • Provider freedom is the headline. Anthropic, OpenAI, Google, Groq, Copilot, ChatGPT plans, local Ollama — switch in config. No tool here treats this as a first-class concern the way OpenCode does.
  • The TUI is genuinely good. Multi-pane, multi-session, keyboard-driven. You feel like you're using a tool, not chatting with a window.
  • No subscription requirement. Bring keys if you want pure pay-as-you-go, or use a supported subscription login. The tool does not force one commercial path.
  • Open source ethos. Forkable, inspectable, hackable. If a behavior bugs you, you can change it.

Where it bites you

  • The setup tax is real. You pick the provider, the model, the keys or login path, the config. That flexibility costs maybe 15 minutes of decisions you didn't have to make with Codex or Claude.
  • Documentation lags features. Common with fast-moving OSS — you'll hit moments where the GitHub issues are the docs.
  • Polish is uneven. The TUI is great, but edges around error messages, recovery, and edge-case UX trail behind the vendor tools.
  • Less tribal knowledge. When you Google a problem, you'll find ten Claude Code answers for every OpenCode one.
OpenCode is the tool you choose when "I don't want to be coupled to a single AI vendor" matters more than "I want the smoothest possible onboarding."
DEEP DIVE / 02

Codex CLI

openai/codex

What it gets right

  • Sandbox-first design. The tiered approval modes (suggest / auto-edit / full-auto) plus OS-level sandboxing on macOS and Linux are the cleanest safety story of the three.
  • The Rust rewrite paid off. Startup is fast, footprint is small, behavior is more predictable than the original TS version.
  • Cloud delegation is genuinely useful. codex cloud lets you fire off long-running tasks without parking your terminal — a different shape of multitasking than the others offer.
  • Good IDE story. The VS Code extension and IDE bridges are getting more mature, and the CLI ↔ IDE handoff is smooth.

Where it bites you

  • OpenAI-first, not fully model-agnostic. You can configure Azure, local providers, and custom OpenAI-compatible endpoints, but the happy path is still clearly the OpenAI stack.
  • The TUI is functional, not loved. It works. It doesn't feel like a place you want to live in for hours the way Claude Code or OpenCode do.
  • Custom command ergonomics trail Claude Code. Prompt files, AGENTS.md, skills, and slash commands exist, but the muscle memory is less mature.
  • Hooks are real, but newer. The lifecycle surface is documented and useful, but it still feels more like an emerging platform than Claude Code's long-running customization layer.
Codex feels like infrastructure built by people who think about safety first and developer delight second. That's a feature if you're shipping in regulated environments. It's a flatter experience if you're not.
DEEP DIVE / 03

Claude Code

anthropic/claude-code

What it gets right

  • The most refined interaction loop. Plan mode, the way edits are previewed, the conversational rhythm — it's the tool that most consistently makes you forget you're talking to a CLI.
  • The extensibility surface is huge. Slash commands, skills, subagents, hooks, MCP, output styles — the seams are real and well-thought-out.
  • CLAUDE.md hierarchy is genuinely good. Project memory that respects nesting, with clear precedence rules. Once you've used it, the AGENTS.md convention feels less structured.
  • Ecosystem gravity. Claude Code Actions, the SDK, GitHub workflows — there's a lot of "you can also..." that compounds the longer you use it.

Where it bites you

  • Anthropic-only. No multi-vendor story. If your org needs to negotiate model choice, this is the most rigid option.
  • The subscription model is a category mismatch. Claude Pro/Max usage limits work, but they introduce a "did I just burn through my quota?" anxiety the API-key tools don't have.
  • It encourages context dependency. The richer the project becomes (skills, subagents, custom commands), the harder it is to walk away from. That's lock-in even if it's pleasant lock-in.
  • The polish creates a baseline expectation. When something does go wrong — a bad tool call, a weird approval prompt — the contrast with the surrounding smoothness is jarring.
Claude Code is the tool that most rewards investment. Spend a week tuning it for your project and you'll have something the others can't easily match. Spend an afternoon and the others probably feel lighter.
§ 05 — Scorecard

The DX dimensions, scored side by side.

Subjective scoring across the dimensions that actually move developer happiness. Out of 10.

Time to first useful output
Open
7
Codex
9
Claude
9
TUI / interaction polish
Open
8
Codex
7
Claude
9.5
Permissioning & safety UX
Open
7
Codex
9.5
Claude
8.5
Extensibility ceiling
Open
9.2
Codex
8.2
Claude
9.5
Provider / vendor flexibility
Open
10
Codex
6.5
Claude
2
Project memory ergonomics
Open
7.5
Codex
8
Claude
9.5
IDE / editor integration
Open
7
Codex
8.5
Claude
9
Background / remote sessions
Open
7.5
Codex
9
Claude
8
Documentation quality
Open
6.5
Codex
8
Claude
9
Long-term lock-in cost
Open
9.5
Codex
7.8
Claude
5
§ 06 — Choosing

Pick the one that matches your constraints.

There is no winner. There's only fit. Here's the shape of the developer who'll be happiest with each tool.

Choose OpenCode if…

You want to switch models without switching tools.

You're price-sensitive and want pay-as-you-go via API keys, with subscription logins as an option rather than a requirement.

You run local models (Ollama, LM Studio) and want a real TUI, not a chat window.

You value being able to read, audit, or fork the tool you depend on.

Your org has a multi-vendor AI policy or compliance reasons to avoid lock-in.

Choose Codex CLI if…

You're already invested in the OpenAI stack, or you want an OpenAI-first tool that can still route through Azure, local providers, or custom endpoints.

You need the strongest sandbox and approval-tier story you can get.

You like delegating long-running work to the cloud and checking back in.

You want a fast Rust binary that doesn't depend on a Node toolchain.

You prefer infrastructure-feeling tools to delight-feeling tools.

Choose Claude Code if…

You want the most polished moment-to-moment interaction available.

You'll invest in custom commands, skills, and subagents to fit your project.

You're already on a Claude Pro/Max plan or have Anthropic API access.

You value a deep, opinionated extensibility model over a portable one.

You're okay with vendor coupling in exchange for ecosystem gravity.

— Closing thought —

The right question isn't "which is best?"
It's "which is best for me, this quarter?"

OpenCode is the principled choice. Codex is the pragmatic enterprise choice. Claude Code is the maximalist productivity choice. None of them is wrong — they're just optimizing different things, and the fit depends on which of those things you currently care about most.

The healthiest move, if you can afford it, is to keep OpenCode installed alongside whichever vendor tool you use day-to-day. The day a model from a different provider wins your benchmark, you'll already have the muscle memory to switch.