Claude Code, opencode, Cursor: My Daily Driver and My Plan B

I’ve spent enough of the last six months working alongside an AI coding agent that I now have actual opinions, in the way you only get from shipping production code with a tool, not from reading benchmarks about it. There are three names that dominate the conversation in 2026 and they represent three genuinely different bets about how humans and language models should collaborate on code.

This is my honest read on Cursor, Claude Code, and opencode. The headline: Claude Code is my daily driver. opencode is my Plan B. Cursor is not what I reach for. Here’s why.

The three poles, briefly

There are roughly fifteen serious AI coding tools in 2026. They collapse cleanly into three categories that matter:

• The IDE bet. AI lives inside the editor. Tab completion, inline diffs, a chat panel that knows your codebase. The flagship is Cursor (Anysphere’s VS Code fork). Windsurf and Zed’s agent panel sit in the same camp.
• The proprietary-CLI bet. AI lives in a terminal, talks to your filesystem and shell directly, runs as an agent that plans, edits, verifies. The flagship is Claude Code (Anthropic). GitHub’s Codex CLI and Google’s Gemini CLI sit in the same camp.
• The open-source-CLI bet. Same shape as Claude Code, but with no vendor lock-in: bring your own API key, pick any model from any provider, run locally if you want. opencode (from the SST team) is the clearest leader. Aider, Cline, and Goose are adjacent.

Most people who care end up running two of the three. The interesting question isn’t “which one wins” — it’s which two, and why.

Cursor — the IDE bet

Cursor is a fork of VS Code with AI woven in. Tab autocomplete that predicts multi-line edits, an “Apply” feature that takes a chat suggestion and writes it directly into your file, a Composer mode that does multi-file refactors, and a chat that has read your repo.

It is, and I want to be fair here, genuinely excellent at what it sets out to do. If your day is spent in an IDE — TypeScript front-end, big React monorepo, anything where “where in this file does this import resolve to” is a question you ask thirty times an hour — Cursor is the most ergonomic AI experience on the market. The Tab completion alone is hard to walk away from once you’ve used it.

It is also not how I work. My day is shell, vim/zed, tmux, remote SSH into infrastructure I don’t want to install a 600 MB Electron app on, and dotfiles that have been muscle-memory for fifteen years. Cursor is asking me to migrate my editor for an AI experience. That trade is sane for some people. For a DevOps engineer whose workflow is half servers and half local Linux, it’s not.

There’s also a quieter concern: Cursor’s model routing is opaque. You don’t always know which model just edited your file. For a tool that’s making consequential changes to your code, that matters more than it sounds.

Claude Code — what I actually use

Claude Code is Anthropic’s CLI agent. You install it via npm, run claude in any project directory, and talk to it the same way you’d talk to a senior engineer pair-programming with you over Zoom — except it can read your files, run your shell, and edit code with your permission.

The features that matter, in roughly decreasing order of how much I notice them missing when they’re not there:

• Opus 4.7 is the best agentic model available. That sounds like a marketing line. It is also true: on real refactors, on debugging through a half-broken monorepo, on writing code that actually compiles the first time, the gap between Opus 4.7 and the next-best model is bigger than the marketing copy admits. This is the single biggest reason it’s my daily driver.
• Plan mode. Before it touches code, it shows you the plan. You approve or redirect. This is the difference between “AI made a mess” and “AI did exactly what I asked.”
• Subagents. Spawn a specialist agent for a narrow task — exploration, code review, planning — that runs in its own context window and returns just the summary. Keeps the main conversation clean.
• Skills, hooks, MCP. Extensibility that’s actually used. I’ve wired up Hugo-aware skills, custom git hooks, a memory system that persists across sessions.
• Slash commands. /loop, /ultrareview, /schedule — small pieces of opinion that ship as the product rather than as documentation.

The honest weaknesses:

• Tuned for Anthropic models, but increasingly portable. Out of the box it ships with Claude Opus/Sonnet/Haiku 4.x. As of Ollama 0.14+, Ollama speaks the Anthropic Messages API natively — so the official integration is now a one-liner:

  ollama launch claude --model glm-4.7-flash
  

  That single command configures the env vars (ANTHROPIC_BASE_URL, ANTHROPIC_AUTH_TOKEN) and drops you into Claude Code talking to a fully local Ollama daemon on localhost:11434. No proxy. No Anthropic account required. glm-4.7-flash is the recommended default — supports tool-calling and ships with 128 K context, which the agent loop actually uses. For non-Ollama endpoints — OpenAI, Groq, OpenRouter — you still drop in a compatibility proxy like LiteLLM or claude-code-router. The agent harness is co-tuned with Claude models, so the experience is best on Claude. But the lock-in is much softer than the marketing pages suggest.

• Subscription pricing has tiers. Pro ($20), Max ($100), Max+ ($200). Heavy users hit limits.

• Token usage is real money. If you’re paying API rather than subscription, the bills add up faster than people expect.

• No native IDE UI. It’s a terminal. If you want inline diffs rendered in your editor’s gutters, you want Cursor.

For my work — DevOps scripts, Hugo content, container infrastructure, the kind of code that’s read more than it’s written — Claude Code is the right tool. The agentic depth and Opus 4.7’s quality compound into something that genuinely changes what I can ship in a week.

opencode — the Plan B I’m glad I have

opencode is what happens when smart people look at Claude Code and say “this shape is right, but we want it open and provider-agnostic.” Built by the SST team, Apache 2.0, distributed as a single binary, terminal-native. It has 75+ LLM providers built in. Anthropic, OpenAI, Google, OpenRouter, Groq, Ollama for local models — you pick.

Why I have it installed alongside Claude Code (even though, yes, Claude Code can also reach Ollama now):

• Native multi-provider switching. Mid-conversation, in-UI. No restart, no env var dance, no proxy. When I want to A/B Opus 4.7 against glm-4.7-flash against gpt-oss:20b on the same prompt, opencode is the one that does it without ceremony.
• The open-source principle. Same reason I run Podman over Docker on a workstation where Docker would also work. Apache 2.0, auditable, forkable. The license matters.
• No Anthropic in the supply chain. Claude Code via Ollama still ships you the Anthropic CLI as an npm dependency — your node_modules carries it, your update cadence is theirs. Opencode is a single vendor-neutral binary. For some client work, that distinction is the difference between “approved” and “not approved.”
• No subscription, full stop. Bring your own API key, pay only for what you use — or pay nothing, run Ollama, and have the lights stay on. For lighter weeks this is meaningfully cheaper than Claude Pro/Max.

What opencode trades away to get those things:

• The agent loop is less polished. Claude Code’s plan mode, subagent system, and verification flow are noticeably more mature.
• You’re responsible for model choice. Opus 4.7 via opencode works great. Opus 4.7 via Claude Code works better, because the agent scaffolding around it has been co-tuned with the model team. The same model can produce meaningfully different results depending on the agent harness it sits inside.
• Smaller community, fewer pre-built skills/integrations.

The summary: opencode is the right shape, with the model-flexibility escape hatch. Plan B in the literal sense — when Plan A is unavailable, it’s the one I want to fall back to without changing my muscle memory.

The table, finally

What I actually run

• Claude Code, Opus 4.7, Max tier — daily driver, ~80% of my AI coding work. Dockerfiles, nginx configs, container migrations, the kind of DevOps glue that has to be right the first time because the feedback loop is slow.
• opencode pointed at Anthropic, OpenAI, and Ollama — Plan B for outages, side-by-side comparisons when I’m not sure a given model is the right tool, and any work I want to do without external API calls.
• No Cursor — not because it’s bad, but because my workflow is terminal-shaped. If I were doing five days a week of React, the answer might be different.

What it comes down to

Pick the tool that holds up to your actual work, not the one with the louder homepage. For me, today, that’s Claude Code — Opus 4.7 plus the agent loop is hard to walk away from once you’ve shipped a week of real work with it. And when it isn’t available — Anthropic outage, an air-gapped engagement, a client whose security review excludes the supply chain — opencode is the Plan B I’m grateful I installed.