I ran a small N=1 bake-off on a real feature, not a toy repo. Posting here because OpenCode was one of the four stacks, and the OpenCode + DeepSeek combo was interesting on cost/speed.

## What I was building

Remote-node install for SuperDev (a local/remote runtime control plane I work on):

- remote nodes run the SuperDev agent only (no desktop UI)
- connection is TLS
- local desktop needs to install MCP / skills / hooks onto the remote node over the API, so coding agents can use them without a GUI on the remote machine

So: real product surface, multi-step implementation, install/uninstall paths that have to actually work.

## Method (important)

- Spec + plan: written with Superpowers (Fable 5)
- Implementation: four tools in parallel, each on its own git worktree + branch
- Workflow: `superpowers:executing-plans` via subagents
- Same plan for everyone — this is a race of **model + coding agent + Superpowers execution loop**, not raw chat IQ

Stacks:

| Agent | Model |
|---|---|
| Claude Code | Claude Opus 5 (xhigh) |
| Codex CLI | GPT-5.6 Luna (max) |
| Grok Builder | Grok 4.5 (high) |
| **OpenCode** | **DeepSeek V4 Flash (max)** |

## Results

### Time to finish

| Stack | Time |
|---|---|
| Grok 4.5 (high) | 2h 7m |
| **OpenCode + DeepSeek V4 Flash** | **~4h** |
| GPT-5.6 Luna (max) | 11h 19m |
| Claude Opus 5 (xhigh) | 11h 35m |

### Tokens

| Stack | Total | Input | Output | Cached input |
|---|---:|---:|---:|---:|
| Grok | 46M | 45.84M | 426.8K | 42.07M |
| **OpenCode + DeepSeek** | **261.2M** | **260M** | **1.2M** | **257.6M** |
| Claude | 452.8M | 451.91M | 858K | 439.33M |
| GPT-5.6 | 599.67M | 597.98M | 1.69M | 583.64M |

On this run, wall-clock time and token volume mostly moved together. Most of the huge totals were cached input from long agent loops.

### Cost (messy reality)

| Stack | What I actually felt | Rough $ |
|---|---|---|
| Grok | ~20% of SuperGrok weekly ($30 tier) | ≈ $1.5 (API-ish ≈ $23) |
| **OpenCode + DeepSeek** | dedicated API key for clean accounting | **¥9.97 ≈ $1.46** |
| GPT-5.6 | ~35% of Plus weekly quota | ≈ $1.75 (API-ish ≈ $16.57) |
| Claude | ~8% of Max 20x weekly | ≈ $4 (subagents mixed models; pure API hard to price) |

Subscription % and API $ tell different stories. DeepSeek was the cleanest “I know exactly what I spent” number because I isolated the key.

### Bugs / fix passes / mid-run questions

| Stack | Bugs after first finish | Fix passes | Questions mid-run |
|---|---:|---:|---:|
| Grok | 2 | 3 | 0 |
| **OpenCode + DeepSeek** | **3** | **2** | **2** |
| GPT-5.6 | 1 (+1 polish item) | 1 | 2 |
| Claude | 1 | 1 | 4 |

OpenCode + DeepSeek finished second-fastest, but had one more bug than Grok: a skills install `No such file or directory` path issue. It also asked twice mid-run (Grok asked zero).

### Independent review ranking

A separate review pass (Fable 5) scored completeness / conventions / correctness / tests / extensibility:

1. Claude Opus 5  
2. GPT-5.6 Luna  
3. **DeepSeek V4 Flash (OpenCode)**  
4. Grok 4.5  

Almost the inverse of speed.

My own smoke test (install/uninstall on Claude Code, Codex, and OpenCode) matched the “usable after fixes” claim for those three.

## Caveats (please read)

- One shared bug across all four was already wrong in the plan. Not any agent’s fault.
- Grok and DeepSeek shared a Claude Code MCP install path bug.
- GPT’s remaining polish: switching remote machines still needed one manual refresh.
- This is N=1 on one feature and one plan style. Don’t overgeneralize.
- I’m the SuperDev author, so treat product context as background for the task — the comparison is about agent stacks on the same plan.

## OpenCode-specific takeaway

For this workload, OpenCode + DeepSeek V4 Flash looked like the “value / speed” slot:

- much faster than Claude Code / Codex on the same plan
- real money out of pocket stayed low (~$1.46)
- quality was mid-pack: more bugs than Claude/GPT, better review score than Grok
- still landed in a usable install/uninstall state after fixes

What I disliked across the whole experiment wasn’t OpenCode specifically — it was how slow Superpowers-style plan → subagent execution felt end-to-end. I also tried a fuller grill-me style loop; still not fast. I’m currently thinking about a lighter development loop that keeps the guardrails without as much ceremony.

## Questions for this community

1. For long multi-hour OpenCode tasks, are you usually bottlenecked by **model quality**, **provider latency/cost**, or **the plan/subagent workflow** itself?
2. Anyone else running DeepSeek V4 Flash as the default OpenCode workhorse for multi-hour implementation jobs? What’s your failure mode?
3. If you’ve compared OpenCode against Claude Code / Codex on the *same* written plan (not vibes), what held up?

Happy to answer method questions. Not sponsored; not claiming this is a benchmark.

N=1: OpenCode + DeepSeek V4 Flash vs Claude Code / Codex / Grok on the same Superpowers plan (real feature, ~4h, ~$1.46)