My Terminal Stack: Opinionated Tools That Just Work

After years of tweaking dotfiles and chasing the perfect terminal setup, I’ve settled on a powerhouse combination of tools that share one critical trait: they have sane defaults and just work out of the box. These aren’t minimalist UNIX philosophy tools – they’re opinionated, feature-rich, and designed to make you productive immediately. Here’s my quick-setup stack that transforms any terminal into a modern development environment.

The Philosophy of Opinionated Software

This preference for opinionated tools traces back to when Ruby first made programming click in my brain. As Matz (Yukihiro Matsumoto) said about Ruby’s design: “I want to solve problems I meet in the daily life by using computers, so I need to write programs. By using Ruby, I want to concentrate the things I do, not the magical rules of the language… I just want to say, ‘print this!’”

That philosophy – focusing on human happiness over machine optimization – fundamentally changed how I approach tools. DHH’s Rails took this further with “convention over configuration,” proving that opinionated software with sensible defaults leads to better productivity than endless configurability.

Ruby taught me to appreciate this mindset despite its occasional drawbacks. Sometimes the opinions don’t match your needs, but 90% of the time they align with best practices you’d eventually adopt anyway. This same principle guides my terminal stack choices.

The Core Stack: Fish + FZF + Eza + Starship

This combination has become my go-to on every machine I touch. Each tool is opinionated about how things should work, and those opinions align perfectly with modern development workflows.

Fish Shell: The Shell That Thinks for You

Fish throws POSIX compatibility out the window in favor of actually being useful. Syntax highlighting, autosuggestions, and web-based configuration come standard. No more sourcing .bashrc files or installing oh-my-zsh – it just works.

FZF: Fuzzy Finding Everything

FZF turns every list into an interactive, searchable interface. Command history, file navigation, git branches – everything becomes instantly searchable with fuzzy matching. It’s one of those tools that makes you wonder how you lived without it.

Eza: ls for the 21st Century

Eza (the maintained fork of exa) makes file listings actually readable. Color coding, git integration, tree views, and human-readable sizes by default. It’s what ls should have evolved into decades ago.

Starship: The Prompt That Knows Everything

Starship gives you a context-aware prompt that shows git status, language versions, cloud contexts, and more – all with millisecond performance. One config file works across all shells and all platforms.

Quick Setup Guide

Here’s how to get this stack running on popular distros in under 5 minutes:

Arch/CachyOS

sudo pacman -S fish fzf eza starship
chsh -s /usr/bin/fish
# Restart terminal
echo "starship init fish | source" >> ~/.config/fish/config.fish

Ubuntu/Debian

sudo apt update
sudo apt install fish fzf
# Eza needs cargo or manual install
curl -sS https://raw.githubusercontent.com/eza-community/eza/main/install.sh | sh
# Starship via installer
curl -sS https://starship.rs/install.sh | sh
chsh -s /usr/bin/fish
# Restart terminal
echo "starship init fish | source" >> ~/.config/fish/config.fish

Fedora

sudo dnf install fish fzf eza
# Starship via installer
curl -sS https://starship.rs/install.sh | sh
chsh -s /usr/bin/fish
# Restart terminal
echo "starship init fish | source" >> ~/.config/fish/config.fish

NixOS (Because of Course It’s Different)

# In your home-manager configuration
{
  programs.fish = {
    enable = true;
    interactiveShellInit = ''
      ${pkgs.starship}/bin/starship init fish | source
    '';
  };
  
  programs.fzf = {
    enable = true;
    enableFishIntegration = true;
  };
  
  programs.eza = {
    enable = true;
    enableFishIntegration = true;
  };
  
  programs.starship = {
    enable = true;
    enableFishIntegration = true;
  };
}

Look, I love NixOS, but the irony isn’t lost on me – here I am praising tools for their “sane defaults that just work” while using an OS that requires declaring your entire system in a functional programming language. But hey, at least once it’s declared, it works everywhere!

The New Kid: Ghostty

Ghostty is working its way into my standard setup. Mitchell Hashimoto (of Vagrant/Terraform fame) is building what might be the terminal emulator we’ve been waiting for. It’s GPU-accelerated, cross-platform, and aims to be fast without sacrificing features. Currently in beta with macOS and Linux support, it’s worth keeping an eye on. The performance is already impressive, and the feature set is growing rapidly.

Special Mention: Nushell for Data Wrangling

Nushell deserves a special callout. It’s not a drop-in replacement for your daily shell – it’s a completely different paradigm that treats everything as structured data. Think PowerShell but actually pleasant to use.

I don’t use it as my default shell, but I reach for it whenever I need to:

• Parse JSON/CSV/YAML files
• Transform data between formats
• Do complex filtering and aggregation
• Work with APIs that return structured data

Quick example that shows its power:

# List all Docker containers with their sizes, sorted
docker ps -a --format json | from json | sort-by Size | select Names Status Size

Why This Stack Works

What makes these tools special isn’t just their features – it’s their philosophy:

1. Batteries Included: Everything you need works out of the box
2. Sensible Defaults: The default behavior is what you’d want 90% of the time
3. Cross-Platform: Same experience on macOS, Linux, and WSL
4. Fast: All these tools prioritize performance
5. Beautiful: They make your terminal actually pleasant to look at

My Quick Config

After installing, I add these aliases to ~/.config/fish/config.fish:

alias ls="eza --icons"
alias ll="eza -l --icons"
alias la="eza -la --icons"
alias tree="eza --tree --icons"

And that’s it. No hours tweaking configurations, no massive framework installations, no plugin managers. Just tools that respect your time and make you productive immediately.

The Bottom Line

Perfect is the enemy of good, and these tools are really, really good. They’ve eliminated 90% of my terminal friction with 10% of the configuration effort. Whether you’re on a fresh Ubuntu install or managing a fleet of servers, this stack will make your command-line experience dramatically better in minutes, not hours.

Give them a try – your future self will thank you when you’re fuzzy-finding through command history instead of mashing the up arrow for the hundredth time.