The CLI Is the Most Natural Thing an Agent Can Build

Agents are criticized for producing artifacts that look finished and aren't. The counterexample: command-line tools, where text goes in, text comes out, and the agent can verify its own work. Three skills in the directory make the case.

Watch an agent build a web app and you'll see the same failure mode every time: the output looks like a web app, and nobody — including the agent — knows whether it actually works. Visual artifacts resist self-verification. The agent can't click its own buttons.

Now watch an agent build a CLI tool. It writes the tool, it runs the tool, it reads the output, it fixes the tool. Text in, text out, the full loop closes without a human in it. That's why the CLI cluster in our directory scores the way it does, and why we think it's the most underrated category for agent work.

The anchor skill

cli-developer — 9.3 is one of the highest-scoring development skills in the directory, and its evaluation is instructive. It isn't a list of CLI libraries. It's a contract discipline: argument parsing conventions, exit code semantics, --help as a first-class deliverable, subcommand structure, configuration-file precedence, machine-readable output modes.

Those aren't style preferences. They're the difference between a tool an agent can operate and a tool an agent can't. Exit codes are how a script reports truth to its caller; structured output flags like --json are how a tool becomes composable in a pipeline. A skill that enforces these is writing the interface contract that the agent's own future invocations will depend on. The tool-building skill and the tool-consuming skill are the same skill, one generation apart.

The shortcuts skill nobody writes

The cluster's second entry is the kind of skill almost nobody bothers to write, which is exactly why it's interesting. cli-faq-shortcuts — 8.9 exists to answer the questions that CLI users ask over and over: what's the idiom for this, how do I pass that, where does this flag go.

Generalist instinct says this is trivia, beneath a serious skill. Evaluation says otherwise. In practice, a huge fraction of CLI utility is the FAQ — the two-second answer that saves a four-minute flag hunt. A skill that compresses those answers isn't shallow; it's honest about where the time actually goes. 8.9 is a fair grade for a skill with a narrow job it does completely — and a useful corrective to the assumption that only "deep" skills score well.

Worktrees: the missing half of the story

The third skill closes a gap that most agent workflows don't even know they have. using-git-worktrees — 9.0 teaches the agent to give each task its own working copy instead of thrashing a single checkout between experiments.

Here's why this belongs in the CLI story rather than a generic git story: the moment an agent builds and tests tools, it enters a many-parallel-tries workflow — one worktree where the new tool works, another where the flag redesign lives, a third for the control experiment. Worktrees are how command-line development scales to agent-style concurrency. The skill scores 9.0 because it converts a niche git feature into an operational primitive for exactly the workflow agents run.

The pattern behind the scores

Three skills, 9.3 / 8.9 / 9.0, and one shared thesis: agents should build things whose interfaces they can also exercise.

A CLI tool is the purest instance. Its contract is textual, its feedback is textual, its failures are textual — an exit code and a line of stderr is a complete machine-readable error report. Compare that to a GUI, where the agent ships pixels it can never see. The gap isn't the model's coding ability, which is identical in both cases; it's the verification channel, which only one of the two formats actually has.

So when planning what to have an agent build first — the scaffolding tool, the migration runner, the log scanner, the deploy command — you're not just choosing a deliverable. You're choosing a feedback loop. The CLI cluster is the directory's standing recommendation: build the thing you can test from the same terminal you built it in.

Text in, text out. It remains the most agent-native interface we have.