Skip to content
Velloreth
Developer Tools 9 min read

Beyond Git: Essential CLI Tools for Developers

Ripgrep, fd, bat, fzf, zoxide, delta and the rest of the modern CLI toolkit — what each replaces, real commands, and how to adopt them without breaking scripts.

By

Git is the one command-line tool nobody argues about. Beyond it, most developers keep whatever their operating system shipped: grep, find, ls, cat, cd. Those tools are decades old and were designed for machines with a fraction of your current codebase. The replacements are not novelty items. They are faster, they respect your project’s ignore files, and they produce output you can actually read.

This is the set I install on every new machine, what each one replaces, and the caveats I wish I had known before aliasing half my shell.

The problem with the defaults

Each classic tool has one specific weakness that shows up daily:

  • grep -r walks into node_modules, .git, dist, and every other directory you never wanted to search.
  • find . -name '*.ts' -not -path '*/node_modules/*' — the exclusion clause is longer than the search itself.
  • ls tells you nothing about git status or directory trees without a string of flags.
  • cat prints a wall of text with no syntax highlighting, no line numbers, and no paging.
  • cd into a deeply nested path you typed three days ago is pure muscle-memory tax.

None of these are broken. They are just optimized for a different era of computing.

TaskClassicModernWhat actually changes
Search file contentsgrep -rnripgrep (rg)Ignores .gitignore, skips hidden and binary files, parallel
Find files by namefindfdReadable syntax, parallel, gitignore-aware
View filescatbatSyntax highlighting, line numbers, git markers, paging
List directorieslsezaGit status, icons, tree mode
Change directorycdzoxideFrecency jumps to directories you actually use
Interactive searchnonefzfFuzzy-pick files, history, branches, processes
Read diffsgit diffdeltaSyntax-highlighted, readable hunk headers

Why these are fast

There is a pattern behind the list. Almost all of them are written in Rust or C, they traverse directories in parallel, and they make one smarter default decision: they skip what you already told git to skip.

That last part is the real win. On a typical JavaScript project, a naive recursive search touches hundreds of thousands of files inside node_modules before it finds your source. A tool that reads .gitignore never enters those directories. The speed is a side effect of doing less work, not from some exotic optimization.

Search: ripgrep and fd

If you install two tools from this list, make them these two.

ripgrep (rg) recursively searches for a regex pattern while respecting .gitignore by default. Recursive search is the default, so rg "parseConfig" does what you meant:

rg "parseConfig"                      # search the repo
rg "parseConfig" -t py                # only Python files
rg "error" -C 3                       # 3 lines of context
rg -i "copyright" --files-with-matches # just the file list
rg -w "userId" -g '!tests/**'         # whole word, exclude tests

The speed difference is not subtle. A benchmark published by the ripgrep project against the Linux kernel source (25M+ lines) reports 0.082s for rg, versus 0.273s for git grep, 0.443s for ag, and 0.891s for grep -rn. Vendor benchmarks are always flattering, but the reasons behind them — parallel traversal, SIMD-optimized matching, and skipping ignored files — hold up on real codebases.

fd is the same idea applied to find. It is not a drop-in replacement for every find flag, but for the common case it is:

fd '^src'                  # names starting with src
fd -e tsx Button           # .tsx files containing "Button"
fd -t d node_modules       # directories only
fd -H .env                 # include hidden files

fd ignores gitignored paths, hidden directories, and binary files by default. Its first argument is a regex rather than -name glob syntax, which takes about ten minutes to relearn — and then you stop writing -not -path clauses forever.

One packaging quirk: on Debian and Ubuntu the binary installs as fdfind to avoid a name conflict with an older tool. Either symlink it into ~/.local/bin or use fdfind directly.

Viewing: bat and eza

bat is cat with syntax highlighting, line numbers, git diff markers, and paging by default:

bat src/app.ts
bat --line-range 40:80 server.log
bat -p README.md     # plain mode: no colors, no line numbers

Two habits worth building. Use bat interactively, but pass -p when output is going into another command — decorations are for humans, not for grep. And configure a theme once (bat --config-dir) so it matches your editor instead of shipping a default you squint at.

eza is the maintained successor to exa. It replaces ls with git awareness, optional icons, and a tree view:

eza -l --git                  # list with git status
eza --tree --level=2          # two-level tree
eza -l --git --sort=modified  # recently changed first

Icons need a Nerd Font installed in your terminal. Without one, eza degrades gracefully to plain text, so it is safe to adopt before you customize fonts.

zoxide is a cd that remembers where you actually go. It tracks directories by frecency — frequency combined with recency — and after a few days you stop typing paths:

eval "$(zoxide init bash)"   # or zsh, fish, powershell
z blog                       # jump to the best match
zi                           # interactive pick, needs fzf

You keep plain cd available. Most people end up aliasing cd='z' within a week, but you do not have to commit to that on day one.

fzf is the piece that ties everything together. It reads a list from stdin, lets you fuzzy-filter it interactively, and writes your pick to stdout:

export FZF_DEFAULT_COMMAND="fd --type f"
export FZF_DEFAULT_OPTS="--preview 'bat --color=always {}'"

Then wire it into the places you already search:

Ctrl-R                  # fuzzy-search shell history
vim $(fzf)              # fuzzy-pick a file to open
git branch | fzf | xargs git checkout
rg --files | fzf --preview 'bat --color=always {}'

Because matching is fuzzy and non-contiguous, prscfg finds parseConfig. You type a few characters in order and move on.

Composition is where it compounds

Individually, each tool is a small upgrade. Chained together, they change how you explore an unfamiliar codebase:

# every TODO assigned to you, with context
rg "TODO.*jitesh" -C 2

# find the component file, then open it
fd CardForm | head -1 | xargs $EDITOR

# recent commits touching this directory, fuzzy-picked
git log --oneline -- . | fzf --preview 'git show {1}' | cut -d' ' -f1 | xargs git show

# largest directories in the project, two levels deep
dust -d 2

None of these is clever. They are just short, because each tool does one job and passes clean output to the next.

Git without the flag memorization

Two tools cover most of the daily pain.

delta is a syntax-highlighting pager for git and diff output. Configure it once:

git config --global core.pager delta
git config --global interactive.diffFilter 'delta --color-only'
git config --global delta.navigate true
git config --global delta.line-numbers true

git log -p becomes readable. Hunk headers show which function you are inside. Added and removed lines are colored so you can scan instead of squint.

lazygit is a terminal UI for the operations you do dozens of times a day: staging individual hunks, amending commits, rebasing, resolving conflicted files side by side. It does not replace understanding git — you still need to know what a rebase does — but it removes the flag-lookup tax from routine work.

Data and HTTP: jq, xh

If you work with APIs at all, jq pays for itself the first day:

curl -s https://api.example.com/repos | jq '.[] | select(.stars > 100) | .name'
curl -s ... | jq -r '.items[].id'   # raw strings, one per line
jq '.users[] | {id, name}' users.json

For actually calling APIs, xh (a fast HTTPie alternative) sends readable requests and formats JSON responses:

xh POST api.example.com/login email=me@example.com password==secret

Single : sends a value as JSON; double == sends it verbatim. It is curl with the mental overhead removed, and it is worth learning alongside jq rather than before it.

Smaller wins worth taking

ToolReplacesWhy it sticks
tldrmanPractical examples instead of a wall of flags
hyperfinetimeWarmup runs, statistical output, command comparison
dustduReadable disk usage without flag roulette
gpingpingGraphs over time; gping -f 'npm run build' waits for a command
sdsedFind-and-replace with a friendlier syntax

None of these change how you work. They remove small, repeated annoyances — which is exactly the kind of thing worth automating away.

How to adopt them without breaking things

Start with search. Install rg and fd first. Different names from the classics mean nothing breaks; you simply stop reaching for grep -r.

Alias carefully. Aliasing cat='bat' feels great until a script or someone else’s tool expects plain output. Keep aliases in your interactive shell only, and check what you have mapped with type cat once in a while.

Keep the classics available. When you SSH into a server, none of this exists. The remote box has grep, find, and cat, and that is fine — muscle memory for the simple versions is not wasted effort. Do not build habits that only work locally.

Install consistently, then put it in dotfiles:

# macOS
brew install ripgrep fd bat eza zoxide fzf git-delta lazygit jq

# Ubuntu/Debian (note: fd ships as fdfind)
sudo apt install ripgrep fd-find bat fzf jq

The shell init lines — eval "$(zoxide init bash)", fzf keybindings, delta config — belong in your dotfiles repo so the next machine comes up identical.

Verify before you trust. After installing, sanity-check each tool against a result you already know:

rg -c "TODO" src/
grep -rc "TODO" src/ | awk -F: '{s+=$2} END {print s}'

If the counts differ, ignore-file behavior is usually the reason — and it is usually the correct one.

When the classics are still right

Modern tools are defaults for interactive work, not universal replacements. Use plain grep in a shell script that will run on an unknown host. Use find when you need -exec with a complex expression on a minimal machine. In a container build, every extra binary is image weight, and busybox’s grep may be all you want.

The rule that has held for me: modern tools on my machine, classic tools on everyone else’s.

That is the whole toolkit — roughly eight binaries, all open source, most available from your package manager today. None of them will make you a better programmer. They just stop the terminal from being the slowest part of your day.

Frequently asked questions

Do I have to replace all of my Unix commands at once?
No. Start with ripgrep and fd — they have different names, so nothing breaks and you lose nothing. Add bat, eza, and zoxide later, one at a time, and only keep the ones you actually reach for.
Are modern CLI tools safe to use in shell scripts?
Prefer the classics in scripts. Tools like bat and eza add colors, paging, and column formatting that other commands do not expect. Interactive use is where the modern tools shine; scripts should stay portable.
Do these tools work on Windows?
Yes, most of them ship native Windows binaries through winget, scoop, or cargo. The main friction is shell integration: fzf keybindings and zoxide initialization need to go into your PowerShell profile instead of .bashrc.
Are they worth installing on a small codebase?
Raw speed matters less on a small project, but the defaults still do. gitignore-aware search alone saves you from matches inside node_modules, build output, and vendored files every single time.