
A developer on LINUX DO, China's largest developer forum, threw down a provocation this week that drew 233 replies in days: if desktop AI coding clients now do everything the terminal does — parallel sessions, in-app viewing of web pages and images, smooth next-day resume — why are so many serious developers still living in the terminal?
The thread's answer, distilled: for the heaviest users, the terminal is faster, lighter, and scriptable in ways a window can't be — and the desktop's advantages solve problems CLI loyalists don't think they have. But the most interesting part of the debate isn't who wins. It's that the two sides are quietly converging, and the line between them is thinner than either admits.
The provocation didn't come out of nowhere. Desktop AI coding apps have matured fast. OpenAI's Codex desktop app — documented in OpenAI's developer docs — is explicitly built as a "command center" for running multiple agents in parallel: it organizes agents into separate project threads so you can switch tasks without losing context, keeps changes as reviewable diffs inside each thread, isolates parallel work with Git worktrees so two agents don't stomp on the same repo, and can even run scheduled automations that drop outputs into a review queue. You sign in with a ChatGPT account or an API key, and the whole thing behaves like a project dashboard rather than a chat box.
That's a strong pitch. The forum's desktop advocates added their own list: rendering web pages, images, and video inline (a terminal can paste a screenshot, but it can't show you one), easier resumption of yesterday's tasks, and the general polish that comes from a team designing every pixel. One common rebuttal to CLI speed claims: on any modern machine with 16GB or more of RAM, the desktop client runs smoothly — the "GUI is bloated" argument, they say, is a habit from the Eclipse era, not a measurement.
Desktop tooling keeps evolving in this direction. As we covered before, Google's Antigravity 2.0 doubled down on structured workflows like plan mode — the desktop-client worldview is that more structure is better.
The CLI loyalists didn't budge, and their arguments are concrete. Both flagship terminal agents are real, first-party products: OpenAI's Codex CLI (open source, Apache 2.0, installed with npm install -g @openai/codex and launched with a single codex command) and Anthropic's Claude Code (installed with npm install -g @anthropic-ai/claude-code, launched with claude). That one-command launch matters more than it sounds: when you're in a VS Code terminal mid-debug, the agent is already where the work is. No alt-tab, no context switch, no window management.
Then there's the scriptability gap, which desktop apps can't fully close. A terminal agent composes with everything Unix gives you:
# One-shot mode: no window, no session ceremony
codex "Fix the failing tests in auth/ and run the suite"
# Piping real data into the agent
git diff --stat | claude -p "Review this diff for risky changes"
Forum members hammered the same themes in plain language: the CLI uses less memory, starts instantly, embeds in the terminal they already live in, and — in a defense that drew laughs — "looks professional" in a screen share. The subjective stuff matters because these tools are used eight hours a day; developers pick the surface that disappears into their workflow.
Beneath the UI holy war, the thread kept circling the actual problem: session management. The original poster said he runs 7–10 parallel agent conversations a day. That's not a UI preference — it's a workload. Seven agents across four repos, each with its own branch, build state, and pending approval, is an orchestration problem that neither a plain terminal nor a tabbed desktop solves on its own.
This is where the thread got practical. Members pointed to a class of tools the desktop apps don't offer: terminal workspace managers built specifically for herding AI agents. The one that came up, herdr, is an open-source terminal multiplexer whose sidebar tracks each pane's agent state at a glance — working, blocked, waiting on input, or done — across sessions that survive laptop lid-closes and dropped SSH connections. It's essentially tmux redesigned around the idea that the thing running in each pane is an AI agent, not a shell. Third-party coverage notes it gathered tens of thousands of GitHub stars within months of its 2026 launch, and its docs describe a session → workspace → tab → pane object model that maps cleanly onto the multi-agent workflow the forum describes.
The takeaway from this section of the debate: the CLI side isn't winning on nostalgia. It's winning because an ecosystem of terminal-native tooling has grown up around the specific pain of managing many agents at once — pain that a prettier window doesn't address.
The thread's sharpest moment came when someone pointed out that the desktop side's best remote-work story is… the terminal in disguise. Codex's desktop app has a remote-SSH feature: it reads the host aliases from your ~/.ssh/config, starts a codex app-server process on the remote machine over an ordinary SSH connection, and renders the interface locally. All file work, shell commands, and agent execution happen on the server; the desktop app is just a rendering layer. Independent documentation of the mechanism — for example, the codex-remote project docs and the codex-shuttle README — describes exactly this architecture: the app server runs where the code is, the UI runs where you are, and nothing extra listens on the network.
The forum's verdict on this, in the thread's own framing: that's functionally identical to SSH-ing into a server and running the CLI. When the desktop app's killer remote feature is "your terminal, but rendered in a window," the two camps aren't arguing about different technologies anymore — they're arguing about window dressing. (Pun noted by the thread, not by us.)
This also connects to a broader pattern we've seen in the community: Chinese developers have a deep bench of remote-access tooling — from UU Remote and Sunflower to self-hosted RustDesk relays, which we decoded earlier — and the instinct to keep the heavy compute on a server while the interface follows the user is the same one.
Nobody in the 233 replies convinced the other side, which is itself the conclusion: the choice now depends on workload, not taste. Here's the honest scorecard that emerged:
| Terminal (CLI) | Desktop app | |
|---|---|---|
| Launch speed | Instant, one command, inside your existing terminal | App startup + window management overhead |
| Memory footprint | Minimal | Heavier, though fine on 16GB+ machines (per desktop advocates) |
| Parallel sessions | Strong with terminal managers like herdr | Built-in project threads + worktrees (Codex app) |
| Rich media | Can't render pages/images inline | Native inline viewing |
| Scriptability | Pipes, one-shot prompts, CI hooks | Limited |
| Remote work | SSH + CLI, the classic | Remote-SSH app-server rendering — same idea, prettier |
| Resume next day | Session restore via tools like herdr | Built-in thread persistence |
Two practical heuristics from the thread's consensus:
The provocative framing — "desktop does everything CLI does, so CLI is obsolete" — collapsed under its own weight, because the desktop's most compelling remote feature turned out to be a terminal wearing a costume. What the thread really documented is a shift in what "the terminal" means: less a black rectangle with a monospace font, more a design philosophy — fast to launch, scriptable, composable with everything, and increasingly managed by purpose-built tooling rather than endured raw.
The desktop apps aren't standing still either. Parallel project threads, worktrees, scheduled automations, inline media — each of these is a real answer to a real complaint. But the CLI loyalists' core insight survives every round of this decades-old debate, from editors to IDEs to agents: the tool that stays out of the way wins the heavy users. Right now, for the developers running ten agents before lunch, that tool is still the terminal.