TL;DR: Eight terminal tools that have permanently upgraded my daily workflow. Some replace slow GUIs, some make existing tools radically smarter. All of them are installed on every machine I touch.

⚡ Key Takeaways

• Claude Code — an agentic AI coding assistant that lives right in your terminal and understands your entire codebase.
• bat — a cat replacement with syntax highlighting and Git integration built-in.
• fzf — a blazing-fast fuzzy finder that makes searching anything in your terminal interactive.
• fd — a simpler, faster alternative to the find command with sensible defaults.
• git-delta — beautiful, readable diffs for Git with syntax highlighting and side-by-side views.
• eza — a modern ls replacement with colours, icons, and Git status at a glance.
• thefuck — corrects your previous terminal command with a single keystroke.
• zoxide — a smarter cd that learns your most-visited directories and lets you jump to them instantly.

---

I spend most of my working day inside a terminal. After years of shipping full-stack web apps, React Native projects, and cloud infrastructure for clients, my toolkit has been ruthlessly refined. Every tool on this list earns its place because it either removes friction, saves time, or just makes the terminal genuinely enjoyable to work in.

Here are the eight CLI tools I install on every machine, every time.

---

1. Claude Code — AI That Lives in Your Terminal

If you write code for a living, this is the one that changes everything.

Claude Code is Anthropic's agentic coding assistant that runs directly in your terminal. Unlike browser-based AI chat tools, Claude Code understands your entire project — it reads your files, navigates your codebase, runs commands, edits code, and iterates — without you copy-pasting anything.

# Install
curl -fsSL https://claude.ai/install.sh | bash

# Run inside any project
cd my-project
claude

Once running, you can give it natural language instructions like:

> Refactor the auth module to use JWT refresh tokens
> Write tests for the payment service
> Find all API calls that aren't handling errors

It reads relevant files autonomously, makes the changes, and explains what it did. What used to take 45 minutes of context-switching now takes a focused conversation.

Why I use it daily: It's not a code autocomplete — it's a junior engineer that never sleeps, never gets tired, and already knows your codebase. For freelancers and small teams moving fast, this is an enormous force multiplier.

Install: curl -fsSL https://claude.ai/install.sh | bash | Docs

---

2. bat — cat, But Actually Good

cat prints file contents. bat prints file contents with syntax highlighting, line numbers, Git change indicators, and automatic paging. It's a strict upgrade.

# Install
brew install bat           # macOS
sudo apt install bat       # Ubuntu/Debian

# Use it exactly like cat
bat index.js
bat src/api/routes.ts

# Show only specific lines
bat --line-range 40:60 server.js

# Plain output when piping (no decorations)
bat -p config.json | jq .

The Git integration is what makes it indispensable. Modified lines show a ~ marker in the gutter, new lines show +, and deleted content shows -. You get a lightweight diff view just by viewing the file.

Pro tip: Alias cat to bat in your shell config so you never have to think about it: alias cat='bat'

Install: github.com/sharkdp/bat

---

3. fzf — Fuzzy Find Everything

fzf is a general-purpose, interactive fuzzy finder for the terminal. It reads a list of items and lets you filter through them interactively with a real-time search UI. It sounds simple. The reality is that it integrates with virtually everything and becomes one of the most-used tools in your terminal.

# Install
brew install fzf
$(brew --prefix)/opt/fzf/install   # Enables shell integrations

# Ubuntu
sudo apt install fzf

The shell integrations are where fzf becomes magic:

# CTRL+R → Interactive fuzzy search through your entire shell history
# Type any fragment of a past command and navigate to it instantly

# CTRL+T → Fuzzy file search, inserts selected path into your current command
vim **<TAB>    # Opens fzf to fuzzy-find and complete the file path

# ALT+C → Fuzzy cd into any subdirectory

You can also pipe anything into fzf:

# Interactively kill a process
kill -9 $(ps aux | fzf | awk '{print $2}')

# Checkout a Git branch interactively
git checkout $(git branch | fzf)

# Open any recently modified file in your editor
vim $(find . -name "*.ts" | fzf)

Why it matters: Once you have CTRL+R bound to fzf history search, you will never dig through your terminal history the old way again.

Install: github.com/junegunn/fzf

---

4. fd — find, But Human-Friendly

The Unix find command is powerful but its syntax is notoriously hostile. fd is a modern replacement: faster, has sensible defaults, respects .gitignore, and uses a syntax that you'll actually remember.

# Install
brew install fd
sudo apt install fd-find    # Note: binary is `fdfind` on Ubuntu, alias to `fd`

# Find all TypeScript files
fd --extension ts

# Find files matching a pattern (case-insensitive by default)
fd config

# Find and execute a command on results
fd --extension log --exec rm {}

# Search inside a specific directory
fd migrations src/database/

# Include hidden files (fd ignores them by default)
fd --hidden .env

Compare the syntax for finding all .log files modified in the last day:

# Old way with find
find . -name "*.log" -mtime -1 -not -path "*/node_modules/*"

# New way with fd
fd --extension log --changed-within 1d

The .gitignore respect alone makes fd worth it on any project with a node_modules folder.

Install: github.com/sharkdp/fd

---

5. git-delta — Diffs That Are Actually Readable

The default git diff output is functional but ugly. git-delta is a syntax highlighter and pager for Git output that transforms diffs into something you actually want to look at.

# Install
brew install git-delta
cargo install git-delta     # via Rust

Configure it in your ~/.gitconfig:

[core]
    pager = delta

[interactive]
    diffFilter = delta --color-only

[delta]
    navigate = true          # n/N to jump between diff sections
    side-by-side = true      # Show old and new code side by side
    line-numbers = true
    syntax-theme = Dracula   # Any bat/syntect theme works

With these settings, every git diff, git show, and git log -p command now renders with:

• Full syntax highlighting per language
• Side-by-side comparison of changed blocks
• Clean line number gutters
• Colour-coded additions and deletions

# All these commands now use delta automatically
git diff
git diff HEAD~3
git show abc1234
git log -p --follow -- src/auth/index.ts

For code review: git-delta with side-by-side = true is closer to a GitHub diff view than the default terminal output. It makes reviewing colleague PRs locally much more comfortable.

Install: github.com/dandavison/delta

---

6. eza — ls for the Modern Age

ls lists files. eza lists files with colours, icons, Git status, file permissions formatted clearly, and a tree view — all with sensible, opinionated defaults.

# Install
brew install eza
sudo apt install eza

# Basic listing (replaces ls -la)
eza --long --all --icons

# Tree view of your project structure
eza --tree --level=2

# Show Git status for each file
eza --long --git

# Sort by modification time, newest first
eza --long --sort=modified --reverse

The Git integration column shows you at a glance which files are staged (S), modified (M), or untracked (?) without running a separate git status.

Add these aliases to your shell config for instant quality-of-life improvement:

alias ls='eza --icons'
alias ll='eza --long --all --icons --git'
alias lt='eza --tree --level=2 --icons'

Install: github.com/eza-community/eza

---

7. thefuck — Correct Your Last Command Instantly

You type a command. It fails. You know roughly what you meant. thefuck figures out the correction and runs it for you.

# Install
brew install thefuck
pip install thefuck          # via pip

Add this to your shell config (~/.zshrc or ~/.bashrc):

eval $(thefuck --alias)
# Optional: shorter alias
eval $(thefuck --alias f)

Now when a command fails, type fuck (or f) and it corrects and reruns it:

$ git push
# fatal: The current branch has no upstream branch.

$ fuck
# → Runs: git push --set-upstream origin feature/my-branch ✓

$ npx creat-react-app my-app
# command not found

$ fuck
# → Runs: npx create-react-app my-app ✓

$ sudo apt-get install nodejs
# E: Could not open lock file

$ fuck
# → Runs: sudo apt-get install nodejs ✓

thefuck has rules for hundreds of common mistakes across git, npm, pip, apt, docker, kubectl, and more. It is genuinely one of those tools that makes you feel slightly magical.

Install: github.com/nvbn/thefuck

---

8. zoxide — cd That Learns Your Brain

zoxide is a smarter cd. It tracks every directory you visit, weights them by frequency and recency, and lets you jump to any of them with a fragment of the path — no matter where you currently are in the filesystem.

# Install
brew install zoxide
curl -sSfL https://raw.githubusercontent.com/ajeetdsouza/zoxide/main/install.sh | sh

Add to your shell config:

eval "$(zoxide init zsh)"    # or bash, fish, etc.

Now use z instead of cd:

# First time — navigate normally to build the database
cd ~/projects/client-dashboard/frontend/src

# Next time — jump there from anywhere with a fragment
z dashboard
z frontend src
z client

# If multiple matches exist, it picks the highest-scored one
# Use zi for interactive selection with fzf
zi     # Opens fzf with all your frecent directories

The zi command (zoxide + fzf interactive) is particularly powerful. It opens an interactive fuzzy search of all directories you've ever visited, ranked by how often and how recently you were there.

Combine with fzf: If you have both fzf and zoxide installed, zi gives you a searchable, ranked list of every directory you've ever worked in. Jumping between client projects becomes instant.

Install: github.com/ajeetdsouza/zoxide

---

Quick Install — All 8 Tools

If you're on macOS with Homebrew:

brew install bat fzf fd git-delta eza thefuck zoxide
$(brew --prefix)/opt/fzf/install
npm install -g @anthropic-ai/claude-code

For Ubuntu/Debian:

sudo apt install bat fd-find fzf eza
cargo install git-delta       # requires Rust
pip install thefuck
curl -sSfL https://raw.githubusercontent.com/ajeetdsouza/zoxide/main/install.sh | sh
npm install -g @anthropic-ai/claude-code

Recommended shell aliases to drop in your ~/.zshrc or ~/.bashrc:

# Better defaults
alias cat='bat'
alias ls='eza --icons'
alias ll='eza --long --all --icons --git'
alias lt='eza --tree --level=2 --icons'
alias find='fd'

# thefuck
eval $(thefuck --alias)

# zoxide
eval "$(zoxide init zsh)"

---

Frequently Asked Questions

Do these tools work on Windows?

Most of them do, either natively or via WSL2 (Windows Subsystem for Linux). bat, fzf, fd, eza, and zoxide all have Windows builds. thefuck works on WSL2. For the best experience, WSL2 with Ubuntu is the recommended setup for Windows developers.

Is Claude Code free to use?

Claude Code requires an Anthropic API key and usage is billed based on tokens. It is not a flat subscription. For light daily use the costs are manageable; for heavy agentic tasks across large codebases, usage can add up. Check Anthropic's pricing page for current rates.

Will these tools slow down my terminal startup?

Only if configured carelessly. zoxide init and thefuck --alias add a small eval step. Keep your shell config lean and you won't notice any latency. All of the binary tools (bat, fd, eza, etc.) are compiled Rust or C binaries and are extremely fast.

Which shell do you recommend for using these tools?

Zsh with Oh My Zsh or Starship prompt is a solid setup for all eight tools. Fish shell also has excellent support. The tools themselves are shell-agnostic.

Are there similar tools for Windows PowerShell natively?

Some, yes. PowerShell 7 has improved significantly. But the ecosystem of modern CLI tools is overwhelmingly centered on Unix shells. WSL2 on Windows gives you full access to the entire Linux tooling ecosystem without compromise.

---

Conclusion

Your terminal is where you spend most of your time as a developer. These eight tools collectively eliminate a significant amount of daily friction — from jumping between projects instantly with zoxide, to reviewing code clearly with git-delta, to having an AI engineer in your terminal with Claude Code.

None of these require you to change your workflow dramatically. You install them, alias the ones that replace existing commands, and within a week the old way of working feels noticeably slower.

If you're a technical founder or CTO looking to accelerate your team's delivery velocity, the tooling layer matters. The same philosophy that drives these tool choices — eliminate friction, automate the repetitive, focus human attention on what matters — is the one we bring to every project we build at SoftwareCrafting.

Talk to our team about your next project →

---