I've spent the last two weeks running OpenCode as my daily driver for a mid-sized Rust codebase, and I've got a take that'll probably annoy people on both sides of the open-source-vs-commercial fence: the model barely matters anymore. The thing that decides whether a coding agent saves you an hour or costs you one is how well it understands your repo's conventions and your actual workflow. OpenCode gets this right in ways Cursor and Copilot still fumble.
Let me be clear about what OpenCode is before I compare. It's a terminal-based, open-source coding agent. You point it at a repo, it reads the tree, and you talk to it in natural language. It runs against whatever model you want — local or API — and it's fully configurable through YAML. No IDE lock-in, no telemetry you can't read, no subscription you can't cancel. That alone puts it in a different category from Cursor and Copilot, which are both proprietary products wrapped around their own infrastructure.
But here's the thing I actually care about, and it's the reason I'm writing this: the difference between these tools isn't the intelligence under the hood. It's how they handle context.
The convention problem
Every repo has unwritten rules. Error handling style. Whether you use this or bind methods. How you name modules. What the test setup looks like. A good agent doesn't just know the language — it knows your dialect of the language.
Cursor tries to solve this with rules files and a memory of your edits. It works, but it's a proprietary black box. You're trusting their heuristics to infer your conventions from what you've done before, and you can't see or edit the logic. Copilot is worse — it's trained on the entire internet's worth of code, which means it defaults to the most common pattern, not your pattern. If your codebase does something slightly unusual, Copilot will fight you on it.
OpenCode does something different. Because it's open source, the context pipeline is inspectable. I can see exactly what it's feeding the model — which files, what order, what's been truncated. And more importantly, I can change it. I wrote a small config that tells it to always read the CONTRIBUTING.md first and to prioritize the src/ tree over tests/ when it's forming an initial plan. That took me twenty minutes and it changed the quality of every single response after it.
That's the real open-source advantage, and it's not about the model at all. It's about being able to shape the agent's understanding of your repo instead of accepting someone else's guess.
The workflow problem
The second thing I measured — and I did actually measure this — is how each tool fits into how I work.
I live in a terminal. My whole agent stack is terminal-based. When I tried Cursor, the friction wasn't the AI, it was the IDE. I had to leave my tmux session, open a GUI, and work in their editor to get the agent's benefits. That's a workflow tax I wasn't willing to pay, and it's why Cursor sits unused on my machine.
Copilot is better on that front because it lives in VS Code, which a lot of people already use. But it's still tied to GitHub's ecosystem. If you're not on GitHub, or if you're working across multiple forges, it's awkward.
OpenCode runs in the terminal, which means it slots into the workflow I already have. I can pipe its output, script around it, run it in CI if I wanted to. It's a Unix tool, not a product. For someone like me who builds agentic systems for a living, that's not a nice-to-have — it's the whole point. I can integrate it into my own pipelines instead of adapting my pipelines to it.
Where OpenCode still loses
I'm not going to pretend it's all roses. OpenCode has rough edges that Cursor and Copilot have polished away.
First, setup. Getting it configured with the right model, the right context rules, and the right permissions took me an afternoon. Cursor worked out of the box in ten minutes. That's a real cost, and for a lot of teams it'll be the deciding factor. Open source means you do the work; the commercial tools do it for you.
Second, the model routing. OpenCode is model-agnostic, which is great, but it also means you're responsible for picking the right model and tuning it. I've been running it against a local model for privacy-sensitive work and an API model for heavy lifting, and managing that split is on me. Cursor and Copilot hide all of that behind their own model selection, which is simpler even if it's less flexible.
Third, the polish. Cursor's diff previews are genuinely nice. Copilot's inline suggestions are seamless. OpenCode's terminal output is functional but ugly, and the diff review experience is nowhere near as smooth. If you care about that kind of thing, you'll notice.
What the comparison actually tells us
Here's my honest conclusion after two weeks: the model capability gap between these tools is noise. They're all running models that are good enough to write competent code. The real differentiator is how the agent understands your repo and how it fits your workflow.
OpenCode wins on both for someone like me — because I can shape its understanding and because it lives where I work. Cursor wins for people who want a polished, opinionated experience and don't mind the IDE lock-in. Copilot wins for people already deep in the GitHub/VS Code ecosystem who want zero setup.
None of this is about intelligence. It's about context and workflow. The sooner we stop arguing about which model is smarter and start arguing about which agent understands our code, the better off we'll all be.
I haven't fully committed to OpenCode yet — the polish gap is real, and I'm still deciding if the control is worth the friction. But it's the first coding agent that treats me like a developer instead of a user, and that counts for a lot. https://opencode.ai/
Top comments (0)