12 Best Claude Code CLI Tools to Pair With Your Agent in 2026

Claude Code is only as fast as the shell around it. The agent reads files, runs commands, and shells out to whatever you have installed. In 2026, the difference between a Claude Code session that ships and one that burns tokens is not the model. It is the CLI tools you pair with it.

The hard part is separating the tools that actually reduce tokens and round-trips from the marketing-flavored "AI dev tools" that just wrap a chat box. We have run Claude Code daily across client engagements, internal repos, and the AY Automate platform, and we have watched which CLIs consistently cut session time, reduce context bloat, and prevent the agent from doing dumb things.

This guide compares the 12 best Claude Code CLI tools in 2026. Real workflows, licenses, the install commands each project documents, pros and cons, and a framework to pick the right combination for your repo. Three entries (jq, ast-grep and delta) were added on 2026-09-26 from their own docs and READMEs, and we make no hands-on claims about those three here.

Best Claude Code CLI tools: a brief overview

• ripgrep (rg): Best for fast code search inside the agent loop: the de facto replacement for grep. Claude Code bundles a copy for its own Search tool, and a system install keeps your Bash searches consistent with it.
• fzf: Best for interactive file and command selection: a fuzzy finder that pairs with rg, git, and your shell history to feed Claude Code precise paths.
• gh CLI: Best for GitHub-native agent workflows: lets Claude Code open PRs, read issues, and triage CI without leaving the terminal.
• jq: Best for parsing JSON in hooks and scripts: the command-line JSON processor that Claude Code's own hooks guide uses in its Bash examples.
• repomix: Best for one-shot repo-to-prompt packing: bundles a repo into a single XML/Markdown file ready to paste into any model or feed to Claude Code.
• files-to-prompt: Best for surgical context selection: Simon Willison's tool that flattens a chosen file set into one prompt-ready blob.
• code2prompt: Best for token-budgeted context: Rust CLI that builds prompts from a codebase with token counts, templates, and .gitignore respect.
• bun: Best for fast JS/TS execution: an all-in-one runtime, installer, and bundler that lets Claude Code iterate Node projects without npm slowness.
• uv: Best for Python project setup at agent speed: an extremely fast Python package and project manager from Astral that replaces pip + venv + pyenv.
• rtk (Rust Token Killer): Best for cutting Claude Code token spend: a CLI proxy that filters noisy command output before it reaches the agent.
• ast-grep: Best for structural search and codemods: matches syntax tree patterns instead of text, then rewrites them.
• delta: Best for reviewing what the agent changed: a syntax-highlighting pager for git diff, log and blame output.

1. ripgrep (rg), best for fast code search inside the agent loop

ripgrep is the search engine Claude Code actually wants. The agent shells out constantly to find symbols, references, and patterns. With plain grep, every search is slow and noisy. With rg, it is fast, respects .gitignore, and returns clean output that the agent can parse in a single pass.

If you only install one tool from this list, install ripgrep. Claude Code already bundles a ripgrep binary for its Search tool, and its troubleshooting docs tell you to install the system package and set USE_BUILTIN_RIPGREP=0 when the bundled copy will not run on your machine. A system rg also means the searches Claude runs through Bash behave the same way.

Key features

• Recursive search that the project's own published benchmarks show ahead of grep, ag and ack on most workloads
• Respects .gitignore, .ignore, and .rgignore by default
• Unicode and PCRE2 regex support, JSON output for scripting
• First-class glob filtering: rg "TODO" -g "*.ts" -g "!**/dist/**"
• Single static binary, ships in every major package manager

Best for

• Any Claude Code user on a non-trivial repo
• Teams that want consistent search behavior across macOS, Linux, and Windows
• Anyone running code-search-heavy agent loops (refactors, audits, migrations)

Pricing

• Free and open source, dual-licensed MIT or Unlicense
• Available via brew install ripgrep, winget install BurntSushi.ripgrep.MSVC, cargo install ripgrep, most Linux package managers, and direct binaries

Pros

• Massive speedup over default tools
• Zero configuration to be useful
• Output format is agent-friendly: stable, parseable, deterministic

Cons

• No interactive UI on its own; pair with fzf for picking results
• Regex syntax differs slightly from grep/PCRE, which trips up some scripts

2. fzf, best for interactive file and command selection

fzf is a fuzzy finder that turns any list into a searchable picker. For Claude Code, it is less about the agent calling fzf directly and more about you piping the agent precise paths and commands without manually typing them.

Combined with ripgrep, git, and shell history, fzf becomes the connective tissue of an agent-friendly terminal. Pick a file in one keystroke, hand it to Claude Code, get a focused edit.

Key features

• Fuzzy matching with score-based ranking and preview pane
• Integrates with shell history (Ctrl-R), file picker (Ctrl-T), and cd (Alt-C)
• Pipe-friendly: works with anything that emits lines (git log, rg, find)
• Supports multi-select, custom keybinds, and preview windows

Best for

• Engineers who want a faster terminal feedback loop around Claude Code
• Teams that already use ripgrep and want a cohesive search-pick-edit workflow
• Anyone tired of manually copy-pasting paths from ls output

Pricing

• Free and open source (MIT)
• Install via brew install fzf or sudo apt install fzf (both from the README)

Pros

• Tiny binary, zero config, runs everywhere
• Composes with every CLI you already have
• Preview pane shrinks the gap between "find" and "open"

Cons

• The agent itself does not "use" fzf; the benefit is on the human side of the loop
• Default keybindings overlap with some shell setups and need tweaking

3. gh CLI, best for GitHub-native agent workflows

gh is GitHub's official CLI and the cleanest way to let Claude Code work with PRs, issues, releases, and Actions. Instead of pasting URLs and screenshots, you let the agent run gh pr view, gh pr create, gh run watch, and stitch the GitHub side of the workflow directly into the build loop.

For teams shipping daily, gh is the missing piece that turns Claude Code from "writes code locally" into "owns the whole PR".

Key features

• Full coverage of issues, PRs, releases, Actions, gists, and Codespaces
• JSON output (--json) for clean parsing by agents
• Auth via OAuth or PAT, with org and SSO support
• Extensions ecosystem (gh extension install) for custom workflows

Best for

• Any team on GitHub running Claude Code in real engineering work
• Solo developers using the AY Framework /ship and /review modes
• Engineering teams that want PR descriptions and changelog entries drafted by the agent

Pricing

• Free and open source (MIT)
• No GitHub plan changes required

Pros

• Officially maintained by GitHub
• JSON mode is precise enough for safe agent automation
• Eliminates context switches between terminal and browser

Cons

• Some advanced GraphQL queries still require gh api, which the agent can mishandle
• Rate limits matter once you have the agent polling CI status loops

If you already use Claude Code for shipping PRs, our Claude Code agency team's standard setup pairs gh with the /ship workflow defined in our best Claude Code workflows guide.

4. jq, best for parsing JSON in hooks and scripts

jq is a command-line JSON processor: it slices, filters, maps and transforms JSON the way sed and awk handle text. It matters for Claude Code because hooks receive their event data as JSON on stdin, and the Bash examples in Anthropic's hooks guide use jq to pull out fields like .tool_input.file_path.

That makes jq the glue between Claude Code and everything else in your shell. A PostToolUse hook that runs Prettier on the file Claude just edited is one line: jq -r '.tool_input.file_path' | xargs npx prettier --write. The same tool trims gh --json output down to the three fields the agent actually needs.

Key features

• Filter, map and reshape JSON with a small expression language (.items[] | .name)
• -r raw output, so extracted strings pipe straight into other commands
• Written in portable C with zero runtime dependencies, per the README
• Streams input, so it works on hook payloads, API responses and log files alike

Best for

• Anyone writing Claude Code hooks in Bash (see our best Claude Code hooks guide for ready configs)
• Teams scripting GitHub, cloud CLI or API output before it reaches the agent
• Engineers who want deterministic JSON parsing instead of asking the model to read raw payloads

Pricing

• Free and open source (MIT; the docs are CC BY 3.0)
• brew install jq, sudo apt-get install jq or winget install jqlang.jq, per the jq download page. The README itself points to prebuilt binaries on the releases page and a Docker image. Latest release: jq 1.8.2 on 2026-06-20.

Pros

• The hooks guide already assumes it, so most published hook examples run as written
• Small, dependency-free binary that behaves the same on macOS, Linux and Windows
• Keeps JSON handling in code instead of in the model's context window

Cons

• The filter language is its own syntax, and complex filters get hard to read fast
• gh has a built-in --jq flag, so for GitHub output alone you may not need a separate install

Skip it if you never write hooks or shell scripts and only touch JSON through gh, whose --jq flag covers that case.

5. repomix, best for one-shot repo-to-prompt packing

repomix bundles an entire repo (or a filtered subset) into a single file optimized for LLM consumption. It is the cleanest way to take a codebase, strip the noise, count tokens, and hand the result to a model that needs the full picture.

For Claude Code users, repomix is most useful when you want to feed a sibling model (Claude.ai web, ChatGPT, a local Llama) the same context, or when you need a permanent snapshot of a codebase for a planning session.

Key features

• One command produces XML, Markdown, or plain-text output of an entire repo
• Token counts per file and for the whole repo, plus a --token-count-tree view
• File exclusion patterns, .gitignore respect, and binary detection
• Security checks for secrets via Secretlint integration
• --compress uses Tree-sitter to keep signatures and drop implementation bodies
• A Chrome extension adds a Repomix button to GitHub repository pages

Best for

• Pre-planning sessions where you want context outside Claude Code
• Audits where the auditor uses a different model than the implementer
• Open-source maintainers who want a "share this repo with an LLM" link

Pricing

• Free and open source (MIT)
• The README's quick start is npx repomix@latest. That is unpinned: it fetches whatever version is newest on every run. For repeatable runs, pin a version (v1.18.1 was the latest release on 2026-09-26) or install with npm install -g repomix or brew install repomix

Pros

• Sensible defaults out of the box, no config required
• Token counting prevents accidentally blowing past context limits
• Works on any repo, any language

Cons

• Single-shot output: not designed for incremental, in-loop use like Claude Code's own tools
• Large monorepos still need manual filtering to stay under token budgets

6. files-to-prompt, best for surgical context selection

Simon Willison's files-to-prompt is the minimalist alternative to repomix. You point it at specific files and directories and it concatenates them into a single prompt-shaped blob, with optional Claude XML formatting.

Where repomix tries to be comprehensive, files-to-prompt is precise. When you know exactly which 8 files matter, this tool gives you the cleanest payload with zero ceremony.

Key features

• Accepts files, directories, and globs; respects .gitignore
• Output formats: plain, Markdown (--markdown), and Claude-style XML (--cxml)
• Optional line numbers (-n) for precise reference
• Pipe-friendly: chains with rg, find, and shell substitution

Best for

• Power users who already know which files matter
• Quick one-off prompts in Claude.ai web that need 5-20 file payload
• Scripted agent workflows that need deterministic context

Pricing

• Free and open source (Apache 2.0)
• pip install files-to-prompt or uvx files-to-prompt

Pros

• Tiny, single-purpose, easy to script
• Claude XML output (--cxml) is built for pasting into Claude
• Pairs naturally with find, rg, and fzf

Cons

• No automatic token counting (pair it with a separate token counter, or use code2prompt)
• Less polished than repomix for whole-repo dumps
• Low activity: the last release (0.6) and the last commit are both dated 2025-02-19, checked 2026-09-26. The repo is not archived and the tool still does its one job, but do not expect fixes

7. code2prompt, best for token-budgeted context

code2prompt is a Rust CLI that builds prompts from a codebase with first-class token counting, Handlebars templates, and .gitignore support. It sits between repomix and files-to-prompt: more programmable than either, with better budgeting for tight context windows.

It is the right tool when you need consistent prompt structure across many runs (audits, refactors, codemods) and want to enforce a token budget per prompt.

Key features

• Per-file token estimates plus an estimate of template overhead, so you see prompt size before sending
• Handlebars template engine for custom prompt structure
• Glob include/exclude and .gitignore support
• Output to stdout or straight to the clipboard (-c)
• Rust CLI with an interactive TUI, plus Python bindings on PyPI

Best for

• Teams running repeated audits or migrations at scale
• Engineers building custom agent pipelines around Claude or GPT
• Anyone hitting context window limits with naive prompt building

Pricing

• Free and open source (MIT)
• Install via cargo install code2prompt, brew install code2prompt, or pre-built binaries

Pros

• Templating is genuinely useful for repeatable workflows
• Token visibility prevents silent truncation
• Fast: Rust binary, no Node or Python runtime

Cons

• Templates have a small learning curve compared to repomix defaults
• Less integrated with web UIs than repomix

8. bun, best for fast JS/TS execution

bun is an all-in-one JavaScript runtime, package manager, bundler, and test runner. For Claude Code working in Node, TypeScript, or React projects, swapping npm install and node script.ts for bun install and bun script.ts cuts the time the agent spends waiting on installs and test runs.

Slow installs and slow test runs are more than human-painful: they cost real money in agent sessions, because the agent sits idle waiting for output. bun fixes that.

Key features

• Node.js-compatible runtime that the README describes as "significantly faster than existing options" (the README gives no single headline multiplier)
• Built-in package manager with a text lockfile (bun.lock, the default since Bun v1.2)
• Native TypeScript and JSX execution: no transpile step
• Built-in test runner, bundler, and bunx package runner
• First-class Web APIs (fetch, WebSocket, FormData)

Best for

• TypeScript and Node projects where install/test loops dominate session time
• Side-project repos where simplicity beats convention
• Edge and serverless code that targets Bun, Cloudflare Workers, or Deno

Pricing

• Free and open source. Bun itself is MIT, and it statically links JavaScriptCore, which is LGPL-2 (license page)
• curl -fsSL https://bun.com/install | bash (an unpinned script that installs the latest release) or brew tap oven-sh/bun then brew install bun

Pros

• Genuine speed gains, especially on installs and cold starts
• Reduces agent idle time during loops
• Single binary replaces node, npm, tsx, ts-node, jest

Cons

• Some Node-native modules and tooling still have rough edges
• Production parity with Node still requires verification per project

For TypeScript-heavy agent projects, our Claude Code agency team standardizes on bun for the dev loop and Node for production.

9. uv, best for Python project setup at agent speed

uv is Astral's Python package and project manager, written in Rust. It replaces pip, venv, pyenv, pip-tools, and poetry with one fast binary. For Claude Code working in Python repos, uv removes minutes of latency per session.

If you run any Python automation, RAG pipeline, or data scripts under Claude Code, uv is the single biggest upgrade you can make to the shell environment.

Key features

• 10-100x faster than pip, per Astral's published benchmarks
• Built-in virtualenv management (uv venv)
• Project management with uv init, uv add, uv sync
• Python version management (uv python install 3.13)
• uvx for ephemeral tool execution (replaces pipx)
• Single static Rust binary

Best for

• Any Python developer running Claude Code on real projects
• RAG and agent framework work (LangChain, LlamaIndex, CrewAI)
• Data and ML engineers who want fast environment bootstrapping

Pricing

• Free and open source (Apache 2.0 / MIT)
• curl -LsSf https://astral.sh/uv/install.sh | sh (an unpinned script that installs the latest release) or brew install uv

Pros

• Speed that is genuinely noticeable, not marginal
• Compatible with pyproject.toml and existing Python tooling
• Replaces 4-5 tools with one binary

Cons

• Project workflow (uv sync) is newer and still evolving
• Some legacy projects with custom setup.py flows need manual tweaks

10. rtk (Rust Token Killer), best for cutting Claude Code token spend

rtk is a CLI proxy that sits between Claude Code and the commands it runs. It rewrites and filters noisy command output (verbose test runners, git chatter, long directory listings) before the agent ever sees it. The README claims it cuts up to 90% of the bash output your agent reads, and is careful to say that is not the same as cutting your bill by 90%, because bash output is only one part of input tokens.

In long Claude Code sessions, the dominant cost is not the model's thinking. It is the agent re-reading bloated tool output. rtk attacks exactly that.

Key features

• Transparent hook: rtk init -g installs a PreToolUse hook that rewrites Bash commands (git status becomes rtk git status)
• Per-command filters: test runners show failures only, git log shows hash, author and subject, ls becomes a compact tree
• rtk gain analytics: shows tokens saved per session and per command
• rtk discover mode: analyzes your history to surface missed savings
• 100+ supported commands, including git, cargo, npm test, pytest, go test and docker, per the README

Best for

• Power users running long Claude Code sessions (>1 hour)
• Teams paying real money for Anthropic API tokens
• Anyone tired of seeing 5,000 lines of npm output eat their context window

Pricing

• Free and open source (Apache 2.0)
• brew install rtk (the README's recommended method), winget install rtk-ai.rtk, or cargo install --git https://github.com/rtk-ai/rtk. Do not run cargo install rtk: the README warns that a different project called "rtk" (Rust Type Kit) owns that name on crates.io

Pros

• rtk gain shows savings per command and per session (the README notes token counts are estimated as bytes divided by 4, so percentages are more reliable than absolute numbers)
• Zero workflow changes for the agent
• Useful even outside Claude Code (reduces terminal scroll fatigue)

Cons

• The hook only covers Bash tool calls. Claude Code's built-in Read, Grep and Glob tools bypass it, per the README
• Aggressive filtering can hide errors if rules are not tuned; rtk proxy <cmd> runs a command unfiltered when you need the raw output

11. ast-grep, best for structural search and codemods

ast-grep searches code by syntax tree instead of by text. You write the pattern as ordinary code with $VAR wildcards, and it matches every node with the same structure, then optionally rewrites it. ripgrep finds the string useEffect. ast-grep finds every useEffect call whose dependency array is empty.

For Claude Code, that turns large mechanical refactors into one deterministic command instead of hundreds of individual edits. You can have the agent draft the pattern, run it with --json=stream to preview matches, then apply the rewrite. rtk even ships a filter that groups ast-grep matches by file.

Key features

• Patterns written as real code: ast-grep -p '$A && $A()' -l ts -r '$A?.()' (an example from the README)
• --rewrite for search-and-replace across a codebase
• YAML rule files for custom lint rules and code modifications
• --json output (pretty, stream or compact) for piping into other tools
• Tree-sitter parsing, written in a compiled language and using multiple cores

Best for

• Teams running migrations or API upgrades across many files
• Tech leads who want repo-specific lint rules without writing an ESLint plugin
• Claude Code sessions where text search returns too many false matches

Pricing

• Free and open source (MIT)
• The README lists npm install --global @ast-grep/cli, pip install ast-grep-cli and brew install ast-grep. The npm and pip commands install whatever version is newest (unpinned), so add a version if you script the install. Latest release: 0.45.3 on 2026-08-31.

Pros

• Matches code structure, so formatting and whitespace differences do not break a search
• Rewrites are deterministic and reviewable, which beats a long chain of model edits
• JSON stream output is easy for the agent to parse

Cons

• Patterns must parse in the target language, and you usually pass a language flag (-l ts)
• Still on 0.x version numbers, so flags and rule syntax can change between releases
• Claude Code does not know it is installed unless you say so, for example in CLAUDE.md

Skip it if your changes are small and local, or your codebase is in a language ast-grep's Tree-sitter grammars do not cover. Plain ripgrep plus Claude Code's Edit tool is simpler there.

12. delta, best for reviewing what the agent changed

delta is a syntax-highlighting pager for git diff, git log -p, git blame and grep output. It adds word-level highlighting, line numbers and an optional side-by-side view. After a long Claude Code session, it makes the diff you have to review much easier to read before you commit.

This one sits on the human side of the loop. Git only pipes output through a pager when standard output is a terminal (git docs), so when Claude runs git diff through its Bash tool it still gets plain, parseable output. You get the readable version in your own terminal.

Key features

• Syntax highlighting using the same themes as bat
• Word-level diff highlighting and side-by-side view with line wrapping
• n and N keys to jump between files in large diffs
• Improved merge conflict and git blame display
• Also highlights grep output from rg, git grep and grep

Best for

• Engineers who review every agent diff locally before committing
• Teams using the /review style workflows in our best Claude Code workflows guide
• Anyone reading long refactor diffs where changed words hide inside changed lines

Pricing

• Free and open source (MIT)
• The README links to its installation page, which lists brew install git-delta, cargo install git-delta and winget install dandavison.delta. The package is called git-delta, the binary is delta. Then set it as your pager with git config --global core.pager delta. Latest release: 0.19.2 on 2026-03-28.

Pros

• One git config change and every diff you read gets better
• Does not change what the agent sees, so there is no risk to its parsing
• Works with plain unified diff output, not only git

Cons

• No benefit to the agent itself: it improves human review only
• The last tagged release is six months old (checked 2026-09-26), though commits were still landing in September 2026

Skip it if you review changes in a GitHub pull request or your editor's diff view instead of the terminal.

How we ranked these tools

We ordered the list by how often a tool touches a typical Claude Code session: search and GitHub first, then JSON handling and context packing, then language runtimes, then token and review tooling. The other nine entries (ripgrep, fzf, gh, repomix, files-to-prompt, code2prompt, bun, uv, rtk) come from our own daily Claude Code work. The three added on 2026-09-26 (jq, ast-grep, delta) are ranked from their docs and READMEs, with no hands-on testing claimed for them in this post. Licenses, install commands, release dates and star counts were checked on each project's GitHub repo or docs on 2026-09-26. Where a documented install command fetches the latest version on every run, we say it is unpinned.

How to choose the best Claude Code CLI tools

1) What is the minimum baseline every Claude Code user should install?

If you only install three tools, install ripgrep, gh CLI, and bun or uv (depending on your stack). Add jq the day you write your first hook. ripgrep accelerates every search the agent runs, gh CLI gives the agent ownership of the GitHub side of your work, and bun/uv eliminates the install and test latency that dominates session cost. After that, add fzf and delta for the human side of the loop and rtk once your sessions get long enough to feel the token bill.

2) When should I use repomix vs files-to-prompt vs code2prompt?

Use repomix for "give me the whole repo as one prompt": quick exploration, audits, sharing context with another LLM. Use files-to-prompt when you know exactly which files matter and want a clean, scriptable payload (it pairs beautifully with ripgrep and find). Use code2prompt when you need repeatable prompt templates with token budgeting across many runs, like a batch refactor or an internal codemod pipeline. For ongoing in-loop work, Claude Code's own tools beat all three.

3) How do these tools cut Claude Code token spend?

The biggest token sinks in Claude Code are noisy command output, repeated file reads, and oversized context payloads. rtk directly attacks output noise. ripgrep keeps searches scoped (no node_modules reads). bun and uv finish commands faster, so the agent reruns less. jq trims JSON payloads to the fields that matter before the agent reads them. ast-grep replaces hundreds of individual edits with one rewrite. code2prompt and files-to-prompt keep payloads in check when you do step outside Claude Code. How much you save depends on your repo, so measure it: rtk gain reports estimated savings per command. For deeper patterns, see our roundup of best Claude Code skills.

4) Do I need all twelve, or is this overkill?

No team needs all twelve on day one. Start with ripgrep + gh CLI + your language-specific speed upgrade (bun or uv). Add fzf when manual file selection starts to slow you down. Add repomix or files-to-prompt the first time you need to feed a non-Claude-Code model. Add rtk once you have a real token bill to worry about, and ast-grep the first time a refactor touches more files than you want to review one by one. The point is not maximalism: it is matching the tool to the specific friction in your loop.

Ready to ship faster with Claude Code?

The right CLI stack turns Claude Code from a chat-with-files agent into a real engineering teammate. At AY Automate, we build our client setups on this stack, tuned to the repo and the language. If you want a team that already runs these tools on production codebases, our Claude Code agency builds, ships, and maintains Claude Code workflows end to end. Pair this guide with our best Claude Code GitHub repos for templates and our best Claude Code skills for the prompt-level upgrades. When you are ready to talk, book a consultation and we will audit your current setup.

FAQ

What are Claude Code CLI tools?

Claude Code CLI tools are command-line utilities you install in your shell that Claude Code can call as part of its tool use loop, or that you call manually to feed Claude Code cleaner inputs. They include search tools (ripgrep, ast-grep), package managers (bun, uv), GitHub clients (gh), JSON processors (jq), diff viewers (delta), and context-shaping tools (repomix, files-to-prompt, code2prompt).

How are CLI tools different from Claude Code plugins or MCP servers?

CLI tools are generic command-line programs that any agent or human can call. Claude Code plugins extend Claude Code's behavior at the IDE/agent level. MCP servers expose structured tools over the Model Context Protocol. They are complementary: CLI tools sit in the shell, plugins sit inside Claude Code, and MCP servers sit between Claude Code and external systems. See our best Claude Code MCP servers for the MCP layer and our best Claude Code plugins for the plugin layer.

How do I verify a CLI tool is safe to run inside an agent loop?

Three checks. First, the tool should be open source and widely adopted (ripgrep, gh, uv and bun each had more than 45,000 GitHub stars on 2026-09-26). Second, it should have predictable output: deterministic, parseable, no interactive prompts. Third, you should be able to dry-run it: tools like repomix and code2prompt let you preview output before piping it anywhere.

How much do Claude Code CLI tools cost in 2026?

Every tool in this list is free and open source. What you pay for is the Claude subscription or API usage that powers Claude Code itself. The whole point of the right CLI stack is to reduce that bill, not add to it.

How long does it take to set up a full Claude Code CLI stack?

Most tools here are one package-manager command each, for example brew install ripgrep gh jq fzf. Language runtimes (bun or uv) take one more command. rtk adds a second step, rtk init -g, which installs its Claude Code hook. Budget extra time only for tuning: fzf keybindings, delta's git config and ast-grep rules.

Is the official Anthropic Claude Code release the same as Claude Agent SDK?

Claude Code is the IDE-grade agent CLI from Anthropic. The Claude Agent SDK is a lower-level library for building your own agents on the same primitives. CLI tools in this list work with both, but most of the day-to-day developer experience benefits land in Claude Code.

Should I use Claude Code CLI tools or just rely on Claude Code's built-in tools?

Use both. Claude Code's built-in tools (Read, Edit, Grep, Bash) cover the common path. The CLI tools in this list make that common path faster, cheaper, and more accurate. Claude Code's Search tool already runs a bundled ripgrep, and a system rg keeps Bash searches consistent with it. bun and uv make the built-in Bash loop faster. rtk trims the output of the Bash commands it supports. They stack with Claude Code, not against it.

Can a Claude Code agency set this up for my team?

Yes. A good Claude Code agency will audit your current CLI stack, install and configure the right tools per repo, write the Claude Code hooks and skills that wire them together, and train your engineers on the new loop. At AY Automate, that is exactly what our Claude Code agency team does on every engagement. Book a consultation if you want to walk through your current setup. Pair the right CLI stack with the right prompts: see our best Claude Code prompts guide for ready-to-use starting points.

Does Claude Code need ripgrep installed?

No, not by default. Claude Code ships a bundled ripgrep binary for its Search tool. If search, @file mentions or custom skills stop finding files, the docs say to install your platform's ripgrep package (brew install ripgrep on macOS) and set USE_BUILTIN_RIPGREP=0. Then run claude doctor to confirm the Search line shows your system path.

Why do Claude Code hook examples use jq?

Claude Code passes hook event data to your command as JSON on stdin. jq pulls out a single field, such as the edited file path or the Bash command, in one line. Anthropic's hooks guide uses jq in its Bash examples and says to install it with brew install jq or apt-get install jq.

Is it safe to install Claude Code CLI tools with curl | sh or npx @latest?

Those commands are unpinned: they install whatever version is newest at that moment, so a compromised release reaches you with no review. Prefer your package manager, pin exact versions in scripts and CI, and check release notes before upgrading. For a full review of your agent setup, see our Claude Code security audit.

What is the difference between ripgrep and ast-grep?

ripgrep matches text with regular expressions, so it is fast and works on any file. ast-grep parses code into a syntax tree and matches structure, so it ignores formatting and can rewrite what it finds. Use ripgrep to locate things and ast-grep when a change has to hit every matching call the same way.