10 CLI Tools That Made the Biggest Impact
Introduction
The command line remains a powerful ally for anyone working in tech. Whether you’re managing Kubernetes clusters, writing code, automating deployments, or writing prose in markdown files the right set of tools can significantly boost your efficiency.
Over the years, I’ve integrated various CLI (Command Line Interface) and TUI (Terminal User Interface) tools into my daily workflow. Some have become so essential that I can’t imagine working without them. In this post, I’ll share 10 of these tools that have proven their worth time and time again.
From fuzzy finders to git interfaces, from task managers to file viewers, these tools cover a wide range of functionalities. They’re not just about saving keystrokes — they’re about making complex tasks simpler and letting you focus on what matters most.
I’m using those tools on Linux, but they should work on most operating systems.
For the impatient, here is tl;dr we are going to look at interesting usecases for those commands:
- fzf: A fuzzy finder that enhances command-line workflows with interactive searching.
- bpytop: Resource monitor that shows usage and stats for processor, memory, disks, network and processes.
- tmux: A terminal multiplexer for managing multiple terminal sessions efficiently.
- lazygit: A TUI for git operations, simplifying repository management.
- gh (GitHub CLI): A GitHub CLI tool to manage repositories, issues, and PRs from the terminal.
- entr: A utility that runs commands when files change, useful for automation.
- just: A command runner for managing project-specific tasks with simple commands.
- taskwarrior: A command-line tool for efficient task management.
- tldr: Simplified man pages providing quick command examples.
- pet: A snippet manager for saving and reusing complex command-line commands.
Terminal Enhancement and Navigation
If command line tools are like tools in a toolbelt, then ensuring your toolbelt is well-equipped and versatile should be top priority!
The tools in this category enhance terminal experience, making navigation and multitasking a breeze. They’re the foundation of a productive CLI workflow, allowing to work faster and more intuitively.
fzf (Fuzzy Finder)
fzf is a powerful fuzzy finder that can significantly enhance your command-line workflow. Here are three custom functions that leverage fzf to streamline common tasks. You can add them to .bash(zsh)rc
Interactive process killing:
function pkill() {
ps aux | fzf --height 40% --layout=reverse --prompt="Select process to kill: " | awk '{print $2}' | xargs -r sudo kill
}This function presents an interactive list of running processes. You can search and select a process to kill, all without needing to remember PIDs or use grep.
Git log navigation and browsing:
function logg() {
git lg | fzf --ansi --no-sort \
--preview 'echo {} | grep -o "[a-f0-9]\{7\}" | head -1 | xargs -I % git show % --color=always' \
--preview-window=right:50%:wrap --height 100% \
--bind 'enter:execute(echo {} | grep -o "[a-f0-9]\{7\}" | head -1 | xargs -I % sh -c "git show % | nvim -c \"setlocal buftype=nofile bufhidden=wipe noswapfile nowrap\" -c \"nnoremap <buffer> q :q!<CR>\" -")' \
--bind 'ctrl-e:execute(echo {} | grep -o "[a-f0-9]\{7\}" | head -1 | xargs -I % sh -c "gh browse %")'
}This function combines fzf with git log, providing an interactive interface to browse your git history. It offers a preview of each commit and allows you to open the full commit details in Neovim or browse it on GitHub. This is invaluable for quickly navigating complex git histories.
Repositories browsing:
function repo() {
export repo=$(fd . ${HOME}/dev --type=directory --max-depth=1 --color always| awk -F "/" '{print $5}' | fzf --ansi --preview 'onefetch /home/decoder/dev/{1}' --preview-window up)
if [[ -z "$repo" ]]; then
echo "Repository not found"
else
echo "Repository found locally, entering"
cd ${HOME}/dev/$repo
if [[ -d .git ]]; then
echo "Fetching origin"
git fetch origin
onefetch
fi
create_tmux_session "${HOME}/dev/$repo"
fi
}This function streamlines repositores navigation. It uses fzf to interactively select a repository from dev directory (you need to adjust it for your setup), then automatically changes to that directory, fetches the latest changes, and sets up a tmux session. It’s a great example of how fzf can be integrated into more complex workflows to boost productivity. If you want to use this funciton as is, remember to install onefetch.
more on
create_tmux_session funcitonlater.
bpytop (Resource Monitoring)
bpytop is a visually appealing and intuitive command-line tool for real-time system monitoring. It allows you to track CPU, memory, disk, and network usage with colorful, easy-to-read graphs, making it far more engaging than traditional tools like top or htop.
To monitor system performance, simply run:
bpytopThis command launches an interface that displays real-time resource usage, helping you quickly identify and manage resource-heavy processes. It’s especially useful for developers and system admins who need to keep an eye on system health.
Integrating bpytop into your workflow idea: add this binding to your .tmux.conf
bind -n M-b popup -d '#{pane_current_path}' -E -h 95% -w 95% -x 100% "bpytop"
tmux (Terminal Multiplexer)
tmux is a terminal multiplexer that allows you to create, access, and control multiple terminal sessions from a single screen. It’s an essential tool for managing complex workflows, especially when working on multiple projects or with remote servers.
While tmux is powerful on its own, its true potential is realized when integrated into your broader development workflow. Here’s a custom function that demonstrates this integration:
we are using this funciton in the repo funciton
function create_tmux_session() {
local RESULT="$1"
zoxide add "$RESULT" &>/dev/null
local FOLDER=$(basename "$RESULT")
local SESSION_NAME=$(echo "$FOLDER" | tr ' .:' '_')
if [ -d "$RESULT/.git" ]; then
SESSION_NAME+="_$(git -C "$RESULT" symbolic-ref --short HEAD 2>/dev/null)"
fi
if ! tmux has-session -t "$SESSION_NAME" 2>/dev/null; then
tmux new-session -d -s "$SESSION_NAME" -c "$RESULT"
fi
if [ -z "$TMUX" ]; then
tmux attach -t "$SESSION_NAME"
else
tmux switch-client -t "$SESSION_NAME"
fi
}This function does several things:
- It creates a tmux session named after your project folder and git branch.
- It integrates with
zoxide, a smart cd command, to track your most-used directories. - It checks if a session already exists, creating one if it doesn’t.
- It either attaches to the session or switches to it, depending on whether you’re already in tmux.
While tmux has many built-in commands and key bindings, this function shows how you can build upon its capabilities to create a workflow tailored to your needs.
For those interested in further integrating tmux with other tools, check out my blog post on Neovim AutoCommands, where I discuss how to create an even more powerful setup by connecting tmux with Neovim.
Development Workflow
This section focuses on tools that enhance your interaction with version control systems, automate repetitive tasks, and improve your overall development process.
lazygit (Git TUI)
lazygit offers a visual interface for git operations, making repository management more intuitive. It’s a simple terminal UI that simplifies common git tasks without the need to remember complex commands.
To use lazygit, simply navigate to your git repository in the terminal and type lazygit. This launches the interface where you can stage files, commit changes, and manage branches using keyboard shortcuts.
One of lazygit’s strengths is its diff view. You can easily review changes before committing by navigating to a file and pressing ‘d’. This visual representation of changes can be incredibly helpful when preparing commits.
For more complex git operations, lazygit shines with features like interactive rebasing. You can start an interactive rebase by navigating to a commit and pressing ‘r’, then ‘i’. This makes tasks like squashing or reordering commits much more straightforward than using the command line.
gh (GitHub CLI)
gh brings GitHub functionality directly to your terminal, making it easy to manage repositories, issues, pull requests, and more without leaving your command-line environment.
Creating a GitHub Repository
Creating a new GitHub repository is straightforward with gh. To create a new repository, simply run:
gh repo create my-new-repo --public --description "My new repository"This command creates a new public repository named “my-new-repo” with the specified description. You can also create private repositories by adding the --private flag.
Creating a Gist
Gists are a great way to share code snippets or small scripts. You can create a new gist with gh using the following command:
gh gist create my_script.sh --public --desc "A simple bash script"This command creates a public gist with the contents of my_script.sh and the specified description. For a private gist, you can omit the --public flag.
Using GitHub’s AI-Powered Commands
GitHub has integrated AI capabilities into gh for various tasks. For example, you can ask GitHub Copilot to suggest code directly from the terminal:
gh copilot suggest "Install git"
Or in explain mode
gh copilot explain "traceroute github.com"
There are many ai command line companions. Learn more about AI focused command line tools:
entr (Event Notify Test Runner)
entr is a utility that watches for file changes and runs specified commands in response. It’s particularly useful for automating tasks like running tests or reloading applications during development.
For instance, you can set up entr to run your test suite whenever a file changes. A command like find . -name "*.go" | entr go test ./... will automatically run your Go tests every time you save a .go file. This immediate feedback can be invaluable during test-driven development.
When working on web applications, entr can help with live reloading. The command find . -name "*.py" | entr -r python app.py will restart your Python web server whenever you make changes to your code. The -r flag ensures that entr restarts the command when it exits.
Task and Project Management
The tools in this category help streamline your workflow, orchestrate commands, and keep track of your to-dos, allowing you to focus on what matters most.
just (Command Runner)
just is a handy command runner that serves as a modern, more powerful alternative to make. It allows you to save and run project-specific commands, significantly simplifying project management and task automation.
At its core, just uses a file called justfile (similar to a Makefile) where you define commands or “recipes”. These recipes can be simple one-liners or complex scripts, and they’re executed by running just <recipe-name> in your terminal.
Here is a sample recipe creating a local KIND cluster.
# setup kind cluster
setup_kind cluster_name='control-plane':
#!/usr/bin/env bash
set -euo pipefail
echo "Creating kind cluster - {{cluster_name}}"
envsubst < kind-config.yaml | kind create cluster --config - --wait 3m
kind get kubeconfig --name {{cluster_name}}
kubectl config use-context kind-{{cluster_name}}I wrote a separete blog about justfile, give it a read:
taskwarrior (Task Management)
taskwarrior is a powerful, open-source task management tool that operates entirely from the command line. It’s designed to help you organize, plan, and track your tasks efficiently.
With taskwarrior, adding a new task is as simple as typing task add. For example, task add Write blog post about command-line tools due:tomorrow adds a new task with a due date. You can then view your tasks by typing task, which shows a list of pending tasks sorted by urgency.
taskwarrior handles complex task attributes well. You can add priorities, tags, projects, and even dependencies between tasks. A command like task 1 modify priority:H project:BlogPost +writing would set a high priority, assign it to the BlogPost project, and add a ‘writing’ tag to task 1.
One of taskwarrior’s most powerful features is its robust filtering system. You can easily view tasks by project (task project:BlogPost), due date (task due:today), or any combination of attributes. This flexibility allows you to focus on what’s important at any given moment.
I use it extensively and it definitelly deserves its own blog!
Information Organization and Help
This group of tools focuses on making it easier to find, view, and manage the information you need, whether it’s command snippets, documentation, or searching through various file types.
tldr (Simplified Man Pages)
tldr is a community-driven effort to simplify man pages with practical examples. It provides concise, example-focused summaries of command-line tools, making it easier to quickly understand and use various commands.
Simply type tldr followed by the command name. For instance, tldr tar will give you a quick overview of the most common tar commands with practical examples.
What sets tldr apart is its focus on real-world usage. Instead of wading through comprehensive documentation, you get straight to the point with examples that cover the most common use cases.
pet (Command Snippet Manager)
pet is a command-line snippet manager. It’s designed to help you remember and quickly access those complex commands you use infrequently but are essential to your workflow.
With pet, you can easily save, search, and execute command snippets directly from your terminal. This is particularly useful for DevOps engineers and developers who frequently work with complex CLI commands.
Learn more about pet snippet manager:
To add a new snippet, you can use the pet new command. This will prompt you to enter the command and a description. For example:
pet new
Command> awk -F, 'NR <=2 {print $0}; NR >= 5 && NR <= 10 {print $0}' company.csv
Description> Print specific lines from a CSV fileClosing Thoughts
We’ve taken a tour through some of my favorite command-line tools. From fzf’s fuzzy finding magic to pet’s snippet commands library, these tools aren’t just about saving keystrokes — they’re about bringing a bit of fun back into our daily command-line workflow.
Remember, the goal here isn’t to overcomplicate your workflow with a Swiss Army knife of tools. It’s about finding those gems that click with your style and supercharge your productivity.
As with any toolset, the real power comes from integrating these tools into your daily routine. Start small, maybe with just one or two that catch your attention. Before you know it, you might find yourself wondering how you ever lived without them.
Thanks for taking the time to read this post. I hope you found it interesting and informative.
🔗 Connect with me on LinkedIn
🌐 Visit my Website
📺 Subscribe to my YouTube Channel
