Local-first CLI

Node-compat is not 100%. Joined Anthropic — watch ecosystem/governance noise, but license remains MIT. Not Deno. Some packages still assume Node quirks.

Go git TUI — not a GitHub app, not magit (Emacs), not CI. You still need git installed and a terminal habit.

Fuzzy finder only - not a file manager, not ripgrep itself (pairs with it), not a shell. You wire the pipes. Not Atuin shell history sync.

Prompt only — not a shell, not Zellij. Needs a Nerd Font for the glyph set. Config is yours to keep sane.

Modern Makefile replacement; not Taskfile. No implicit build DAG like Make. You still pick how CI invokes recipes. Distinct from package.json scripts if the repo is polyglot.

Vs Husky: polyglot hooks; not a CI product. Local only. Teams still need a shared install path.

Rust terminal workspace/layouts/plugins — agent terminal lane; not tmux-clone marketing. Plugin ecosystem younger than tmux. Some SSH/remote habits still assume tmux/screen.

Vs Zed: terminal modal + tree-sitter/LSP; not a GPU IDE. No Electron GUI, weaker AI-IDE surface than Cursor/Zed. Plugin story is thinner than Neovim.

Not a container runtime and not direnv-only. Some asdf plugins still assume bash. Team-wide adoption means every laptop runs mise, or CI drifts.

Vs grep (POSIX baseline) and ag/The Silver Searcher (predecessor): ripgrep is the modern default, not a POSIX drop-in. If your workflow depends on GNU grep flags exactly, `rg` is similar but not identical. No built-in fuzzy matching — pair with fzf for interactive filtering.

Vs cat (POSIX baseline): bat is heavier — startup and memory cost for highlighting. Not a POSIX cat drop-in for scripts expecting raw byte streams. Large files or binary content should still use plain cat. Theme configuration is optional but becomes a rabbit hole.

Vs ripgrep (content search) and fzf (fuzzy UI): fd finds *names*, not file contents, and it is not an interactive fuzzy picker. Not a POSIX find drop-in for every `-exec`/`-printf` edge case. Large trees still need sensible roots; it is not a content indexer.

Vs bat (file viewer) and lazygit (TUI Git client): delta is the *diff pager*, not a file cat and not a staging UI. Config lives in gitconfig — wrong pager nesting with less can surprise. Huge binary diffs still want `--stat` or path filters first.

Shell history tool — not a prompt (Starship), not a jumper (zoxide), not Dotfiles sync. Desktop/Hub team features are a separate product line (Hub not self-hostable). Atuin AI is free while in testing — treat that as temporary.

Default idle timeout is about one hour: the headless daemon shuts down and discards transient tabs/state unless you passed `--restore` (or another restore key). Headed, Safari/iOS WebDriver, and user-attached browsers are exempt; cloud-provider browsers are not. Tune with `--idle-timeout` or `AGENT_BROWSER_IDLE_TIMEOUT_MS`; `0` disables. This is CDP Chrome, not stealth—anti-bot pages will still block you.

Compile times increase with complex CLIs. Some advanced patterns require builder API. Error messages could be clearer.

Vs Yazi (terminal *file manager* / nav ≠ size): dust answers “what is using disk,” not browse/preview/move. Vs plain `du`: opinionated overview, not every POSIX du flag. Permission-denied noise is minimized, but you still need roots you can read.

Vs xh/HTTPie (interactive HTTP CLIs) and Bruno/Hoppscotch (API *clients*): Hurl is the *plain-text test runner*, not a REPL client and not a collections GUI. You author `.hurl` files; it is not Postman-shaped collaboration. libcurl semantics apply.

It benchmarks *process wall time*, not flamegraphs or allocator profiles — pair with a profiler when the hot path is inside one long process. Shell overhead and cold caches still skew naive runs; read the warmup flags. Not a load-test / HTTP soak tool.

Vs Ollama / llama.cpp / vLLM (runtimes): llmfit is the hardware fit finder, not the model runtime. Catalogs and VRAM heuristics drift; always verify against your real device and quantization. Does not download or serve models for you.

Vs fzf (generic fuzzy finder) and just (recipe runner): navi is cheatsheet *browse + param fill + run*, not a bare fuzzy filter and not a Justfile task graph. You still author or import cheats; empty cheats dirs teach nothing. Depends on a finder binary.

Vs hey (simple Go hammer), vegeta/k6 (scripted/scenarios), and curl loops: oha is the *interactive TUI load* CLI, not a full performance suite with thresholds-as-code. No browser/Web Vitals story. Point it at staging you own — load tests are still an attack if aimed at someone else.

Vs btop (host *resource* TUI with CPU/mem/disk/net/GPU): procs is the modern *ps*, not a live metrics dashboard. Not multi-host observability. Keep `ps` when POSIX scripts expect its exact columns.

Vs the coding agent itself (Claude Code, Codex, Aider): RTK is a token-thrift layer under agents — output compression/proxy, not an agent, not a model router. You must wire it into the shell path the agent actually uses; over-aggressive filtering can hide the error you needed.

Vs sed: intentional *subset*, not a full sed dialect — no sed scripts, hold space, or every GNU extension. Vs ripgrep (search) and fd (names): sd *rewrites*, it does not search a tree or find filenames. Keep sed for the ancient one-liners that already work.

Vs cloc/scc and vs GitHub language bars: tokei is the *local CLI/library* for code stats, not a hosted insights product and not a complexity/churn analyzer. Counts are still heuristics — generated code and vendor trees need excludes. Not a dependency auditor.

Vs Tilt (K8s microservice *dev control plane*): watchexec is the entr-class local file watcher, not a cluster live-update UI. Not a build system and not a process supervisor for multi-service graphs. You still write the command and filter extensions yourself.

Vs HTTPie (Python CLI UX) and curl: xh is the *Rust single-binary* cousin, not a plugin ecosystem and not every HTTPie feature. Incomplete parity is intentional (#4). curl still wins when the script must assume the OS already has it.

The project calls itself experimental and recommends running it alongside Homebrew, not replacing it — do not purge brew. It depends on Homebrew’s formulas, bottles, and infrastructure; it is a faster client, not a new package ecosystem. Cold-install gains shrink on slow links (downloads dominate big bottles), and the “100x” headline is the warm-cache case. Vs mise (runtime version manager): zerobrew installs Homebrew packages, it does not pin language toolchains per project.