10 CLI Apps That Will Transform Your Terminal Workflow

When it comes to writing code, I've been working in the terminal now for just over 10 years, and it's perhaps one of the best decisions I've ever made. Not only has it improved my own productivity when developing software, but given the recent rise of AI agents such as Claude Code and Gemini CLI—both of which operate inside the command line—having this terminal-based workflow is perhaps now more important than ever before.

By default, however, the terminal isn't exactly the most hospitable place, especially if you're coming from a more full-featured IDE or text editor such as JetBrains, VS Code, or even Cursor. Therefore, given that more and more people are likely going to be using the terminal in the near future, I thought it would be worthwhile sharing some of my favorite CLI tools that I've picked up over the past 10 years.

These tools have not only helped to improve the experience of working in the terminal, but have also helped to make me significantly more productive. Let's dive in.

1. Zoxide - Supercharged Directory Navigation

To kick things off, let's start with one of my favorite CLI tools that I picked up in the past couple of years: Zoxide, which is a drop-in replacement for the cd command that makes navigating your file system from the terminal extremely efficient.

The Traditional Way vs. Zoxide

Let's first take a look at how I would normally change into a directory via the CLI using the cd command. Here I want to change into a project I'm currently working on found inside of:

~/projects/zenhq/studio/studio-app

As you can see, this is kind of a tedious path. By using the cd command, I have to type out the full path including any symbols, which is somewhat tedious and can be error-prone.

Now let's see how we can achieve the same thing using Zoxide (which I've set to the command z):

z projects zenhq studio app

This requires far less typing to achieve the same thing. However, we can actually optimize this even further:

z studio app

And it'll again take me to the exact same directory. Very cool.

How Zoxide Works

The way that Zoxide works is by performing fuzzy matching on the arguments you pass in to the path of any directories you've already visited using Zoxide. This means you don't need to type out the exact path in order for it to match, which can help to save a lot of time when jumping between different projects and directories.

Examples:

• To jump to my Neovim configuration: z config instead of cd ~/.config/neovim
• To head over to my Dreams of Code web application: z dreams of code

Additionally, you can configure Zoxide to use the cd command instead of z, allowing you to use cd as you normally would, but with the added benefits provided by Zoxide.

Learn More: I've done a dedicated video on Zoxide that covers configuration details and caveats.

2. Ripgrep (rg) - Blazing Fast Text Search

This next tool is incredibly useful when working in a codebase you might be unfamiliar with—which, given the rise of AI agents, is more and more likely to be the case. This command is rg, which is shorthand for ripgrep, an improved version of grep.

Why Ripgrep Over Grep?

If you're not familiar with grep, it's basically a CLI command that allows you to search for occurrences of text patterns inside files in a directory. The grep command comes standard in modern Unix-based operating systems, but it's not exactly what I would call a modern command, especially given how slow it actually is.

Key Improvements of Ripgrep:

1. Speed: Ripgrep is significantly faster than traditional grep
2. Sane Defaults: Won't search files or directories listed in .gitignore
3. Recursive Search: Automatically searches through all files and directories recursively
4. Color Output: Color is enabled by default, making results easier to read

Example Usage

# Search for "isAdmin" in current project
rg isAdmin

# Traditional grep equivalent (slower and includes node_modules)
grep -r isAdmin .

The speed improvement and intelligent filtering make ripgrep much more user-friendly and effective when working with larger projects.

3. fd - Modern File Finding

Continuing the trend of improving legacy CLI commands, we have fd, which is to find as ripgrep is to grep, bringing similar improvements to file searching.

Traditional Find vs. fd

Let's say I want to list all files that have the word "auth" in their filename. With the traditional find command:

find . -type f -name "*auth*"

With fd, this becomes much cleaner:

fd auth

Key Advantages of fd

• Faster performance
• Respects .gitignore by default
• More intuitive syntax
• Regex and glob support
• Case insensitive search by default

Advanced Example:

# Find files containing "test" but exclude those with "route"
fd test --exclude "*route*"

The equivalent find command would be much more complex and less intuitive.

4. tmux - The Terminal Game Changer

This next command is the big one—perhaps having one of the biggest improvements to the way I work in the terminal of all time: tmux, which I've actually done a whole video on talking about how it's forever changed the way I write code.

What is tmux?

tmux is a terminal multiplexer, meaning it allows you to spawn multiple pseudo terminals and arrange them either as panes, individual windows, or even in multiple sessions, each of which you can navigate between.

Why tmux Over Native Terminal Features?

Key Benefits:

1. Entirely keyboard-based navigation - keeps your hands on the keyboard
2. App agnostic - works with any terminal emulator
3. CLI interface - allows for automation of various actions
4. Session persistence - sessions can be reattached if connections are closed

Session Persistence in Action

Perhaps the biggest benefit is session persistence, especially when working on remote machines over SSH. Here's how it works:

# SSH into server and start tmux
ssh user@server
tmux

# Start a long-running task
htop

# Detach from session (Ctrl+b, then d)
# Even if SSH connection drops, you can reconnect:

ssh user@server
tmux a  # Reattach to existing session

This is invaluable for long-running tasks and prevents work loss due to connection issues.

Automation Integration

Because tmux has a CLI interface, you can automate various actions. In my case, I've integrated these automations into my own Vibe CLI application:

# Opens new tmux window with git worktree and Claude Code
vibe feature new-feature

5. GitHub CLI (gh) - GitHub Without the Browser

The GitHub CLI is a rather recent addition to my toolkit, but despite only using it for a short time, it's already been a huge improvement to my workflow. I've been using it more than the actual GitHub website itself.

Key Use Cases

Main uses I find for the GitHub CLI:

1. Creating new repositories for new projects
2. Checking open issues for existing projects
3. Creating pull requests with AI-generated descriptions

Example Usage

# Create a new repository
gh repo create my-new-project --public

# View issues
gh issue list

# Create a pull request with AI-generated description
gh pr create --title "Add new feature" --body-file -

The ability to stay in the terminal and avoid browser distractions makes this tool incredibly valuable for a terminal-based workflow in 2025.

6. Doppler CLI - Secure Secrets Management

Another tool I've been using extensively is the Doppler CLI. Doppler is my favorite secrets management platform, and the CLI makes it incredibly powerful for local development.

What Doppler Does

Doppler allows you to easily manage secrets for different environments (dev, prod, personal) and inject them into your applications without storing them locally.

Example Usage

# Run local development with dev environment secrets
doppler run --project dreams-of-code --config dev -- bun run dev

This approach provides several benefits:

• Enhanced security - no .env files on disk
• Team collaboration - consistent secrets across team members
• Environment isolation - easy switching between dev/prod configurations

Using the Doppler CLI adds an additional layer of security and is incredibly valuable when working as a team.

7. pass - The Unix Password Manager

pass (also known as password store) describes itself as the standard Unix password manager. I like to describe it as the most perfect password manager for the terminal, making use of open source technologies such as GPG and Git.

Key Features

• GPG encryption for security
• Git integration for versioning and syncing
• Command-line interface for terminal workflows
• Self-hosted - you control your data

Example Usage

# Set environment variable from pass
export OPENAI_API_TOKEN=$(pass show api-tokens/openai)

# Use with database connections
psql $(pass show databases/prod-url)

# Copy password to clipboard
pass -c github.com

Secure Syncing

Because pass uses Git under the hood, you can securely sync passwords across machines:

# Clone encrypted password store
git clone git@github.com:username/password-store.git ~/.password-store

# Access requires GPG key (I use a YubiKey for additional security)
pass show some-password  # Requires YubiKey + PIN

Learn More: I've done a dedicated video on pass covering setup and configuration.

8. jq - JSON Processing Made Easy

jq is pretty much a staple for any backend/fullstack developer. It's a tool to make working with JSON data way more effective.

Basic Usage

By default, jq will automatically format any JSON passed via standard input:

curl api.example.com/data | jq

Advanced Filtering

The real power comes from jq filters, which allow you to extract and transform JSON data:

# Aggregate total sales value
curl api.example.com/sales | jq '[.[] | .value] | add'

# Extract specific fields
curl api.example.com/users | jq '.[] | {name: .name, email: .email}'

jq is invaluable for debugging APIs and automating JSON processing in shell scripts. While the syntax can be tricky to learn initially, it pays off in dividends.

9. stow - Dotfiles Management

stow is what I use for managing my dotfile configurations. It allows you to create symbolic links for files in a directory, making it perfect for storing dotfiles in a repository and deploying them across systems.

How stow Works

# Directory structure
~/dotfiles/
├── nvim/
│   └── .config/
│       └── nvim/
│           └── init.lua
└── zsh/
    ├── .zshrc
    └── .zsh_aliases

# Deploy configurations
cd ~/dotfiles
stow nvim  # Creates symlinks in ~/.config/nvim/
stow zsh   # Creates symlinks in ~/

Benefits

• Version control your configurations with Git
• Easy deployment across multiple machines
• Modular organization of different tool configs
• Rollback capability if something breaks

Learn More: I have a detailed video on stow on my second channel.

Note: Recently I've been experimenting with Home Manager for NixOS/Nix Darwin, but I still use stow for certain configurations where symbolic links are superior.

10. fzf - Interactive Fuzzy Finding

Last but certainly not least is fzf (or "fuzzy find" if you speak the Queen's English). While powerful by itself, fzf truly shines when integrated with other commands.

Basic Usage

# Interactive file selection
fzf

This opens a searchable list of files in the current directory with fuzzy matching.

Integration Examples

The real power comes from integration with other tools:

With password store:

# Interactive password selection
pass show $(pass ls | fzf)

# Or with shell integration, just press TAB:
pass show   # Opens fzf interface

With shell history:

# Search command history (Ctrl+R with fzf integration)
history | fzf

Building CLI Applications

fzf works excellently for building interactive CLI applications. In my Dreams of Code CLI, I use fzf to select lessons:

# Interactive lesson selection for course management
dreams-of-code edit $(dreams-of-code list-lessons | fzf)

Learn More: I cover building CLI applications with fzf in my CLI Applications in Go course.

Conclusion

These 10 CLI tools have fundamentally transformed how I work in the terminal over the past decade. Each one addresses specific pain points and inefficiencies in the default terminal experience:

1. zoxide - Effortless directory navigation
2. ripgrep - Lightning-fast text search
3. fd - Intuitive file finding
4. tmux - Session management and persistence
5. GitHub CLI - GitHub without the browser
6. Doppler CLI - Secure secrets management
7. pass - Terminal-native password management
8. jq - JSON processing powerhouse
9. stow - Dotfiles organization
10. fzf - Interactive fuzzy finding

Of course, these aren't the only tools I use in the CLI, but they are the ones that have had the biggest impact recently. The combination of these tools creates a powerful, efficient, and enjoyable terminal workflow that rivals any GUI-based development environment.

If you want to know about other tools I'm using, let me know in the comments and I'll consider doing a part two to this article!

Special thanks to Hostinger for sponsoring this content. If you need an affordable VPS for your projects, check them out and use coupon code DREAMSOFCODE for an additional 10% discount.

Related Resources

• Zoxide Configuration Video
• tmux Complete Guide
• GNU Stow Tutorial
• pass Setup Guide
• CLI Applications in Go Course