Twelve years ago I wrote that the CLI was the point. “Most of my day with Phab is in arc, not the web UI.” I meant it literally: the terminal was where the work happened, the browser a side channel.
It is true again. The terminal is back, the browser tab is a side channel again, every serious tool ships a CLI first. But the point moved.
A paragraph later in that post I wrote the sentence that did the work: the commit message is what you meant to say, not the noise of “fix review comments.”
arc diff did something small and specific. It read the unpushed commits on your branch, built one logical patch from them, and mapped it to a single revision. The revision was not your branch. It was the thing you meant, cut free of the commit stream. You could hack locally any way you wanted - six commits, a rebase, a “wip” you forgot - and the revision stayed clean. It was a statement you composed, not a history you dragged behind you. The tool forced the separation. It would not let you submit noise.
I watched that separation die. gh pr create pushes your raw branch and opens a pull request. It sits on the same axis as arc - both exist to submit a change for review - but it is a thin wrapper over the API. It automates the browser click. It keeps the exact thing arc refused to keep: the branch, the noise, the history you dragged along. Squash-and-merge exists to undo at the end what the tool never separated at the start.
That is the submission axis, and it is the one everyone knows. The other axis is the one nobody names.
arc assumed the developer was the author. Intent lived in the human. The tool’s job was to package that intent cleanly, and the revision was “what I meant to say” because a human meant something and the tool made it legible.
Claude Code assumes the opposite. The human is the auditor, not the author. The tool watches the filesystem for changes, reads your .gitignore, shells out to git and the test runner, runs its own loops, fails, fixes, and comes back with a change. The terminal is where you watch this happen. It is an observation theater now, not an execution tool.
Intent did not dissolve in that shift. It moved. In arc, intent was authored at the diff - you composed the revision, and the revision was what you meant. In Claude Code, intent is authored upstream at the prompt, and the diff is downstream of it. The prompt is what you asked for. The diff is whatever the loop produced. Between them sits a layer of the agent’s own intermediate intent that you did not author and cannot fully read.
What I meant to say became what I asked for. Those are not the same object. One is a statement the tool forced you to make cleanly. The other is a seed you dropped and watched grow.
arc was a quality gate wearing a command’s shape. It made taste structural. You could not forget to state your intent, because the tool would not package it until you did. gh will ship your branch, noise included. Claude Code will author your change, and the taste it enforces is its own, applied to its own output – which is not enforcement, it is preference.
Nobody is going to reinstall Phabricator, and I am not asking anyone to. The logical patch is dead as a mechanism. Gerrit still does change-based review, and Graphite re-invents stacking on top of branches, but the dominant workflow is a branch and a pull request, and it is not going anywhere.
Which leaves discipline as the only place the separation still lives. No tool forces it anymore, so you have to. The developer is the only remaining quality gate.
That is the loss, and it is both smaller and larger than losing a good tool. The clean statement of intent stopped being something the tool made you produce and became something you have to remember to produce. arc did not try to think for me. It gave me a rigid stage and made me show my work. The wrapper and the agent, each in its own way, let me skip that step.
Twelve years later the CLI is still the point. In 2013 the point was the developer, composing intent. Now it is the loop, running without me. The terminal is back. The author is not.