Same DeepSeek Model, Two Shells: CLI Won Speed and Precision, GUI Won Polish
First published on the WeChat public account "逻辑与温度" (Logic & Temperature), synced to Juejin, hoping to help people torn between the two tools.
Conclusion first: the model didn't change; only the shell changed.
Over the past few months my daily coding driver was Claude Code, hitting DeepSeek through the API. Recently I switched my daily driver to DSH (DeepSeek Harness, DeepSeek's officially open-sourced agent tool with a desktop GUI; the model is configurable). The reason isn't "DSH is smarter" — both sides run the same DeepSeek model underneath; the intelligence is one and the same.
So what changed? I designed a real test costing less than ¥0.40: the same requirement, word-for-word identical prompts, sent to both shells, with full data logging.
What you get from this post:
① A directly copyable same-question test prompt set (three rounds) ② Complete CLI vs GUI working data: time, rounds, cost, to the minute ③ My judgment on "same brain, what the shell decides"
I. Test design: one brain, two shells
Fairness first; knowledgeable readers, keep an eye on me:
- Same model: both sides use deepseek-flash (screenshots prove it)
- Same prompt: word for word, pasted directly
- Same day, each opened a fresh conversation, no extra hints in between
The task chosen was "build a page" rather than writing an algorithm — a practical reason: whether a page looks good, readers can judge from a screenshot at a glance; whether code is good requires readers to verify the logic for me, a high bar.
Round 1 prompt (copyable):
Make a personal introduction single-page website:
1. Single HTML file, opens directly in a browser, no external dependencies
2. Include: top avatar placeholder and name, one-line personal intro,
tech-stack tags (8~10), three project cards (title + two-line description),
and bottom contact info (email/GitHub placeholders)
3. Clean modern style, pick your own colors
4. When done, tell me the file name and where it is
II. Round 1: one "Chen Mo", one "Lin Yizhou"
Both sides: one round of conversation, zero errors, passed on the first try. The interesting part is the process data:
| Claude Code (CLI) | DSH (GUI) | |
|---|---|---|
| Time | 28 seconds | 58 seconds |
| Rounds | 1, passed | 1, passed |
| Errors/rework | none | none |
| Consumption | ~76K tokens | ~56K tokens |
| Cost | ~¥0.085 | ¥0.095 |
| Cache hit rate | 68.2% | 95.8% |
| Output tokens | ~4,400 (323 lines) | 11,134 (430 lines) |




Number precision notes: the CLI-side 76K tokens is Claude Code's own context count; the platform bills by metering (including cache reads and writes), so the two don't add up. Fees always follow the platform bill; the CLI's ¥0.085 is derived by subtracting the DSH charge from the total bill, hence the "~" mark; DSH numbers display directly in the interface.
Two counterintuitive points, put out front:
① Fast and cheap is the CLI, not the GUI. 28 seconds vs 58 seconds, and cost is slightly lower too. I assumed "GUI tools are faster" — the data disagrees: the CLI has no interface rendering or extra interactions, so it works more like a bare-naked sports car.
② DSH is slower because it writes more. Output tokens are 2.5x the CLI's, and the code is more than 100 lines longer — the extra isn't filler: entrance animations, favicon, keyboard focus styles, things the prompt never asked for.
What the results look like

Claude's version (the page's virtual persona is "Chen Mo") is a clean engineer business card: light card, indigo accents, complete info, at a "won't embarrass you in public" level.

DSH's version ("Lin Yizhou") clearly did one more layer of design: the small eyebrow text "HELLO, I'M", numbered 01/02/03 project cards, categorized tags, bottom contacts as buttons — every one of these wasn't in the prompt.
I misread the code at first
Initially I only looked at rendered screenshots and assumed the Claude version's project cards had "text overflow as a bug." Opening the source showed both sides used -webkit-line-clamp: 2 for two-line truncation — that's design, not a defect. I was hasty.
Code quality otherwise ties: CSS variables, semantic tags, responsive layout, prefers-reduced-motion all present. The difference: DSH added favicon, meta description, entrance animation, focus-visible focus styles — one sentence:
Same model: under a CLI shell it defaults to "the engineer delivering features"; under a GUI shell it defaults to "the developer publishing work."
Round 1: DSH wins on the deliverable; CLI wins on speed and money. The real watershed is round 2 — changing requirements is the norm in daily use.
III. Round 2: changing requirements is the mirror
Round 1 compared "building from zero"; daily use is more "modifying code written by others (or itself)." Round 2's prompt, again word for word:
Change two things:
1. Change the colors to dark mode
2. Add hover animations to the three project cards (e.g. slight lift + shadow)
Result: both passed in one round, zero errors, nothing broke. But the process data keeps widening the gap:
| Claude Code (CLI) | DSH (GUI) | |
|---|---|---|
| Time | 24 seconds | 30 seconds |
| Rounds | 1, passed | 1, passed |
| Edit style | surgical diff: minimal add/remove (color block: 9 added, 8 removed) | broad adjustment: +27 / −24 lines |
| Cost | ~¥0.044 | ¥0.056 |
| Tokens | 206K (7 small requests) | 58K |
| Cache hit | 99.0% | 99.2% |




Two details worth separate mention:
① The CLI's "surgical" editing. It doesn't rewrite files; it touches only what needs changing — the color variable block: 9 lines added, 8 removed, nothing else. Very much an old-school backend code review instinct: the less you change, the lower the chance of introducing new problems.
② The CLI burns tokens like water, yet spends less. Round 2 it consumed 206K tokens, 3.5x DSH's — but 99% went through cache, so the bill still came out lower than DSH's. Agent-style workflows are "many small requests" that keep re-reading context; once the cache is warm, costs drop. Consuming more isn't spending more; look at the bill, not just tokens.
Dark-mode result comparison


Both dark modes hold up: the CLI brightened the indigo accent for contrast and adapted the tech-stack tag hover to dark mode; DSH kept every round-1 design detail — eyebrow text, numbered badges, gradient avatar, with the top gradient bar sliding in from the left on hover (0.25s). Hover effects actually fire on both sides; neither cheated.
Round 2 sees no reversal: the CLI takes back speed, cost, and edit precision; DSH keeps deliverable quality.
At this point two rounds total ¥0.28 — 28 cents for four complete pages and a full set of real data. The test may cost less than a bottle of cola.
IV. Round 3: add an animated skills section
Rounds 1 and 2 cover "create" and "modify"; round 3 adds the third daily scenario: adding a complex new section to the page (layout + animation logic together), the type most prone to failure:
Add a skills progress-bar section, a percentage bar for each skill, animated from 0 to the target value
Result: both passed once again, zero errors. This time I focused on how the animation was implemented:
| Claude Code (CLI) | DSH (GUI) | |
|---|---|---|
| Time | 22 seconds | 29 seconds |
| Rounds | 1, passed | 1, passed |
| Edit style | precise insert +50 lines | whole-block insert +95 lines |
| Animation | transform scaleX (compositor layer, no reflow), width driven by CSS var --level |
CSS animation with staggered delays |
| Cost | ~¥0.035 | ¥0.045 |




Two points worth pausing on:
① The CLI's animation is "browser-aware." The most obvious way to animate a progress bar is animating width — every frame triggers reflow; the CLI chose transform: scaleX, so the animation runs on the compositor layer, the GPU does the work, the main thread never reflows once, plus an easing curve and a fallback. Honestly, for a single progress bar, the two look identical to the eye; the difference shows when pages get complex and animations multiply — this is writing for the future. A "page writer" defaulting to that instinct signals some professional literacy.

Same progress-bar animation, two implementations — left runs on the compositor without reflow; right is the more direct width approach, perfectly adequate for a small page.
② Both sides even thought of accessibility identically. With "reduce motion" enabled in the system, both show the final value directly without animation — nobody asked; they added it themselves. Same brain, same baseline.


Three-round totals
| Claude Code (CLI) | DSH (GUI) | |
|---|---|---|
| Total time | 74 seconds | 117 seconds |
| Total cost | ~¥0.16 | ~¥0.20 |
| First-try pass | 3/3, zero errors | 3/3, zero errors |
| Deliverable quality | adequate, clean | noticeably more polished |
| Edit precision | surgical | broad adjustment |
Three rounds total ¥0.36, six page states, zero errors, zero rework. The scoreboard is clear: speed, cost, edit precision, engineering details — the CLI wins all three; deliverable quality — DSH runs away with it; stability and accessibility baseline — a tie.
V. In conclusion: data is data, feel is feel
Let me admit a fact first: on code quality, Claude Code clearly thought more completely in this test — animation on the compositor, precise and restrained edits, more direct and efficient logic. If your main battlefield is server-side and engineering logic, the CLI is still my recommendation.
But I switched my daily driver to DSH anyway. Three real reasons, things data can't measure, only felt after a week of use:
① Operation is genuinely simpler. Clicking buttons and filling config in a GUI vs typing commands in a terminal is a different mental load. After a day of writing code, fiddling with tools at night, I pick the lighter one.
② Cache hits are higher. Across all three rounds, DSH's cache hit sat at 95~99%; the CLI only hit 68% in round 1. Single tests make the CLI cheaper, but with long-term high-frequency use, the cache-hit gap slowly clawed back on the bill.
③ The desktop client keeps operation history. What was done, which version was changed, easy to scroll back through; scrolling terminal history gets annoying fast. For this one alone, my daily-tool scale tips to the GUI.
So my conclusion isn't "who's stronger, who's weaker" — it's division of labor:
Code-level tasks, batch modifications, engineering logic — CLI takes the stage; pages, demos, tasks with visible results — DSH takes the stage.
Switching tools never changes the model's intelligence; it changes the "few extra steps it takes by default," and whether you're willing to open it every day.
The three test prompts are all above. Copy them, run your own version for ¥0.36, and come back to share your results.
Disclaimer: the test is personal; model versions and prices follow each official page; cost data comes from the test-day bill, and results may differ under different usage structures.
Interact with me: CLI camp or GUI camp? Comment with your real reason for switching — saving effort, saving money, or just looking cool.
About me: 10-year Java backend, daily in DSH / Claude Code / DeepSeek writing code and debugging. The public account "逻辑与温度" continuously documents AI tools in real development — Codex with DeepSeek, DSH plugin development, WeChat mini-program AI practice, agent building, all covered. Year 10 of writing code, turning AI into leverage.
If this post helps you choose a tool, find me on the public account; updates come more often there.
