Cross-posted from The Call Center Doctors: DeepSeek vs Opus: The Numbers Don't Add Up. The original has the full fact sheet.
We rented 4 H200s to replace Claude with DeepSeek. We measured everything. It was not close.
The plan sounded great on paper: run DeepSeek V4.1 Flash (763B parameters, 1M-token context) on our own rented GPUs, point Claude Code at it, run 64-128 robot coders at once, and save a fortune. Here is what actually happened on 2026-09-27, with the real numbers.
Tale of the tape
| DeepSeek V4.1 Flash (4x H200, $9.19/h) | Opus 5.5 (our Claude Code plans) | |
|---|---|---|
| First reply, typical | 12.8 s | 3.5 s |
| First reply, slow | 56.6 s | 9.6 s |
| Writing speed per call | ~8 tok/s | ~85 tok/s |
| Conversation it was reading (median tokens) | 24,000 | 542,000 |
| Hard terminal coding score (public) | ~31 | ~66 |
| Cost per merged change | $1.15-$4.90 (estimate) | about $1 |
| Code changes shipped | 0 | 5,610 |
The official verdict from the owner: "it sucked ass." Back to Opus 5.5 on high.
Round 1: latency
From real logs: 26,680 Opus 5.5 calls vs 853 DeepSeek robot calls. DeepSeek took 12.8 s to say its first word on a typical call and 56.6 s on a slow one. Opus: 3.5 s and 9.6 s. Almost a full minute of silence is not a coding assistant, it is a hold queue.
Fairness note: the robots were 48-64 at once sharing one box. A lone stream on the box did ~105 tok/s.
Round 2: speed
Opus 5.5 wrote ~85 tokens a second per call while reading a median 542,000-token conversation. DeepSeek on the shared box wrote ~8 tokens a second while reading 24,000. Opus types faster while reading conversations 20x longer.
Round 3: brains
Public hard terminal coding scores: ~31 for DeepSeek Flash, ~66 for Opus 5.5. 763B parameters, only 8-16B active per token, and half the score.
Round 4: cost per shipped change
Not per token. Per code change that actually merged.
- Our Claude subscriptions in September: 5,610 changes merged, 5 reverted, about $1 per merged change.
- DeepSeek's sticker is $0.60 per MILLION output tokens ($0.15 new input, $0.003 cached, off-peak; doubled at weekday peak).
- Same tokens per change on DeepSeek's API would be about $0.63. But DeepSeek needs more tokens per shipped change (tester, builder, reviewer, retries: 1.5-3x), finishes fewer jobs (assume 50-90% of Claude's success rate), and Claude still has to check its work (+$0.10-0.30).
- Best case $1.15, middle ~$2.40, worst ~$4.90 per merged change.
Those last steps are estimates, because DeepSeek never merged a change for us.
Round 5: shipping
DeepSeek, lines of code shipped: zero. Opus 5.5 in September: 5,610 code changes merged, 3.19 million lines added, 5 reverted.
The expertise tax: 5 starts to say hello
Self-hosting is not a download. It is a job. The released vLLM could not even run the model; it needed the 0.30.1 nightly build. Then ~511 GB of weights at ~600 MB/s, then ~10-15 minutes of loading per start, because the expert weights ship in 4-bit and get converted to 8-bit on the CPU. Then:
- Start #1: out of GPU memory. A speed trick called "adaptive verification" ate 41 GB per card. Dead after ~41 minutes.
- Start #2: froze while recording its GPU shortcuts. The owner: "dont restart anything let it go". We sent deep-research robots. They found the killer: the same adaptive-verification setting.
- Start #3: crashed on a memory setting we borrowed from an H100 recipe. It breaks the cards talking to each other.
- Start #4: worked! Model live 2 h 03 min after renting. Then we threw 256 robots x 1,500-token answers at it and found the box's limit.
- Start #5: 128 robots at most, 90% memory. It stayed up.
Bonus chaos: a progress bar that said "48/48 files" long before the weights were really loaded, and our own cleanup script matched its own command line and killed itself.
The flex
Each test measured alone, one minute, 0 errors:
- Reading brand-new text: 16,621 tokens/s (1.44 billion a day)
- Re-reading saved text (cache): 521,027 tokens/s (45 billion a day)
- Writing: 5,281 tokens/s (456 million a day); record 5,871/s at 129 robots
- Normal robot mix, 48 robots: 11,196 new + 131,904 re-read + 521 written per second
GPUs at 100% and ~600 W each. Looks unstoppable. Hold that thought.
The catch: real work is all three at once
Our real Claude Code September (Sep 1-27, one server): 96% of all input is re-reading old conversation. One average call re-reads ~196,000 tokens before it writes anything. Per 1 token written, Claude reads 41.6 new + 1,042 old.
The formula
Every token costs box time, taken from the single-kind tests:
new token = 1 / 16,621 s = 60 microseconds
re-read token = 1 / 521,027 s = 1.9 microseconds
written token = 1 / 5,281 s = 189 microseconds
one unit of our real work = 1 written + 41.6 new + 1,042 re-read
(41.6 x 60) + (1,042 x 1.9) + (1 x 189) = ~4,692 microseconds
1,000,000 / 4,692 = ~213 written tokens per second, whole box
= ~20B tokens per day in total
Check against the live mixed test: 11,196/16,621 + 131,904/521,027 + 521/5,281 = 1.026. The formula matched reality within 3%.
Four of the most powerful GPUs you can rent, pinned at 100%, and on real coding work they top out around 213 written tokens a second, for everyone on the box combined. Opus writes ~85 tokens a second for each call.
New tokens cost ~30x more box time than re-reads, and every Claude Code call brings ~7,800 genuinely new tokens. That is why real coding mixes saturate so low.
We rented a tie
| per day | |
|---|---|
| The box, busy or not | $220 |
| A full 100%-busy day of box work, at DeepSeek's own per-token prices | $184-$223 |
Even pinned at 100% all day, the box only ties DeepSeek's own API. At our real average load (~57% busy) the box costs about 2x the API for the same work.
"But paying per token is 80x cheaper"
The 80x sticker compares against Claude's posted per-token price, a price nobody on a Claude Code plan pays. Priced at list, our team's September would have been $154.6K-$197.8K. Our plans cost about $5.5K, which is 28x-36x cheaper than list.
Same September on DeepSeek's pay-per-token service: $3.5K off-peak, $7.0K at peak hours. So "cheaper" is at best a small maybe. And per shipped change, DeepSeek loses: $1.15-$4.90 vs about $1.
The safety plot twist
48-64 reviewer robots read 2,377 folders of our code and filed 32 bug reports. Fine. But the reviewers of the robot sandbox kept finding ways robot code could escape -- for example, a settings file dropped in a shared temp folder could make robot code run as the admin. So the builder robots never got switched on. DeepSeek shipped zero lines of code.
Then, after ~3 hours and ~$28, the spare-capacity box was taken back by the provider minutes after the last test. Even the GPU left us.
The one question
What does ONE shipped change cost? DeepSeek V4.1 Flash: $1.15-$4.90, and it shipped zero. Opus 5.5: about $1, with 5,610 merged and 5 reverted.
Ask that before you switch models. Not the sticker. Not the tweet.
Price per token is a lie. Price per shipped change is the truth.
All numbers were measured on 2026-09-27 and from our own September (Sep 1-27, one server). The full fact sheet with every number lives on the original: DeepSeek vs Opus: The Numbers Don't Add Up by The Call Center Doctors.
Top comments (0)