OpenCode AI coding agent review

I switched my daily coding agent workflow recently, not because of a licence expiry or a sudden client demand, but simply because I wanted choice. I wanted to pick which AI model powers my coding agents without being locked into one provider, and that choice is exactly what OpenCode gives you. That’s why I’ve shifted from using Claude Code as my default to putting OpenCode front and centre in my tooling.

If your goal is flexibility and future-proofing without sacrificing productivity, OpenCode is worth exploring. It isn’t just another CLI coding tool, it’s a platform that lets you hook in any provider that makes sense for the task at hand.

Why model-agnostic tooling matters

Claude Code is a polished, capable agentic coding tool with native integration into Anthropic’s models that a lot of developers (and even AI leaders like Andrej Karpathy) lean on for deep reasoning and code generation workflows. Recent discussions in the industry note how tools like Claude Code are helping people shift much of their development workflow to prompts and AI assistance.

But it’s tied to one ecosystem. You’re essentially placing a bet on Anthropic’s roadmap and pricing. If you want to try another model, maybe GitHub Copilot’s backend models, OpenAI’s Codex, Gemini, or even your own local models, you’re often waiting on tooling support.

OpenCode takes a different stance. It’s open source and explicitly model-agnostic. You bring your own keys, whether that’s a Claude subscription, a Copilot token, an OpenAI Codex key, or even local LLMs via Ollama. The same agent workflows can use whichever provider you prefer. That’s not a niche benefit for me; it’s become central to how I experiment and decide on the best model for the job.

This flexibility means:

• you aren’t constrained to a single provider’s performance curve,
• you can experiment with replacements or new releases as soon as they come out,
• and you retain control over which service you pay or migrate towards.

What I was doing before OpenCode

In my day-to-day work building Laravel/PHP applications (with Vue or React frontends), I rely heavily on agentic tools to give context on codebases, draft features, generate tests, and automate repetitive syntax. With Claude Code, I’d drop into the terminal, ask about a specific context, scaffold code or patches, and commit from the same CLI environment.

It worked well and felt like a significant productivity boost.

Still, I hit recurring constraints: I couldn’t easily switch the LLM behind the scenes, and I didn’t want the pain of migrating later if another provider outpaced Anthropic. That’s a practical concern, not a hypothetical one, and it drove me to try OpenCode.

What changes with OpenCode

OpenCode gives me much of what I liked about Claude Code plus the freedom to choose the model that fits my current need.

The terminal UI (TUI) is slick, responsive, and it isn’t designed to be flashy (like Crush), but it’s efficient when you’re switching between agents, codebase queries, and workflow commands. Configuration is straightforward and lets you manage sessions, agents, and model choices from within the same CLI.

But the real differentiator is model flexibility. OpenCode uses their AI SDK and Models.dev to support 75+ LLM providers (and it supports running local models too). In practice that means I can plug in:

• my existing Claude subscription (just like Claude Code),
• a GitHub Copilot/Codex key to compare output styles,
• a local model via Ollama for offline tasks.

Being able to test different models with the same agent definitions and workflows makes it a far more flexible day-to-day choice.

Migrating from Claude Code: it isn’t painful

One of my big concerns before switching was: “Is this going to be a painful rewrite of all my agent configs?”

Here’s the good news: it’s not. OpenCode’s configuration concepts for agents, skills and commands are very similar to Claude Code’s. OpenCode also supports Claude Code’s file conventions as fallbacks (including CLAUDE.md and ~/.claude/...), so you don’t always need to rewrite your rules on day one (rules docs).

Where adjustments are needed, I leaned on AI itself to refactor or translate a file, and that took minutes rather than hours. Simple agent definitions, patterns and tooling hooks carried over with minimal pain.

When doing this on a real project, I could point OpenCode at a directory with my Claude config files and start testing right away. It took far less time than expected.

When Claude Code still makes sense

I’m not here to dismiss Claude Code outright. It’s a strong tool with deep model integration and advanced capabilities that aren’t always mirrored exactly in OpenCode — especially around things like built-in model optimisations and the tight coupling with Anthropic’s ecosystem. Many developers still pick Claude Code for its reasoning quality, especially on complex, context-heavy tasks.

But for me, the openness and model choice matter more in the long run. That’s not a slight on Claude Code, it’s just a reflection of my priorities as someone who experiments with different models and doesn’t want a migration headache later.

Some gotchas to watch out for

• Trying to go all-in on too many models at once. OpenCode lets you bring multiple providers, but switching between them without tuning prompts can give inconsistent results.
• Assuming identical output quality across models. Different providers produce slightly different behaviours; your prompts and agent definitions frequently need refinement.
• Over-engineering agents immediately. Start small, refine your agent’s tools and instructions as you iterate.

Wrap-up

OpenCode isn’t just another entry in the growing list of AI coding agents, it’s a statement about how you, the developer, should stay in control of your tooling. Its model-agnostic design, support for many providers, and flexible configuration make it a compelling choice if you value choice over lock-in and want to avoid being tied to a single ecosystem. That’s the core reason I shifted my workflow here.

Choosing OpenCode doesn’t mean Claude Code or other tools are inferior. Claude Code remains a strong option with deep integration into Anthropic’s models and a polished experience. It’s just that for me, who likes to experiment, the freedom to switch models and keep configurations portable matters more in the long term.

If you’re curious about agentic coding tools and want to explore beyond a single provider, starting with OpenCode’s TUI and multi-provider support is a practical next step.

Ready to try it yourself? Grab your API keys, drop your Claude Code configs into OpenCode, and see how flexible your workflow can become.