OpenCode vs Claude Code: config, plugins, models and one Twitter (X) MCP server in both

The two agents overlap on the basics: both run in a terminal, read and edit files, run shell commands behind a permission system, delegate to subagents, read project instruction files and speak the Model Context Protocol. The differences are in who controls the model, how the config is laid out and what you pay for.

Popularity is close enough not to decide anything: at the time of writing the OpenCode repository shows about 224,000 GitHub stars and the public claude-code repository about 154,000, and both pushed commits the day we checked. Release cadence is fast on both sides (Claude Code v2.1.316 shipped on October 31, 2026), so pin versions in CI whichever you choose.

If you are weighing a third option, Codex CLI uses yet another format (TOML in ~/.codex/config.toml); the MCP section below shows the same server in all three, and the Codex vs Claude Code page covers that pairing in depth.

OpenCode. One JSON or JSONC file does almost everything. The global file is ~/.config/opencode/opencode.json; a project file named opencode.json is found by walking up from the current directory to the nearest Git root. The docs list a precedence order from remote .well-known/opencode config, through global, OPENCODE_CONFIG, project, .opencode directories and inline OPENCODE_CONFIG_CONTENT, up to managed files and macOS managed preferences. Files are merged key by key, not replaced. Secrets go in as {env:NAME} or {file:path} substitutions.

What V2 changed. The V2 migration guide says file names and locations stay the same, but agent becomes agents, provider becomes providers, command becomes commands, plugin becomes plugins, the V1 permission groups become one ordered permissions array, and terminal-client settings move from tui.json to a single global ~/.config/opencode/cli.json. V1 configs are still accepted, and the guide suggests asking OpenCode to migrate them.

Claude Code. Settings live in ~/.claude/settings.json (all projects), .claude/settings.json (committed with the repo), .claude/settings.local.json (personal, gitignored) and managed policy settings for organizations. MCP servers are separate: project-scoped servers go in .mcp.json at the repo root, local and user scopes are stored in ~/.claude.json. Environment variables expand as ${VAR} or ${VAR:-default}. Instructions come from CLAUDE.md files.

The practical difference: OpenCode is one schema-validated file you can diff in a pull request; Claude Code spreads permissions, hooks, MCP and instructions across several files with clear team versus personal scopes. Neither is wrong. Teams that standardize a repo-level setup tend to like Claude Code's committed .claude/settings.json plus .mcp.json; people who switch models daily tend to like one OpenCode file with model at the top.

Both agents speak MCP over HTTP, so a hosted server is the shortest way to give either one live X data. We sent the TwitterAPI.io server at mcp.twitterapi.io/mcp an MCP initialize request while writing this page. It answered as twitterapi-mcp 0.1.0, with instructions to paste a TwitterAPI.io API key as the Bearer token, and its tools/list returned 12 tools: search_tweets, get_user_info, get_user_about, get_user_followers, get_user_followings, get_user_last_tweets, get_user_mentions, get_tweets_by_ids, get_tweet_replies, get_tweet_quotes, get_tweet_retweeters and get_trends.

OpenCode V2. Servers go under mcp.servers, each with type: "remote", an absolute url and a headers map; the docs say to set "oauth": false when a server authenticates with an API key header, and to use disabled (not enabled) to keep one configured but off. V1 put servers directly under mcp with enabled: true. opencode mcp list shows each server's status and opencode mcp debug <name> checks connectivity.

Claude Code. One command, claude mcp add --transport http twitterapi https://mcp.twitterapi.io/mcp --header "Authorization: Bearer $KEY", writes the server to local scope; add --scope project to commit it in .mcp.json for the team. The docs say Claude Code warns when one MCP tool result passes 10,000 tokens and caps output at 25,000 tokens by default (MAX_MCP_OUTPUT_TOKENS raises it), and tool search is on by default so tool schemas are not all loaded up front.

Codex CLI. A [mcp_servers.twitterapi] table in ~/.codex/config.toml with url and bearer_token_env_var, which Codex sends as the Authorization header.

Context cost. OpenCode's MCP page warns that MCP servers add to your context and that some can exceed the context limit. For this server the full tools/list schema is 11,712 characters, roughly 2,928 tokens at four characters per token (our estimate), and that is the same payload in every agent. Enable it per project rather than globally if you only need X data in one repo.

"opencode plugins" is searched almost as often as the comparison itself, and on X the plugin conversation is busy: a search for opencode plugin returned 160 posts in 8.34 days, and 30.6% of them also mention Claude Code. The two plugin systems solve the same problem in very different shapes.

OpenCode V2 plugins are packages. A plugin exports a server part (and optionally TUI, GUI and RPC parts), all built against the single @opencode/plugin dependency. The server part is Plugin.define({ id, setup(ctx) }), and ctx is essentially an OpenCode server client with plugin-only additions: ctx.tool.transform registers tools with a JSON Schema input and an execute function, ctx.session.hook("prompt", ...) intercepts prompts before they are admitted, ctx.provider.transform adds providers and models, and ctx.event.subscribe reads the server event stream. Files under .opencode/plugins/ load automatically; anything else goes in the plugins array (npm names, versions, scoped packages or local directories).

V1 plugins do not run in V2. The migration guide is explicit that V1 plugin implementations must be ported. V1 plugins were async functions that received project, directory, worktree, client and Bun's $, and returned a hooks object keyed by event names such as tool.execute.before, session.idle and file.edited. If a plugin you found on npm still looks like that, it targets V1.

Claude Code plugins are directories with a manifest at .claude-plugin/plugin.json that bundle skills (SKILL.md), subagents, hooks, a JavaScript hooks module (a plugin with one is called a mod) and MCP servers via .mcp.json. You install them from a marketplace with /plugin; Claude Code adds Anthropic's official marketplace on first interactive start. Hooks themselves are JSON in settings with handler types command, http, mcp_tool, prompt and agent, across events like PreToolUse, PostToolUse, SessionStart and Stop. The docs note that every enabled plugin's skill and agent descriptions sit in context on every turn.

In short: OpenCode plugins are code that reshapes the agent itself (tools, providers, prompts, UI); Claude Code plugins are packaged configuration plus scripts layered on a fixed agent. For an X-data tool, both work. In OpenCode you can register a native tool that calls TwitterAPI.io directly; in Claude Code the equivalent is the MCP server above or a skill that runs the Python script further down.

OpenCode costs nothing as software. You bring a key: /connect adds a provider and /models picks one, and the V1 docs say keys added this way are stored in ~/.local/share/opencode/auth.json. Local models are first-class: V2 probes Ollama at 127.0.0.1:11434 and adds its models without an account. For hosted open models there is OpenCode Go: $10 a month (Go), $40 a month (Go Plus) or $20 per member a month (Go Teams). Each model in Go carries its own monthly dollar allowance, with a 5-hour allowance of 20% and a weekly allowance of 50% of that monthly limit, per the Go docs.

The Claude subscription question. Many people want OpenCode's harness with their Claude subscription. OpenCode's providers page addresses this directly: there are plugins that let you use Claude Pro/Max models in OpenCode, "Anthropic explicitly prohibits this", and OpenCode stopped bundling those plugins as of version 1.3.0. Using Claude models in OpenCode through an Anthropic API key (pay per token) is the documented route.

Claude Code is included in paid Claude plans. From claude.com/pricing: Pro is $17 a month billed annually ($200 up front) or $20 monthly, Max (5x Pro usage) is $100 a month, Ultra is $200 monthly, and Team seats are $20 to $25 (standard) or $100 to $125 (premium) per seat a month depending on billing. The free plan does not include Claude Code. You can also run it against a Console API key or a cloud provider and pay per token; our Claude Code pricing page breaks those options down.

None of these include X data. Whatever harness you pick, the X reads are billed separately by whichever X data source the agent calls, which is the next two sections.

We searched X for posts containing both opencode and "claude code" (reposts excluded) and kept the latest 500 posts, from 402 distinct authors, covering 2.29 days, which works out to about 218.4 posts a day. A second pass took the 93 posts X ranks as Top for the same query. We tagged each post with transparent keyword rules (listed in results.json). Languages: 55.4% English, 24.2% Chinese, 4.8% Japanese.

Most posts are lists, not duels. 66.6% of the latest posts name three or more coding agents (median 3), and 55.2% also name Codex. Among Top posts the share rises to 80.6% and 72.0%. A typical post announces a skill, tool or model that "works in Claude Code, Codex and OpenCode". That is useful for builders: the ecosystem increasingly treats these harnesses as interchangeable hosts for the same skills and MCP servers.

Switching claims are rare. Only 1 of 500 latest posts used explicit switch phrasing toward OpenCode, and none toward Claude Code. People run both side by side more than they migrate.

Plugins and skills get the reach. Plugin or skill posts are 13.2% of the latest sample but 25.8% of Top posts, with a median of 611.0 likes there against 95 for all Top posts. Local-model posts follow the same pattern (5.6% latest, 11.8% Top).

The two official accounts post differently. @opencode (228,177 followers) published 90 original or quote posts over 81 days in our sample (about 1.11 a day) plus 64 reposts, and 47.8% of its own posts mention models or providers. @claudeai (1,990,991 followers) posted 149 over 270 days (about 0.55 a day), 56.4% of them with video against 8.9% for @opencode.

Relative to audience size, @opencode's posts draw about twice the median likes per follower, a sign of a small, highly engaged developer audience; @claudeai reaches roughly nine times as many followers with product videos.

The harness does not change the price of X data; the data source does. Through TwitterAPI.io, tweet endpoints (search, user timelines, mentions, replies, quotes, tweets by ID) cost 15 credits per tweet returned, which is $0.15 per 1,000 tweets. A full 20-tweet page costs $0.003; a request that returns nothing still bills the 15-credit minimum, $0.00015. Profiles are 18 credits each ($0.18 per 1,000), followers and followings 1 to 3 credits per user returned. $1 buys 100,000 credits, and purchased credits never expire. New accounts that pass the automatic bot check get up to $1 of free credits (at most 100,000 credits, no card, one per person or network, expiring after 31 days). Reads need no X account.

The official X API pay-per-usage rate card (docs.x.com/x-api/getting-started/pricing) charges $0.005 per post read, $0.010 per user read and $0.010 per follower or following read, capped at 3 million post reads a month before Enterprise. Per 1,000 tweets that is $5 against $0.15, about 33 times more.

Our own study is a concrete example: 56 requests returned 1,067 tweets and 2 profiles, which billed about 16,041 credits, roughly $0.16. The same reads at the official rate card would be about $5.35.

Mind the payload, not just the price. A raw 20-tweet search page from the REST API had a median of 105,138 characters in our sample, about 26,284 tokens at four characters per token (our estimate). That is above Claude Code's default 25,000-token MCP output cap and a large bite of any model's context in OpenCode. Whether you call the API from a plugin tool, a skill or a script, trim each tweet to the fields the task needs before the model sees it. The script below does that and works unchanged from either agent's shell tool.

If you need higher throughput, rate limits are 0.2 requests a second before the first payment, 20 once paid, 50 on Scale and 500 on Business; subscriptions run from Starter $29 to Business $1,499 a month (see the pricing page).

Question. When developers on X compare OpenCode with Claude Code, what do they talk about, how often do posts lean toward either tool, and how do the two official accounts differ? Plus: how much schema does one shared X-data MCP server add to either agent?

Sources and queries. /twitter/tweet/advanced_search with opencode "claude code" -filter:retweets (Latest, 500 posts; Top, 93 posts) and opencode plugin -filter:retweets (Latest, 160 posts); /twitter/user/last_tweets and /twitter/user/info for the official @opencode and @claudeai accounts (154 and 160 timeline posts). MCP sizing from an unauthenticated initialize and tools/list on mcp.twitterapi.io/mcp.

Window and size. The most recent posts at collection time; the latest comparison sample spans 2.29 days, the plugin sample 8.34 days, the Top sample reaches further back by design. 1,067 posts in total from 56 requests, collected in 2026.

What the sample cannot show. Keyword rules are blunt: a post that says "cheap" sarcastically still counts as price. The search returns what X indexes for the query, not every post. Short windows over-weight whatever launched that week. Engagement medians are skewed by a few viral posts. Nothing here measures which agent writes better code.

Privacy. Aggregates only. Search authors are private individuals, so their raw pages were never committed and the published sample.json holds de-identified rows (theme flags, language, like buckets; no IDs, URLs, text or handles). Only the two official product accounts are named.

Pick OpenCode if you want to choose the model per task (a frontier model for planning, a cheap open model for bulk edits), run local models, keep the whole setup in one schema-validated file, or extend the agent itself with code. Budget a little time for the V1 to V2 move if you copy older tutorials or plugins.

Pick Claude Code if you already pay for a Claude plan, want Claude models without managing keys, or want a packaged ecosystem: marketplaces, hooks with five handler types, skills and subagents with committed team settings. Do not plan on reusing the subscription inside OpenCode; OpenCode's own docs say Anthropic prohibits it.

Run both if that is what you already do; our X sample suggests many developers do exactly that. Keep shared instructions in a file both read, and attach the same MCP server to each so tools behave identically.

For X data in either one, create a key in the TwitterAPI.io dashboard, paste it as the Bearer token in the MCP config above or export it for the script, and read the endpoint reference at docs.twitterapi.io for every parameter. Searches, timelines and profiles return in the shapes shown here, billed per item returned.