5 CLI Tools That Actually Changed How I Work in 2026

📋 Overview

▶ 0:00 Mischa van den Burg presents five CLI tools that fundamentally transformed his daily workflow. These aren't trendy new utilities — they're battle-tested, production-grade tools that serious DevOps engineers depend on every day. Together, they turn your terminal into a complete productivity system.

🧰 The 5 Tools at a Glance

🔍 fzf — Fuzzy Finding Everything

▶ 0:09 fzf is a general-purpose fuzzy finder for the command line. Pipe anything into it — files, command history, git branches, processes — and get instant, interactive fuzzy matching. It replaces Ctrl+R for shell history with a vastly superior experience: you can preview files while searching, chain it with find, grep, and git, and even use it as a selection interface for custom scripts.

Once you use fzf, you never go back to manual searching. It's the gateway drug to a CLI-centric workflow.

Example Commands

# Fuzzy search files in current directory
$ fzf

# Search with file preview
$ fzf --preview 'cat {}'

# Replace Ctrl+R — fuzzy search command history
$ history | fzf

# Fuzzy-find and open a file in vim
$ vim $(fzf --preview 'bat --color=always {}')

# Search git branches interactively
$ git branch | fzf | xargs git checkout

# Kill a process selected via fzf
$ kill $(ps aux | fzf | awk '{print $2}')

🖥 tmux — Your Terminal Window Manager

▶ 2:52 tmux replaces the need for multiple terminal windows entirely. It's a terminal multiplexer that lets you create sessions with named windows, split panes, and — critically — sessions that persist through SSH disconnects. This makes it essential for remote server work and increasingly for running multi-agent AI workflows.

Combine tmux + SSH and you have persistent remote workspaces that survive network drops. Your long-running builds, monitoring sessions, and agent processes keep running no matter what happens to your connection.

Essential tmux Commands

# Start a new named session
$ tmux new -s myproject

# Detach from session (inside tmux)
prefix + d

# List active sessions
$ tmux ls

# Reattach to a session
$ tmux attach -t myproject

# Split pane horizontally / vertically
prefix + %      # vertical split
prefix + "      # horizontal split

# Navigate panes
prefix + ←/→/↑/↓

# Create a new window
prefix + c

# Rename current window
prefix + ,

🔐 SSH — Beyond Just Logging In

▶ 8:21 SSH is far more than ssh user@host. Most engineers massively underutilize its built-in capabilities. The ~/.ssh/config file lets you manage dozens of servers with named aliases, custom keys, and jump hosts. ProxyJump makes bastion/jump host chaining trivial. SSH agent forwarding lets you use your local keys on remote machines without copying them.

SSH Config Example

# ~/.ssh/config

# Jump host / bastion
Host bastion
    HostName bastion.example.com
    User admin
    IdentityFile ~/.ssh/id_ed25519

# Production server (via bastion)
Host prod-web
    HostName 10.0.1.42
    User deploy
    ProxyJump bastion
    ForwardAgent yes

# Now just:
$ ssh prod-web
# ↑ Automatically jumps through bastion

🚇 SSH Port Forwarding Into Remote Containers

▶ 10:21 Port forwarding is SSH's superpower that eliminates the need to publicly expose services during development. Local forwarding maps a remote port to your localhost. Remote forwarding exposes a local service to the remote machine. Dynamic forwarding creates a SOCKS proxy. The real-world killer use case: forwarding ports directly into Kubernetes pods and Docker containers on remote servers.

Port Forwarding Commands

# Local forwarding: access remote :8080 on localhost:3000
$ ssh -L 3000:localhost:8080 prod-web

# Remote forwarding: expose local :3000 to remote :9090
$ ssh -R 9090:localhost:3000 prod-web

# Dynamic forwarding (SOCKS proxy on :1080)
$ ssh -D 1080 prod-web

# Forward into a Kubernetes pod
$ ssh -L 5432:localhost:5432 prod-web -t \
    "kubectl port-forward pod/my-db 5432:5432"

# Chain: access a Docker container's port via SSH
$ ssh -L 8080:172.17.0.2:80 prod-web

🔑 pass — Unix Password Management

▶ 14:18 pass is the standard Unix password manager. Each password is stored as a GPG-encrypted file in ~/.password-store. It has built-in git integration for version control and syncing across machines. Combined with gpg-agent for credential caching, it's a fully local, zero-cloud-dependency password solution with no vendor lock-in.

pass Commands

# Initialize password store with your GPG key
$ pass init "your-gpg-id@email.com"

# Enable git tracking
$ pass git init

# Insert a new password
$ pass insert email/work

# Generate a random 24-char password
$ pass generate web/github 24

# Show a stored password
$ pass show email/work

# Copy password to clipboard (clears after 45s)
$ pass -c web/github

# List all entries
$ pass

# Sync across machines via git
$ pass git push

🤖 fabric — AI Chained Into Your Terminal

▶ 17:05 fabric by Daniel Miessler is a game-changer for automating AI-assisted text processing. It chains AI directly into your Unix workflow — pipe any text through pre-built or custom patterns (prompt templates): summarize, extract wisdom, analyze claims, write essays. Combined with standard Unix tools like curl and tee, it turns your shell into an AI-powered text processing pipeline.

fabric Commands

# Summarize piped text
$ echo "long article text..." | fabric --pattern summarize

# Extract wisdom from a YouTube transcript
$ yt --transcript https://youtu.be/xyz | fabric --pattern extract_wisdom

# Analyze claims in an article
$ curl https://example.com/article | fabric --pattern analyze_claims

# Chain with tee to save output
$ cat report.md | fabric --pattern summarize | tee summary.md

# List available patterns
$ fabric --list

# Create a custom pattern
$ fabric --setup

⚡ The Compound Effect

▶ 22:06 These five tools don't just add value individually — they multiply each other. Each tool fills a specific gap, and together they create a complete terminal-native productivity system.

✅ Key Takeaways