OpenCode, Claude Code, Cursor — picking the right one for your IaC repo

TL;DR — Cursor, Claude Code, and OpenCode all work with the Kuberly autopilot. For IaC work: Cursor for product-eng teams, Claude Code for platform/SRE teams, OpenCode for regulated or open-source-only shops. The substrate underneath (MCP) is what matters, not the agent.

The honest answer

We support all of them. Customers run Cursor for the dashboard-rich IDE feel, Claude Code for terminal-native deep edits, and OpenCode for fully-open-source pipelines. Each works with the Kuberly autopilot — the MCP servers register, the PR flow is the same, the plan output lands on the PR regardless of the agent. The shared substrate is described in MCP for DevOps.

But "they all work" is a bad answer. Here's how we actually pick when a customer asks.

The shapes

Three tools, three very different bets:

Cursor is a fork of VS Code with the agent loop welded into the editor. You stay in the IDE. Inline edits, diffs, agents that touch multiple files, all within the editor frame. Closed source, paid subscription, your code goes to Cursor's servers — there's a Privacy Mode toggle that we recommend setting once per workspace and forgetting.

Claude Code is Anthropic's terminal-native agent. No IDE. You sit in tmux or Cmux, the agent runs in a pane, and you treat it like a colleague that types. It does have IDE plugins, but the design center is the terminal. Pay-per-token via your Anthropic API key. The model is Claude.

OpenCode is the open-source one. A terminal agent that runs against any model — Claude, GPT, Gemini, local — through pluggable providers. You bring your own API key. Available as a TUI and a desktop app. The bet: the value isn't in the wrapper, it's in your model choice and your tool ecosystem.

When we pick which

Cursor — when the customer's team is product-engineering-shaped. They live in VS Code. They want the AI to feel like part of the editor and don't want to think about it. Frontend-heavy or mixed-skill teams where some engineers are not comfortable in the terminal. The autopilot's IaC repo isn't their primary surface; they touch it occasionally and want low friction.

Claude Code — when the customer is platform-engineering-shaped. The IaC repo is their work. They're already in tmux. They want the agent to deeply read 200 files, hold a coherent plan in its head, and produce a 12-file diff that's actually correct. The terminal-first design pays off when the work is itself terminal-shaped — kubectl, terragrunt, gh, jq. Claude Code is the strongest pure-coding agent we run on customer work. For our laptop-side multiplexer setup, see Cmux vs tmux for AI agent fleets.

OpenCode — when the customer requires no closed-source LLM tooling, or when they're cost-sensitive. Some banks. Some regulated SaaS. Anyone running their own LLM gateway. OpenCode is the only one of the three that lets us point at an internal LLM endpoint without convincing legal of anything new.

Copilot — when the team is already using it everywhere and it's a tax they pay for the editor experience. We support it. We don't recommend it as the primary tool for IaC work; it's optimized for inline completion, not multi-file agentic work. But we don't fight it.

What's the same across all four

The autopilot doesn't care which one you use. The two MCP servers — kuberly-graph and kuberly-monitor — register the same way. The agent gets the same graph queries and the same Loki / Prometheus / Tempo access. The PR flow — kuberly-ci plans, kuberly-ai summarizes, the human reviews — is identical.

That's by design. The agent is the thinking. The MCP servers are the substrate. We picked the substrate so the agent is interchangeable. For why the substrate is the actual moat, see Knowledge graphs are the missing piece.

What's actually different in practice

Three things, in our experience running this on real customer repos:

1. Context window discipline. Claude Code is the most disciplined about reading just enough. Cursor is the chattiest — it likes to re-read files. OpenCode is in the middle and depends heavily on the model behind it. For large IaC repos (>500 modules), Claude Code finishes faster and produces tighter diffs.
2. Edit safety. All three sometimes generate a wrong edit. Claude Code is the one most likely to back out, re-plan, and fix. Cursor is the most likely to insist its first attempt was correct. OpenCode varies by model.
3. PR description quality. Cursor's "explain this change" output is the cleanest for non-technical reviewers. Claude Code's is the most technically correct but assumes a reader who already understands the repo. OpenCode is roughly Cursor-shaped if you point it at Claude or GPT.

The recommendation

If you're a Kuberly customer asking "which one should I use," our default answer:

• Frontend / product-eng-heavy team — Cursor.
• Platform / SRE / DevOps-heavy team — Claude Code.
• Regulated, internal LLM, or open-source-only — OpenCode.
• Already paying for Copilot — keep it for inline completion, layer one of the above on top for IaC work.

We don't have a religious horse in this race. The autopilot's value is in the substrate around the agent, not the agent itself. Pick the one your team will actually use.

---

Further reading

• Claude Code documentation — install, settings, MCP integration.
• Cursor documentation — workspace setup, privacy.
• OpenCode on GitHub — provider plugins, self-host.
• Model Context Protocol — what all four hosts speak.
• Anthropic — Building effective agents — patterns the agents inherit.
• Cmux vs tmux for AI agent fleets — the multiplexer underneath.
• Cheap agents — four token-saving moves — keeping any of these affordable.

Want an MCP-backed autopilot that works regardless of which agent your team picks? Talk to us.