I Got Tired of Guessing OpenCode Go Models — So I Built a Live Fit + Burn Dashboard
zp.svelte-apps.me · open source: github.com/Michael-Obele/zenpick
TL;DR
OpenCode Go is $10/month for 13+ curated open coding models — the first month is $5 anyway (their standard intro offer), and if you sign up through my link we each get an extra $5 credit on top. The hard part isn't the price — it's picking the right one without torching your quota. ZenPick is the focus here: it's a free, open-source dashboard that ranks every Go model by task fit and quota burn so you can decide in 10 seconds. Built with Svelte 5 + SvelteKit.
The decision that actually hurt
OpenCode Go is a strong deal. One subscription, $10/month, 13+ models. DeepSeek, Qwen, Kimi, GLM, MiMo, and more.
But Go usage limits are defined in dollar value, not request counts.
Pick a cheap workhorse and you can run tens of thousands of requests per 5-hour window. Pick a premium reasoning model and you might land under a thousand in the same window.
Same tier, wildly different economics. Pick wrong for a long agentic session and you can burn a large chunk of your monthly quota in an afternoon. Pick too cheap for a hard reasoning task and you waste hours on weak output.
The docs give you a markdown table. Cross-referencing benchmarks, request volume, pricing, and task fit across 13+ models in a table is a bad developer experience.
So I built ZenPick.
Three questions, answered fast
1. Which model fits my task?
Every model gets an algorithmic fit score (0–100) across six scenarios:
- Brainstorming — open-ended ideation, long context
- Coding — coding benchmarks + tools/speed/uptime fit
- Competitive — hard one-shot reasoning
- Agentic — long multi-step runs, stability signals
- Frontend UI — Design Arena Elo + intelligence + coding
- Budget — cheapest option that still ranks
Scores are weighted blends of real signals — Artificial Analysis TrueSkill for coding, Design Arena Elo for UI preference, context and tooling for agentic fit. Missing data doesn't zero a model out of the ranking. The table is never empty, and ordering stays meaningful.
2. How fast will it burn my quota?
Each model gets a thermal burn classification from blended price per million tokens:
- ❄️ Slow burn (< $1.50) — volume workhorse
- 🌡️ Moderate ($1.50 – $6.00) — daily driver
- 🔥 Fast burn (> $6.00) — premium / focused sessions
The table also surfaces request estimates per window so the economics are visible before you start a long run.
3. What does it replace from a closed-source workflow?
Open any row's detail drawer for migration hints — e.g. if you used a frontier Sonnet-class model, which Go model is the closest practical stand-in. Plus pricing, benchmarks, quota estimates, and one-tap model ID copy for your OpenCode config.
What actually shipped
Scenario pills + search. Tap Brainstorming, Coding, Competitive, Agentic, Frontend UI, or Budget. The table re-ranks by fit for that job. Search narrows by name or provider. You can go from "13+ models" to "two agentic options that won't torch quota" in a few seconds.
Sortable model table. Sort by name, benchmarks, price, quota requests, scenario fit, or burn. Scenario filter and sort are independent — e.g. Budget scenario, then sort by coding score.
Model drawer. Click a row for benchmark bars, pricing per 1M tokens, request estimates (5h / week / month), migration hints, Add to compare, and Copy model ID.
Side-by-side compare (up to 4). Open Compare. Each row highlights the winner; ties stay unhighlighted. Benchmarks, pricing, context, speed, burn, scenario fit, tags, and migration sit in one grid.
Ask AI. From compare, jump into Grok, ChatGPT, Claude, or Gemini with a pre-filled prompt that already includes the live ZenPick stats for the selected models. You bring the task; the context is already there.
Quota calculator. Estimate tokens per request for your session pattern and see how request counts shift. Official tables assume fixed patterns; real agent runs often don't.
The build
Stack: Svelte 5 runes · SvelteKit · Tailwind v4 · shadcn-svelte · Bits UI · Bun.
Remote functions for data. Model loading lives as a SvelteKit remote query, not a pile of ad-hoc client fetches. It fetches Go models, modelgrep, and llm-stats in parallel, matches each Go model across sources, runs inference (tags, scenario scores, burn, migration hints), and serves through a 6-hour stale-while-revalidate cache. So you get a fast page and data that isn't days old, without burning your own rate limits.
Multi-source blending, honest and field-specific. You can't naively average every benchmark. Methodologies differ.
| Field | Primary | Fallback / blend |
|---|---|---|
| Coding | modelgrep AA TrueSkill | llm-stats only if modelgrep missing — no average (different scales) |
| Reasoning | modelgrep AA TrueSkill | llm-stats only when outlier-safe |
| Math | GPQA + llm-stats math | Blend when both are 0–1 accuracy-style scores |
| Design Arena Elo | modelgrep | — |
False precision is worse than a clear primary source. The UI prefers honesty over a single "magic number."
Algorithmic scenario scoring. Each scenario has its own weighted blend. The Frontend UI score leans heavy on Design Arena Elo (human preference), with some general intelligence and a touch of coding. If every input is missing, the model gets a neutral floor (0.5) — not zero — so the table stays comparable. The pattern repeats for the other five scenarios with their own field weights.
Svelte 5 runes end-to-end. No legacy $: or export let. UI state uses $state / $derived / $props. Compare selection is a small client store; the compare route keeps ?models= in sync for shareable links.
What I learned
1. Benchmark field names lie. Upstream labels aren't always what they sound like. Verify what a score measures before you put it in a column header. One wrong label trains users to distrust the whole table.
2. Blending requires methodology discipline. Averaging TrueSkill-style ranks with 0–1 composites produces a number that feels precise and is nonsense. Field-specific primary/fallback rules beat "average everything."
3. Continuous fit scores beat tags. v1-style tag filters (coding, tools) go stale and create fake ties. A 0–100 score from live signals is harder to build and much more useful.
4. Stale-while-revalidate is the right default for this dashboard. Nobody needs millisecond-fresh Elo on every paint. They need a fast page and data that isn't days old. 6h TTL + SWR hits both.
5. Compare + Ask AI closes the last mile. A ranked table answers "what's good." A 4-model grid + a pre-filled AI chat answers "for my task, tonight, which two should I try?"
Quick picks (starting points — not guarantees)
Live scores move. Treat this as a compass, then verify in ZenPick:
| Use case | Start here |
|---|---|
| Daily workhorse / high volume | DeepSeek V4 Flash (slow burn, high request density) |
| Hard reasoning + tough coding | Qwen3.7 Max (premium; use deliberately) |
| Long agentic sessions | MiMo-V2.5-Pro or Kimi K2.7 Code |
| Max requests / tight budget | Cheapest strong coding option in the Budget scenario (often MiMo-class) |
| Frontend / UI generation | Highest Design Arena / Frontend UI fit in the current lineup |
If your real sessions disagree with the table, that's useful signal — open an issue.
Try it
- 🔗 Live: zp.svelte-apps.me
- 📦 Source: github.com/Michael-Obele/zenpick
- 📄 About / methodology: zp.svelte-apps.me/about
- ⚖️ Compare: zp.svelte-apps.me/compare
- 💰 OpenCode Go — $10/month, 13+ models. First month is $5 standard; my link adds another $5 credit on top (we both get it).
modelgrep and the OpenCode Go model list work without keys; llm-stats enrichment is better with an API key.
Already on GitHub Copilot in VSCode? You can route OpenCode Go through your existing setup with the opencode-go-copilot-provider extension — no separate config dance. (I use it myself; ZenPick picks the model, the extension routes it.)
Honest limitations
- Fit scores and burn tiers are derived, not hand-curated editorials.
- Benchmarks lag releases; a brand-new Go model may show thin data until upstream catches up.
- Request estimates depend on assumed token patterns — use the calculator for your workflow.
- ZenPick doesn't replace reading OpenCode Go docs for billing, privacy, and plan rules.
What's your biggest Go pain right now?
Is it picking the right model, budgeting the burn, migrating from a closed-source workflow, or something else entirely?
I'm collecting real stories from people using OpenCode Go to figure out what to build next. Drop a comment with your Tuesday problem — I'll dig into the patterns.
Built with Svelte 5, SvelteKit, Tailwind v4, shadcn-svelte, and Bun.
Data attribution: modelgrep, llm-stats, OpenCode Go — see the About page.
Top comments (0)