The question people ask is "is the command line faster than the browser chat?" It is the wrong question, and answering the right one changes how you pick a tool.
The interesting difference is not the terminal versus the browser. It is whether the tool closes its own loop. A plain web chat makes you the hands: you copy code out of the chat window, paste it into a file, run it, read the error, and paste that back in. An agentic tool, whether it runs in your terminal or in a cloud sandbox, does all of that itself. It reads the files, writes the changes, runs the tests, reads the output, and tries again. Removing that copy, paste, and re-type round trip is the single biggest wall-clock difference, and it is far larger than any raw model-speed gap.
This post compares eight coding stacks as they actually ship in July 2026: Anthropic's Claude Code, OpenAI's Codex, Google's Gemini, GitHub Copilot, xAI's Grok, plus three open-weight labs that reset the cost math entirely, Moonshot's Kimi, Alibaba's Qwen, and DeepSeek. For each one I look at the terminal CLI, the browser or GUI surface, the current model, the cost, and the speed. Then I get into the part most comparisons skip: where your code physically goes when you hit enter, and whose law governs it once it lands.
The one distinction that explains the speed
Anthropic describes its own loop plainly: unlike a chatbot that answers and waits, the agent can read files, run commands, make changes, and work through the problem on its own. The loop is three phases on repeat. Gather context, take an action, verify the result, and keep going until the task is done.
The reason that loop works without a human babysitting it is that command output is machine-checkable. A shell command that exits with code 0 succeeded; anything above 0 failed. The agent reads that exit code, sees the failing test, and corrects itself. Text streams like stdout and grep and pipes are the native shape of what a language model already does well, so a terminal agent can search, filter, and edit a real repository directly instead of reasoning over a pasted snippet. That is the mechanism. It is not magic and it is not the color of the terminal.
Terminal-native is now the default across every major vendor, not a niche for shell diehards. Claude Code, Codex CLI, Gemini CLI, and the GitHub Copilot CLI all act on the filesystem and run commands. GitHub even describes its CLI as having grown from a terminal assistant into a full development environment that plans, builds, reviews, and remembers across sessions without leaving the terminal.
But the bigger throughput lever is not per-task latency at all. It is parallelism. Claude Code fans work out to sub-agents that run at once; the Copilot CLI has a fleet mode that runs parallel sub-agents; Codex runs many isolated cloud tasks side by side. The productivity gain people keep describing is the ability to start several jobs and go do something else while they run. Wall-clock throughput goes up even when any single task is slower.
And this is where the browser stops being the slow option. Async cloud agents took the copy-paste tax out of the browser too. OpenAI's Codex cloud, Google's Jules (generally available since August 2025), GitHub's Copilot coding agent (generally available since September 2025), and Claude Code on the web each spin up an isolated sandbox loaded with your repository, run the tests, and open a pull request for you to review. You can kick those off from a web page, or from a phone. So the honest conclusion is this: the speed edge belongs to loop-closing agentic tools, whether they live in a CLI or in the cloud. The slow case is a plain conversational web chat, not "the browser" in general.
An honesty check before the tables
I could not find a single rigorous, published benchmark that measures task-completion time for "terminal agent versus browser web chat." The productivity studies that exist measure something else: AI versus no AI, or agent adoption in general. If you see a clean number claiming the CLI is some exact percentage faster than the web chat, treat it as an architectural argument or a vibe, not a measured result. (One viral "141 seconds versus 288 seconds" figure gets passed around as a CLI-versus-GUI result. It is not one. It describes screenshot-driven computer-use agents, a different comparison, so I am leaving it out.)
Worse for the simple story, the best controlled evidence we do have cuts against blanket speed claims. METR ran a randomized trial in July 2025 with 16 experienced open-source developers working real issues in their own familiar repositories. Allowing early-2025 AI tools made them 19 percent slower, even though they believed the AI had made them about 20 percent faster. Speed depends heavily on the task and on how well you already know the codebase. On mature code you know cold, the agent loop can add net overhead. (METR revised its experiment design in early 2026, and the study predates today's agentic tooling, so read it as a caution, not a verdict.)
The adoption numbers set the context. Stack Overflow's 2025 survey of more than 49,000 developers found 84 percent use or plan to use AI tools, and 51 percent of professionals use them daily, but fewer than one in three trust the accuracy of what the AI produces. Google's 2025 DORA report calls AI "the great amplifier": it raises delivery throughput and, without strong testing and version control, lowers stability at the same time. None of that is a terminal-versus-browser finding. It is a reminder that your interface choice matters far less than the engineering around it.
So the browser GUI genuinely wins on real axes, and any fair comparison has to say so. It takes screenshots, PDFs, and Figma mocks as input with zero setup, which the terminal is bad at. It needs no local install, auth, or shell fluency, so it is faster for beginners, one-offs, and repos you have not cloned. It renders a visual diff you can actually read, which matters a lot when trust is low. And it works from a phone. Keep all of that in mind as the tables below lean, correctly, toward loop-closing tools.
The eight stacks, side by side
Every one of these ships both a terminal path and a browser or GUI path. What separates them is whether they also run a first-party async cloud agent that opens pull requests on its own, which model they default to, and how big a context window you get.
| Vendor and tool | Terminal CLI (July 2026) | Browser / GUI surface | First-party async cloud agent | Default or flagship coding model | Context |
|---|---|---|---|---|---|
| Anthropic Claude Code | claude v2.1.218 (npm i -g @anthropic-ai/claude-code, or native installer) |
claude.ai/code, Desktop app, VS Code + JetBrains, iOS/Android, Slack | Yes: Claude Code on the web, runs on Anthropic-managed VMs | Opus 4.8 default (Sonnet 5 on Pro); Fable 5 is the most capable | 1M |
| OpenAI Codex | Codex CLI v0.145.0 (npm i -g @openai/codex) |
chatgpt.com/codex, ChatGPT desktop app, VS Code + JetBrains, GitHub | Yes: Codex cloud, many parallel sandboxes | GPT-5.6 Sol at medium effort | ~1.05M per model spec (about 372K surfaced inside Codex) |
| Google Gemini | Gemini CLI v0.52.0 (npm i -g @google/gemini-cli) |
gemini.google.com, AI Studio, Code Assist in VS Code / JetBrains | Yes: Jules, generally available since Aug 2025 | Gemini 3.1 Pro (auto-picks a Flash tier for speed) | 1M |
| GitHub Copilot | Copilot CLI v1.0.73 (npm i -g @github/copilot) |
Copilot Chat on github.com, VS Code / Visual Studio 2026 / JetBrains, Spaces | Yes: Copilot coding agent, generally available since Sept 2025 | Auto; picker spans Opus 4.8 / Sonnet 5, GPT-5.6, Gemini 3.1 Pro, Kimi K2.7 Code | model-dependent |
| xAI Grok | Grok Build CLI (unversioned public beta; Apache-2.0 since July 2026) | grok.com, Grok on X, xAI console | No first-party cloud agent, and no first-party IDE plugin (third-party via API) | grok-4.5 for depth, grok-code-fast-1 for speed | 500K (grok-4.5) |
| Moonshot Kimi | Kimi Code CLI v1.49.0 (Apache-2.0 repo; also driven through Claude Code) | kimi.com web chat, "OK Computer" agent mode | In-browser agent mode only, no PR-opening cloud agent like the four above | Kimi K2.7 Code, or K3 for long-horizon work | 256K (K2.7 Code), 1M (K3) |
| Alibaba Qwen | Qwen Code CLI v0.20.1 (npm i -g @qwen-code/qwen-code) |
chat.qwen.ai, Model Studio console, ModelScope | No first-party PR agent | Qwen3-Coder-480B (alias qwen3-coder-plus) |
256K native, up to 1M extended |
| DeepSeek | No first-party CLI; Claude Code pointed at api.deepseek.com/anthropic |
chat.deepseek.com, platform console | No | DeepSeek-V4-Pro for depth, V4-Flash for speed | 1M |
A few things worth calling out from that grid. Grok is the outlier on surfaces: it ships a capable local CLI (Grok Build races up to eight sub-agents in separate git worktrees), but it is the only one of the five big vendors with no first-party async cloud agent and no first-party IDE extension. Its IDE story runs through third parties like Cursor and Cline over the xAI API. Kimi has a real agent mode in the browser called OK Computer that can build multi-page sites on its own, but it is not the same as a cloud agent that clones your repo and opens a pull request. And DeepSeek ships no terminal tool of its own at all; the normal path is Anthropic's Claude Code pointed at DeepSeek's Anthropic-compatible endpoint, which DeepSeek documents but explicitly disclaims as a third-party agent.
On models, note two corrections to the version numbers that float around. Codex's "272,000" figure is not its context window; it is the pricing threshold above which long-context requests cost more. The GPT-5.6 model spec is about 1.05 million tokens, and Sol currently surfaces roughly 372K inside Codex. And Google's current flagship Pro is Gemini 3.1 Pro (in preview since February 2026), not the older Gemini 3 Pro; a further Gemini 3.5 Pro was announced but had not reached general availability by mid-July.
Cost: where the open-weight labs rewrite the math
This is the table that changes decisions. Prices are per one million tokens, input then output, in US dollars, as listed by each vendor in July 2026. Where a cached-input price matters, I have included it, because on long agentic runs the cache discount is often the biggest single lever on your bill.
| Model | Input / output per 1M | Cached input | Notes |
|---|---|---|---|
| Claude Opus 4.8 | $5 / $25 | reads about 0.1x | Anthropic's default in Claude Code on higher tiers |
| Claude Sonnet 5 | $3 / $15 (intro $2 / $10 through Aug 31, 2026) | reads about 0.1x | Default on Pro seats |
| Claude Haiku 4.5 | $1 / $5 | reads about 0.1x | Fast tier |
| Claude Fable 5 | $10 / $50 | reads about 0.1x | Most capable, not a default |
| GPT-5.6 Sol | $5 / $30 | (standard tier) | Codex default |
| GPT-5.6 Terra | $2.50 / $15 | Balanced | |
| GPT-5.6 Luna | $1 / $6 | Fast and cheap | |
| Grok grok-4.5 | $2 / $6 below 200K, then $4 / $12 | $0.30 / $0.60 | 500K context, tiered |
| Grok grok-code-fast-1 | $0.20 / $1.50 | $0.02 | The speed and price play |
| Grok grok-build-0.1 | $1 / $2 below 200K, then $2 / $4 | $0.20 | Powers the Grok Build CLI |
| Kimi K2.7 Code | $0.95 / $4.00 | $0.19 | Thinking mode is always on |
| Kimi K3 | $3 / $15 | $0.30 | 1M context, newest flagship |
| Qwen3-Coder-480B | $1 / $5 (0 to 32K) rising to $6 / $60 (256K to 1M) | $0.10 to $0.60 by tier | Whole request bills at the input-size tier |
| DeepSeek-V4-Flash | $0.14 / $0.28 | $0.0028 | Extremely cheap high-throughput tier |
| DeepSeek-V4-Pro | $0.435 / $0.87 | $0.003625 | Reasoning and agentic-coding flagship |
Sit with the spread for a second. DeepSeek-V4-Flash at 14 cents in and 28 cents out is roughly 35 times cheaper on input and about 90 times cheaper on output than Claude Opus 4.8, and its cache-hit input price drops to a quarter of a cent per million tokens. Qwen and Kimi land in between, an order of magnitude under the US flagships. And because Qwen, Kimi, and DeepSeek all publish open weights under permissive licenses, self-hosting them costs only your own compute, with no per-token charge at all.
That does not make them a drop-in swap for every job. The frontier US models still lead on the hardest agentic tasks, and, as the jurisdiction section below explains, the cheap first-party API has a cost that does not show up on the invoice. But for high-volume, lower-stakes work, the price gap is real and large.
On the subscription side, if you would rather pay a flat monthly fee than meter tokens: Claude Pro is $20 a month and includes Claude Code; ChatGPT Plus is $20 (Codex Pro tiers run $100 to $200); Google AI Pro is about $20; GitHub Copilot Pro is $10 (with unlimited code completions plus a pool of AI credits, where one credit equals one cent). Grok's coding CLI comes with SuperGrok at $30 a month or X Premium+ at $40, with a SuperGrok Heavy tier listed at $300. Kimi's web tiers run from a free plan up to roughly $99. Qwen sells a coding plan at about $10 for the Lite tier and $50 for Pro. DeepSeek sells no subscription at all: the web app is free, and everything else is metered API.
A note on Copilot's billing, because it changed. As of June 1, 2026 Copilot moved from counting "premium requests" to usage-based AI credits. Code completions and next-edit suggestions stay free on every paid plan and burn no credits; chat, agent mode, code review, and the Copilot CLI all draw from the credit pool.
Speed, told honestly
Since there is no clean head-to-head benchmark, here is the comparison that is actually defensible: a mechanism-level look at where each surface spends your time.
| What you are doing | Terminal CLI | Browser web chat | Async cloud agent |
|---|---|---|---|
| Applying a change to files | Direct write, no round trip | You copy and paste it yourself | Direct write in a cloud sandbox |
| Running tests and reading errors | Runs and reads them itself | You run, you paste the error back | Runs and reads them itself |
| Doing several jobs at once | Sub-agents / fleet mode | One conversation at a time | Many parallel sandboxes, its strong suit |
| First response feel | Streams in your terminal, seconds | Streams in the page, seconds | Not interactive; you leave and come back |
| Reviewing the result | Scroll the terminal, or use an IDE plugin | Read it in the chat | A pull request with diffs and logs |
| Multimodal input (screenshots, mocks) | Awkward, text-first | Native and effortless | Limited |
| Setup cost | Install, auth, shell fluency | None, just open a tab | Repo connection, then none |
The pattern is consistent. For a human in the loop who wants to move fast, the terminal and the IDE plugin win because they cut the copy-paste tax and stream in seconds. For throughput on many tasks at once, the async cloud agent wins because it parallelizes and hands you reviewable pull requests. For quick visual or one-off work, and for anyone who does not live in a shell, the browser chat wins on zero friction. The vendors know this, which is why all eight now ship every surface.
A few concrete speed markers that are worth citing, each with the caveat it deserves. GitHub says its custom completion model delivers about three times the token throughput and about 35 percent lower latency for inline suggestions. OpenAI reports GPT-5.6 Sol is roughly 54 percent more token-efficient on coding than the prior generation, and, for select customers running on Cerebras wafer-scale hardware, Sol has reportedly hit around 750 tokens per second (a third-party, customer-specific figure, not a universal rate). Kimi's own serving is comparatively slow, so its speed reputation comes from third-party hosts; independent benchmarks put Groq's serving of Kimi K2 in the neighborhood of 200 tokens per second. Grok's grok-code-fast-1 is the explicit speed play, marketed around low latency and tight tool-call loops at a very low price. And Google's Gemini CLI free tier is the generosity story rather than the raw-speed story: 60 requests a minute and 1,000 a day, with the full 1M-token context, at no cost.
Where your code goes, and whose law governs it
Here is the part that matters more than any benchmark, and it is the reason to be careful before you point a coding agent at the cheapest endpoint you can find.
Every one of these tools ships your source code off your machine to a backend for inference. That is not a scandal; it is how they work. So the honest questions are not "does my code leave my machine," because it does. The questions are: where is it processed, under whose law, and what is the vendor's written policy on keeping and training on it. On those axes the tools differ enormously, and the difference is not the one the headlines imply.
Open weights are not the same as a first-party API. This distinction is the whole game, and it gets conflated constantly. Kimi, Qwen, and DeepSeek publish their model weights under permissive licenses. DeepSeek-V4 and the R1 line are MIT; Qwen3 is Apache 2.0; Kimi K2 is a modified MIT license whose only real condition bites above 100 million monthly users. A set of open weights is just static math. When you download it and run it on your own hardware, or on a reputable US or European host, your prompts and code never travel to China at all. Amazon offers DeepSeek-R1 as a managed model in Bedrock, in US regions, under MIT, and states that inputs and outputs are not shared with the model provider. Microsoft hosts it on Azure AI Foundry inside Azure's boundaries. Fireworks, Together, Groq, and Baseten all serve these same weights from US infrastructure. Running a China-trained model this way is a legitimate way to get a capable, cheap model without any China data exposure.
The exposure is the first-party endpoint. Calling api.deepseek.com directly, or using the DeepSeek consumer app, is a different thing entirely. DeepSeek's own privacy policy says, in plain language, that it stores the data it collects, including your prompts, uploaded files, IP address, and even keystroke patterns, on secure servers located in the People's Republic of China. The same first-party pattern applies to Moonshot's and Alibaba's consumer endpoints. Once data lands on PRC servers, it sits under PRC law. China's 2017 National Intelligence Law obliges organizations to support and cooperate with state intelligence work, and its PIPL and Data Security Law reinforce localization and state-access powers. Whether that law can actually compel a company to hand over a foreign user's data is genuinely debated by legal analysts, and there is no public record of DeepSeek being ordered to do so, so the accurate phrasing is "could be compelled," not "has been." But the possibility, plus the lack of enforceable recourse, is exactly what regulators have acted on.
And they have acted, repeatedly. The US Navy told personnel in late January 2025 not to use DeepSeek in any capacity. NASA's chief AI officer barred it from government devices, noting its servers sit outside the United States. By spring, StateTech counted 15 US states restricting it on government devices, with Texas, New York, and Virginia moving first; later 2026 reporting puts it at 17 or more. Italy's data-protection authority ordered an immediate limitation on processing Italian users' data and it left the app stores there. Australia directed it off government systems. Taiwan banned it across the public sector. South Korea's privacy regulator suspended new downloads and later reported that DeepSeek had transferred Korean users' data abroad without consent (the app was reinstated after remediation). Berlin's data-protection commissioner, Meike Kamp, referred it to Apple and Google, stating that "Chinese authorities have far-reaching rights to access personal data." A federal "No DeepSeek on Government Devices Act" was introduced in both chambers in early 2025, but as of mid-2026 it remained in committee and was not enacted, so the binding federal restrictions are agency memos rather than statute. (A broader Commerce prohibition on government-furnished equipment was reported by unnamed sources; treat that one as reported rather than confirmed.)
Cursor and the other AI IDEs. This is where the conflation does the most damage, so let me be precise. Cursor is made by Anysphere, a US company. Its own security page states, verbatim, that it uses no infrastructure in China and no China-headquartered subprocessors, and that to its knowledge none of its subprocessors do either. When you select DeepSeek or another Chinese-origin model inside Cursor, you are using those open weights on US infrastructure under a US vendor, not shipping your code to a PRC endpoint. GitHub does the same thing: it hosts Kimi K2.7 Code on US-based Azure AI Foundry and states that customer prompts and responses are not sent to the original model developers. So "I used a Chinese model in Cursor" is not "I sent my code to China." Those are different sentences, and only one of them is a jurisdiction problem.
That said, Cursor is not zero-exposure, and it is worth naming what the real exposure is. Even when you bring your own model key, your requests route through Cursor's own US backend, where it does its final prompt assembly, and its own docs say so. If you enable codebase indexing, it uploads your code in chunks to compute embeddings; the plaintext does not persist after the request, but the embeddings and obfuscated file paths are stored (they are not readable source, though they are not zero-information either, and indexing can simply be turned off for sensitive work). Privacy Mode, which is enforced for Business tenants, means Cursor will not train on your data and it holds zero-retention agreements with its providers, but abuse classifiers can still store flagged data. Anysphere has completed a SOC 2 Type II attestation, and the current subprocessor list is published at trust.cursor.com/subprocessors, which is the authoritative place to check rather than any snapshot in a blog post. Windsurf, by Codeium, is likewise a US company with a zero-retention default for its paid tiers, though its protections are tier-dependent and its free tier runs under weaker terms; confirm the specifics against its own docs.
There is a separate risk axis with these agentic IDEs that has nothing to do with China, and it is worth keeping distinct: prompt-injection that escalates to code execution on your own machine. Cursor shipped fixes through 2025 and 2026 for a string of these, disclosed by reputable researchers and patched within days to a few weeks: EscapeRoute (a file-protection bypass), MCPoison (a trusted-config swap), and DuneSlide (two sandbox-escape bugs, both rated CVSS 9.8). The existence of those CVEs is not evidence of a careless vendor; it is the maturing attack surface of tools that now run commands for you. But it is a real reason to keep your IDE patched, require re-approval for tool configs, and not paste secrets into an agent's reach. Mitigations for that problem are different from mitigations for the data-jurisdiction problem, so do not collapse the two.
Weights carry behavior, even on a US host. Switching the backend fixes the jurisdiction question. It does not sanitize the model, because alignment and censorship travel inside the weights. CrowdStrike tested the raw open-source DeepSeek-R1 directly, without any API guardrail, and reported that its baseline code quality was comparable to other leading models, but that adding a politically sensitive context to a coding request raised the rate of severe vulnerabilities in the generated code (for example, saying the app was "based in Tibet" pushed the vulnerable-code rate from 19 percent to about 27 percent). PromptFoo found DeepSeek-R1 refused roughly 85 percent of a set of China-sensitive prompts. Those are attributed findings, and the insecure-code effect is trigger-conditional rather than universal, but the point stands: US hosting removes the data-in-China concern and leaves the baked-in behavior concern untouched. If you deploy one of these models, your own evals and code review are doing work that the backend choice cannot do for you.
And, of course, hold Anthropic to the same standard. A US backend is a different jurisdiction, not the absence of one, and it would be dishonest to apply the microscope only to Chinese labs. So: on the commercial side, for the API, Team, Enterprise, and Claude Code under commercial terms, Anthropic states it does not train on your inputs or outputs by default, deletes them within about 30 days, offers a zero-retention arrangement that stores nothing at rest, lets you pin inference and storage to US infrastructure, and carries SOC 2 Type II, ISO 27001 and 42001, HIPAA business-associate agreements, and FedRAMP High through GovCloud, Vertex, and Claude for Government. That is a strong, documented, third-party-audited posture. The consumer tier is a genuinely different bargain, and it deserves to be named plainly: since late August 2025, chats and Claude Code sessions on the Free, Pro, and Max plans are used to train future models unless you turn the setting off, and opting in stretches retention to five years. Read the toggle. And even the strong commercial posture does not mean "no government exposure." Anthropic is a US company bound by US legal process, and the CLOUD Act lets US authorities reach data a US provider holds even when it is stored abroad. The correct comparison with a China-hosted backend is therefore not "exposed versus safe." It is which jurisdiction, which legal standard, which written retention and training commitment, and which independent audits back it up.
So how should you actually choose
Strip it down to a few decisions.
If you want the fastest hands-on loop and you live in a repo, run a terminal CLI or its IDE plugin, and pick your model by task: a frontier US model for the hard, high-stakes changes, and a cheaper or open-weight model for the volume work. If you want to hand off long jobs and get back reviewable pull requests, use the async cloud agent (Codex cloud, Jules, the Copilot coding agent, or Claude Code on the web) and let several run at once. If you are not a shell person, or you are on your phone, or you are pasting in a screenshot, the browser chat is not the slow embarrassing option, it is the right tool.
On cost, the open-weight models from Kimi, Qwen, and DeepSeek are an order of magnitude cheaper per token and free to self-host, which makes them excellent for high-volume, lower-stakes work. Just make the backend decision on purpose. If the data is sensitive or proprietary, run those weights self-hosted or on a US or European host, not against the first-party PRC API, and keep your own evals in front of any model for the behavior that ships inside the weights. Running lean does not have to mean running exposed, and if you want the whole playbook for building a serious operation on a small budget, that is the argument of my book The $20 Dollar Agency (Digital Empire series, $9.99 on Kindle).
The tool is not the hard part anymore. Knowing where your code goes is.
Fact-check notes and sources
- Claude Code CLI v2.1.218, models, and pricing: Claude Code changelog, model config, models overview and API prices, subscription pricing. Fast Mode is Opus 4.8-only from July 24, 2026 (Opus 4.7 fast mode removed): Fast Mode docs.
- Codex CLI v0.145.0 and GPT-5.6 Sol: npm package, Codex releases, Codex docs, cloud, pricing. The GPT-5.6 context window is about 1.05M per the model spec; 272K is the long-context pricing threshold.
- Gemini CLI v0.52.0 and Gemini 3.1 Pro: Gemini CLI releases, quotas and pricing, Gemini 3.1 Pro announcement, Gemini API changelog, Jules.
- GitHub Copilot CLI v1.0.73, coding agent, and billing: CLI GA, supported models, coding agent, plans, usage-based AI credits, model hosting incl. Kimi K2.7 Code on US Azure.
- Grok Build CLI and models: grok-code-fast-1, grok-4.5 docs, xAI model catalog and grok-build-0.1 pricing, Grok Build overview. The community
superagent-ai/grok-cliis a separate third-party tool, not the official CLI. - Kimi K2.7 Code, K3, and the Kimi Code CLI: platform.kimi.ai pricing, K3 pricing, Kimi Code CLI repo (Apache-2.0), agent support in Claude Code. Model weights are Modified MIT: Kimi K2 license.
- Qwen3-Coder and Qwen Code CLI: Qwen3-Coder blog, model card (Apache 2.0), Qwen Code CLI, tiered API pricing and cached-input rates.
- DeepSeek-V4 pricing and the Claude Code path: official pricing, V4 preview, documented (and disclaimed) Claude Code setup.
- The speed argument and the honesty check: Claude Code overview, Anthropic best practices, the mechanism argument for CLI agents, the METR randomized trial (19% slower), the Stack Overflow 2025 survey, and the 2025 DORA report.
- Data jurisdiction and PRC exposure: DeepSeek's own privacy policy stating PRC server storage; China's National Intelligence Law with a contested reading of Article 7; state and agency actions (three-state summary, NASA, Germany's Kamp referral); the federal bill still in committee.
- Weights versus first-party API: DeepSeek-R1 is MIT and self-hostable; DeepSeek-R1 on Amazon Bedrock, US regions, inputs not shared with the provider; embedded-behavior findings from CrowdStrike and PromptFoo.
- Cursor and the AI IDEs: Cursor's data-use and security pages (the no-China-infrastructure statement and Privacy Mode), and the agentic-IDE CVEs (DuneSlide, both CVSS 9.8, patched in Cursor 3.0).
- Anthropic held to the same standard: consumer terms update (training since Aug 2025, five-year retention if opted in), commercial data usage and 30-day default, Zero Data Retention and data residency, certifications and FedRAMP High.
Related reading
- AI Terminal Kickstart: the install-first primer that gets Claude Code, Codex, and the Copilot CLI onto a fresh machine.
- Which Terminal AI Coding Agent: a terminal-versus-terminal look at when to run more than one.
- Codex vs Claude Code: the honest task-by-task breakdown between the two most-used CLIs.
- Claude Code Without the Terminal: the desktop app, the IDE plugins, the cloud, and the web.
- DeepSeek V4 and Kimi K2.6, the open-weight showdown: a closer look at the models that reset the cost math.
This post is informational, not legal or security-consulting advice. All product and company names used here (including Anthropic, OpenAI, Google, GitHub, Microsoft, xAI, Moonshot AI, Alibaba, DeepSeek, Cursor and Anysphere, Windsurf and Codeium, Amazon, and others) are the trademarks of their respective owners and appear only to identify and compare the products under discussion. That is nominative fair use: no affiliation, sponsorship, or endorsement is implied or should be inferred, and no logos or brand styling are used. Statements about any company are drawn from that company's own published documentation or from cited reporting, and are presented as of July 2026. Product versions, prices, and data policies change fast, so reconfirm anything load-bearing at the source before you rely on it.
