Command Line Tools That Make You Look Like a Wizard

You know that developer who seems to do everything instantly? Types three commands and suddenly they've found a bug from 6 months ago, cleaned up 200 files, and generated a report?

They're not typing faster. They're using better tools.

Here's the stuff that makes me look way more productive than I actually am.

1. fzf - Fuzzy Finding Everything

Stop scrolling through your bash history. Stop typing cd 47 times to get to a nested folder.

fzf is a fuzzy finder that hooks into everything.

Install it:

brew install fzf
# or
git clone https://github.com/junegunn/fzf.git ~/.fzf
~/.fzf/install

Now hit Ctrl+R and start typing. It searches your entire command history with fuzzy matching.

Type git com → finds git commit -m "fixed the thing"

But here's where it gets wild. Pipe anything into fzf:

# Kill a process by name
ps aux | fzf | awk '{print $2}' | xargs kill

# Checkout a git branch
git branch | fzf | xargs git checkout

# Open a file in vim
find . -type f | fzf | xargs vim

The moment I got hooked: Needed to find a file in a massive project. Instead of clicking through folders, I typed:

vim $(fzf)

Got a fuzzy-searchable list of every file. Typed "user mod" and it found src/models/UserModel.js. Opened in vim instantly.

That one command saved me 2 minutes of clicking around. I use it 50 times a day now.

2. ripgrep - Grep But Actually Fast

grep is fine. ripgrep (rg) is stupidly fast.

Search through a million files for a specific function name? Takes seconds.

# Install
brew install ripgrep

# Basic usage (searches current directory recursively)
rg "functionName"

# Case insensitive
rg -i "error"

# Only show filenames
rg -l "TODO"

# Search specific file types
rg "api_key" -t js

Why it's better than grep:

• Respects .gitignore (skips node_modules automatically)
• 10-100x faster on large codebases
• Better default output formatting
• Smart case matching (lowercase = case insensitive, uppercase = case sensitive)

Real use case: Client reported "API key exposure" in our repo. Ran:

rg -i "api.?key" -t js -t env

Found 3 instances in 2 seconds across 15,000 files. With regular grep and manually excluding node_modules? Would've taken minutes and probably crashed my terminal.

3. bat - Cat With Superpowers

cat shows you file contents. bat shows you file contents with syntax highlighting, line numbers, and git integration.

brew install bat

# Use it like cat
bat config.js

Why it's better:

• Syntax highlighting (auto-detects language)
• Line numbers
• Shows git changes in the margin
• Automatic paging for long files
• Works with pipes

# View with line numbers
bat -n script.py

# Show git diff in a file
bat --diff config.js

# Pipe output
curl https://api.example.com | bat -l json

When it clicked: Was reviewing a PR. Instead of opening every file in VS Code, I just bat filename.js in terminal. Saw syntax-highlighted code with line numbers. Spotted the issue immediately.

Now I use it constantly for quick file peeks without leaving terminal.

4. tldr - Man Pages for Humans

Man pages are comprehensive. They're also 900 pages long and written like legal documents.

tldr gives you practical examples instead.

npm install -g tldr

# Instead of 'man tar'
tldr tar

You get actual examples:

tar

Create and manipulate archives.

- Create an archive from files:
  tar -cf target.tar file1 file2

- Extract an archive:
  tar -xf source.tar

The difference: Needed to use ffmpeg to convert a video. man ffmpeg is 24,000 lines. tldr ffmpeg showed me exactly what I needed in 10 seconds.

5. zoxide - Smarter Directory Navigation

cd is for cavemen. z is for people with places to be.

zoxide learns which directories you visit most and lets you jump to them with partial names.

# Install
brew install zoxide

# Add to shell config (~/.zshrc or ~/.bashrc)
eval "$(zoxide init zsh)"

Now instead of:

cd ~/projects/work/client-site/backend/src/api

You do:

z api

It jumps to the directory you visit most that matches "api".

How it learns: Tracks every directory you cd into. Ranks them by frequency and recency. When you type z proj, it guesses you mean the project folder you were just in yesterday.

Real scenario: Switching between 5 different project directories all day. Used to have a notes file with full paths. Now I just:

z frontend
# work work work
z backend  
# work work work
z docs

Saves me probably 30 seconds every time I switch. Adds up fast.

6. jq - JSON Swiss Army Knife

APIs return JSON. You need specific values. You could paste it into an online formatter. Or you could use jq.

brew install jq

# Pretty print JSON
curl api.example.com/user | jq

# Extract specific field
curl api.example.com/user | jq '.data.email'

# Filter arrays
curl api.example.com/users | jq '.[] | select(.age > 25)'

# Map over arrays
echo '[{"name":"Alice"},{"name":"Bob"}]' | jq '.[].name'

The game-changer moment: Needed to test an API that returned nested JSON 5 levels deep. Was copying into a formatter, scrolling, finding the value. Painful.

With jq:

curl $API_URL | jq '.data.users[0].settings.notifications.email'

Got exactly the value I needed. One command. Now I build entire test scripts with it.

7. htop - Process Manager That Makes Sense

top is ugly and confusing. htop is beautiful and intuitive.

brew install htop
htop

You get:

• Color-coded CPU/memory bars
• Tree view of processes
• Mouse support (click to sort)
• Easy to kill processes (F9)
• Filter/search built in (F3/F4)

Why I switched: Node process was eating 100% CPU. Needed to find which one. top showed me a mess. htop showed me a tree view where I could see it was a webpack dev server gone rogue. Killed it instantly with F9.

8. entr - Watch Files and Run Commands

Need to rebuild every time a file changes? Use entr.

# Install
brew install entr

# Watch files and run a command when they change
ls src/*.js | entr npm test

# Rebuild on any markdown change
ls *.md | entr ./build.sh

# Restart server on code change
ls src/**/*.js | entr -r node server.js

The -r flag restarts the process (kills and reruns).

Real use: Was testing an API script. Kept manually running node test.js every time I made a change. Tedious.

Solution:

ls test.js api/*.js | entr node test.js

Now it auto-runs every time I save. Instant feedback loop.

The Pattern: Do Less Typing, Get More Done

All these tools have one thing in common: they turn repetitive tasks into one command.

You could manually navigate directories. Or use z.

You could grep slowly. Or use ripgrep.

You could cat files. Or use bat and see more information.

The difference adds up. 10 seconds here, 30 seconds there. Over a day, it's minutes. Over a year, it's hours back in your life.

Your Week 1 Homework

Don't install all of these at once. Pick two:

1. fzf - if you waste time finding files/commands
2. ripgrep - if you search codebases often
3. zoxide - if you cd to the same directories repeatedly
4. jq - if you work with APIs/JSON

Use them for a week. They'll become muscle memory. Then come back and add more.

I went from "command line is for nerds" to "why would I ever use a GUI file explorer again?"

Not because I got smarter. Because I found tools that make the terminal actually faster than clicking.

Level Up Your Dev Workflow

I write about dev tools, productivity hacks, and real techniques that work. No generic advice, just stuff I actually use.

Subscribe to LearnAI Weekly — practical tips for developers delivered weekly.

What's your favorite CLI tool I missed? Drop it in the comments. Always looking for new tools to make me look smarter than I am.