Here is the thing the editor-extension crowd won't say out loud: when you look at where serious agentic work actually ran in 2026 — the unattended loops, the CI-triggered fixes, the multi-agent fan-outs, the bots that review your PR before a human wakes up — almost none of it lived inside an IDE sidebar. It lived in a terminal. The whole "CLI versus IDE" debate has a clean answer nobody selling an editor wants to print: the shell won the agentic tier, and the sidebar got demoted to a pairing surface.
That isn't a vibe. It's a structural outcome, and the structure is the whole argument.
Every frontier lab independently bet the terminal
Inside a single twelve-month window, labs that disagree about everything agreed on the form factor. Anthropic shipped Claude Code. OpenAI shipped Codex CLI. Google shipped Gemini CLI. Aider, Warp, Zed — and Cursor, the IDE champion itself — all shipped credible terminal agent loops.
When competitors who share no roadmap, no incentives, and no codebase land on the same surface, that isn't fashion. Fashion diverges; everyone races to differentiate. Convergence under independent pressure is the opposite signal: the shell is the shared conclusion about where an autonomous agent belongs. You can wave off one lab's bet as marketing. You cannot wave off all of them arriving at the same answer in the same year.
"How good is your agent" is now a number you get in a terminal
Watch where the benchmark went. The de-facto leaderboard for serious agentic capability in 2026 isn't an IDE-completion score. It's Terminal-Bench. On Terminal-Bench 2.1, Codex CLI (GPT-5.5) leads at roughly 83.4%, Claude Code (Opus 4.8) sits near 78.9%, and Gemini CLI (Gemini 3.1 Pro) around 70.7%.
Two honest caveats: these are scaffold-driven proxy numbers, not pure model-capability measures, and they aren't cleanly cross-comparable across harnesses. But notice what isn't in dispute. The question "how good is your coding agent" gets settled by dropping the agent into a terminal and watching it work. The measurement apparatus itself relocated to the shell. That's the tell — you benchmark a thing where the thing actually lives.
The moat is the agent-as-Unix-process
This is the part the IDE camp can't engineer around. A CLI agent is a Unix citizen. It pipes:
cat build-error.txt | claude -p "diagnose and propose a patch" > fix.md
It composes with forty years of tooling an editor extension can't reach — find | grep | jq | curl, redirection, exit codes, the entire substrate. And the deeper win is contextual economy. The agent chains shell tools without routing every intermediate result back through the model's context window: grep finds the call sites, and the model never reads 200 files to locate them. An IDE sidebar mediates everything through a chat panel, so it structurally cannot do this. It pays a context tax the shell agent avoids by construction — every file the sidebar surfaces is a file the model has to ingest.
This isn't a feature gap you patch in the next release. It's the difference between being in the pipeline and being a window beside it.
Headless is the whole ballgame
claude -p reads stdin, emits machine-readable JSON (--output-format json, --json-schema, a total_cost_usd per run), returns an exit code, and locks down for CI with --allowedTools and deterministic flags. Which means you can wrap it as an npm script:
{ "scripts": { "lint:claude": "claude -p \"$(cat .ci/review-prompt.txt)\" --output-format json" } }
Or drop it in a git pre-commit hook. Or a GitHub Action. Or a GitLab stage. The same binary fires on a push, a PR comment, a nightly cron — no human, no window, no panel. Cursor's headless CLI and Codex's non-interactive mode do the same thing, which is the point: this is now table stakes, not a differentiator.
An IDE extension cannot be a step in a pipeline. It needs a GUI process and a person looking at it. That's not a limitation someone forgot to fix in the backlog — it's what an extension is. The moment your real workload becomes "run this agent on every push with nobody watching," the editor is disqualified by its own architecture.
Follow the money: Anthropic metered headless separately
If you still think headless is a side feature, explain the billing change. On June 15, 2026, Anthropic split programmatic agent usage — claude -p, the Agent SDK, the GitHub Actions path — onto a separate credit pool, billed at API rates with its own Pro/Max5x/Max20x tiers at $20/$100/$200.
Companies don't build separate metering for a rounding error. You carve out a credit pool when a workload becomes large, distinct, and worth charging for on its own terms. Billing is an honest witness — it has no marketing incentive — and it says unattended, headless, CI-shaped agent runs grew into a workload class big enough to meter on its own. That class lives in the terminal.
Multi-agent fan-out is CLI-native
The 2026 frontier move is parallel orchestration: fan out four to eight agents across git worktrees, each on a subtask, then reconcile. That is trivial to script with processes and near-impossible to coordinate inside one editor window. Spawning scout subagents to absorb the grep workloads, running them concurrently, collecting condensed summaries back to a lead — this is process choreography, and processes are the terminal's native idiom.
The damning detail: even Cursor runs its Background Agent and BugBot server-side, as headless processes, identical no matter which editor hosts the chat. The IDE champion's own flagship autonomy doesn't run in the IDE. It runs as a process and reports back to a panel. When your most advanced feature has to leave your own product to work, the product was never where the work belonged.
The config moved into the repo, not the preferences pane
AGENTS.md — originated at OpenAI, now stewarded under the Linux Foundation's Agentic AI Foundation, used by 60,000-plus projects and read natively by Claude Code, Codex CLI, Cursor, Aider, Devin, Copilot, Gemini CLI, Windsurf, and Amazon Q — is a repository artifact. Not an editor setting. The surface for telling an agent how to behave migrated into the repo and the process, editor-agnostic by design. When the standard for instructing an agent is a file in your project root instead of a checkbox in your IDE's preferences, the editor has already conceded it's one client among many.
The steelman, because I'm not going to strawman you
Here's where the honest version parts ways with the hype. The IDE did not die, and anyone claiming it did is overselling just as hard as the people I'm arguing with.
The editor still owns the human-verification loop, and owns it decisively. Visual diff review, watching the diffs stream as they generate, pixel-level UI work, anything where a human eye is the oracle — a terminal cannot show you that. The genuine power-user pattern in 2026 isn't pure CLI; it's a CLI base with IDE-style affordances and Playwright screenshots bridged back in for verification. Hybrid is where the sharp people actually land, and pretending otherwise is its own flavor of denial.
So the claim is narrow on purpose. The IDE lost the agentic surface — autonomous, headless, scriptable, unattended work — and kept the pairing surface — interactive, visual, human-in-the-loop work. Two different jobs. The error is conflating them: insisting the sidebar is still the center of gravity for serious agent work. It isn't, and the workflows prove it.
The denial, stated plainly
The IDE camp will reach for the adoption numbers. Fair — let's look. JetBrains' January 2026 AI Pulse survey of 10,000-plus professional developers puts Copilot at 29% at-work usage, with Claude Code and Cursor near 18% each. Raw, the IDE-integrated assistant still leads.
But that number measures assistant usage — autocomplete, inline chat, the human-pairing tier where the IDE genuinely won. It says nothing about the agentic tier, and there the signal points one direction: Codex usage climbed from roughly 5% of Claude Code's volume to about 40% between September 2025 and January 2026; Claude Code itself went from ~3% to 18% in a year. The level still favors the editor; the derivative does not, and the derivative is the story. (Treat the louder roundup figures — six-figure daily commit counts, ">20% of commits by year-end" projections — as reported-not-verified; the directional case stands without them.)
So when someone insists the editor sidebar is still where serious agentic work happens, ask one question: where does the work run when nobody's watching? On a push, on a cron, on a PR comment, in a CI stage? Every honest answer is a terminal. The assistant lives in your editor. The agent lives in your shell. Confusing the two is the denial — and the terminal already won the half that matters.