Medium article https://medium.com/@kibotu/your-ai-coding-agent-uses-your-terminals-tools-give-it-better-ones-bdcfb6737ac9?sk=1eac23694b14a779aed1870693df842f

Better-Than-Stock CLI Tools for AI Coding Agents on macOS

macOS ships grep, find, and cat — decades-old, POSIX-correct, and worse choices than the modern replacements once an LLM is the one calling them. Three reasons that's true, not just aesthetic preference:

Context economy. ripgrep and fd skip .git, node_modules, and build output by default and print compact file:line:match results. grep -r/find without carefully hand-tuned exclusions dump everything, and every irrelevant line an agent reads is context it paid for and now has to reason past.
Fewer wasted round trips. Models are trained on a decade of GitHub, Stack Overflow, and blog content where these newer tools are increasingly the default. They emit correct rg/fd/jq flags on the first try more reliably than the equivalent find -exec grep or awk incantation — a failed command is a full extra turn burned on repair, not just a lost second.
Structured output. jq/yq hand back parseable slices of JSON/YAML instead of a blob the model has to re-derive values from by eye, which is slower and more error-prone than it looks.

None of this requires the model to have been fine-tuned on any specific tool. It only requires the tool to be on $PATH — every harness below either bundles ripgrep itself or falls back to whatever it finds, and all of them will reach for a better tool over a worse one if you give them the choice.

TL;DR

ripgrep is the one tool with actual vendor backing — Claude Code and Codex CLI bundle it and are documented to prefer it over grep; everything else below is unofficial: no vendor documents it, but it's what a model reaches for when it's on $PATH.
Install the replacements once, globally, and stop thinking about it — see copy-paste.
Node.js 22+ is the real gatekeeper for actually running these harnesses (separate from the tools they call) — Claude Code, Codex CLI, and Qwen Code all need it.
For open-weight models, DeepSeek and GLM/Zhipu don't have a verified first-party terminal agent as of this research pass — see below.

The tools

Tool	Replaces	Status	Why it's worth it for an agent loop	Install
ripgrep (`rg`)	`grep`	Confirmed — Claude Code's `Grep` tool is built on ripgrep (its own syntax, not POSIX regex) and bundles a binary per-platform; Codex CLI bundles/depends on it too and has a documented crash history (`spawn rg ENOENT`) without it. Qwen Code's Homebrew formula pulls it in as a dependency.	`.gitignore`-aware, compact match output — the single biggest context-economy win on this list	`brew install ripgrep`
fd	`find`	Unofficial — no vendor documents it, but same `.gitignore`-aware, compact-output logic as ripgrep, and it's what a model defaults to over `find -exec` chains when it's present	Skips the two- or three-command pipeline `find`+`grep`+`xargs` often needs for the same result	`brew install fd`
jq	manual JSON parsing	Unofficial — every harness here can shell out to it if present; nothing vendor-documents it as required	Turns `gh api`/HTTP responses into a structured slice instead of a blob the model re-derives values from by eye	`brew install jq`
tree	`find` / `ls -R`	Unofficial — commonly what a model emits first when asked to get its bearings in a repo, if it's on `$PATH`	One call for a directory overview instead of chaining `ls`/`find`	`brew install tree`
bat	`cat`	Human-facing — agents don't render ANSI color, so this mostly helps you review what the agent touched, not the agent itself	Syntax highlighting + line numbers when you're the one reading the file	`brew install bat`
fzf	—	Human-only — it's interactive, so no non-interactive coding agent shells out to it	Fuzzy search over files/history for you, not the model	`brew install fzf`
git	Xcode CLT's bundled git	Baseline, not a swap for the model's sake	Every harness here assumes it's current; diffs/commits are the agent's write-audit trail	`brew install git`
gh	— (no stock equivalent)	Baseline	PR/issue workflows every agent above can be told to drive directly	`brew install gh`

Language toolchains follow the same logic once you're inside a specific stack — uv/ruff for Python, whatever your repo needs. No vendor documents shelling out to a specific linter; they call whatever's on $PATH if you tell them to.

Installing the assistants themselves

Assistant	Vendor	Runtime prereq	Install (Homebrew)	Alternative install
Claude Code	Anthropic	Node.js (native installer avoids needing it yourself)	`brew install --cask claude-code` (stable) / `claude-code@latest`	Native installer (curl script)
Codex CLI	OpenAI	None strictly required — standalone binary	`brew install --cask codex`	`npm install -g @openai/codex` or `curl -fsSL https://chatgpt.com/codex/install.sh \| sh`
Qwen Code	Alibaba	Node.js ≥ 22 (npm path only)	`brew install qwen-code` (homebrew/core, prebuilt bottle, pulls in Node + ripgrep)	`npm install -g @qwen-code/qwen-code@latest` or standalone install script
MiMo Code	Xiaomi	Inherits OpenCode's runtime (it's a fork)	— (no cask found)	`curl -fsSL https://mimo-code.xiaomi.com/install.sh \| sh`

Codex CLI additionally sandboxes its shell tool (Seatbelt on macOS) and disables outbound network by default — worth knowing before debugging why curl "hangs" inside it.

Sources: Claude Code setup docs, OpenAI Codex CLI repo, Qwen Code repo, Qwen Code docs, XiaomiMiMo/MiMo-Code.

The open-weight column is thinner than it looks

Qwen Code (Alibaba) is the strongest entry here — a proper terminal agent with its own repo, docs, MCP/LSP/Plan Mode support, and a real Homebrew formula. Requires Node ≥ 22 for the npm path (Ink 7 + React 19 need it); the standalone script and brew formula sidestep that.

MiMo Code (Xiaomi) is honest about not reinventing the wheel: its own README states it's "built as a fork of OpenCode," adding persistent memory, subagent orchestration, and autonomous goal-driven loops on top of OpenCode's existing provider/TUI/LSP/MCP/plugin architecture. If you already run OpenCode, MiMo Code is closer to a feature branch than a new tool.

DeepSeek and GLM/Zhipu: no verified official first-party terminal coding agent turned up for either in this research pass — that's a real gap in what's documented publicly, not a claim that one doesn't exist. In practice, both model families are typically driven through third-party or generic harnesses (OpenCode, Aider, Crush, Cline/Roo) rather than a vendor-branded CLI. One thing worth flagging with an explicit confidence caveat: as of my last verified (pre-mid-2026) knowledge, Zhipu marketed GLM models as Anthropic-API-compatible specifically so you could point Claude Code itself at a GLM endpoint via ANTHROPIC_BASE_URL — if that's still true, the "tool to install" for GLM is just Claude Code again. I did not reconfirm this in the current research pass, so treat it as a lead to verify, not a fact to build on.

Copy-paste

# Core, vendor-relevant
brew install ripgrep git gh

# Power-user layer (optional, but pays for itself)
brew install fd jq fzf bat tree

# Pick your assistant(s)
brew install --cask claude-code   # Anthropic
brew install --cask codex         # OpenAI
brew install qwen-code            # Alibaba (open-weight)
curl -fsSL https://mimo-code.xiaomi.com/install.sh | sh   # Xiaomi (open-weight)

Caveats

Findings for Claude Code and Codex CLI are backed by official docs, official repos, and live GitHub issues — highest confidence in this file.
Qwen Code is backed by its own repo and docs — high confidence.
MiMo Code's fork relationship is confirmed by its own README; its exact tool-shelling conventions (does it bundle rg the way Claude Code/Codex do, or just call system rg?) were not independently verified.
DeepSeek and GLM/Zhipu produced no verifiable claims about an official coding CLI — an evidence gap, not a negative finding.
Several specific "here's the exact required tool list" claims from blog sources were checked and refuted — that framing doesn't hold up against what vendors actually document, which is why everything but ripgrep above is labeled unofficial rather than required.
This snapshot is dated 2026-07-10, after this assistant's own January 2026 training cutoff — everything above came from live verification this session, not memorized knowledge. Re-check before relying on it months out; this space moves fast.

kibotu/cli-tools-for-coding-agents-macos.md

Select an option

No results found