Commands

The modern command line: the names you know, far better tools underneath.

The classic Unix commands have faster, friendlier rewrites. This setup installs them and points the familiar names straight at them, because these are the same commands agents run, quote, and debug with you. Learn the words once and you can supervise both your own shell and an agent's shell.

#Already wired up

Two of the commands you'll type most are remapped the moment your shell starts. You don't do anything — ls and cat already run the better tools:

#Moving on the command line

Before you reach for the mouse or the arrow keys, these editing shortcuts move and erase text far faster. They work on every command you type, in any shell.

Two more that save real typing: as you type, the shell suggests the rest of a past command in grey — press CtrlE to accept it without leaving the home row. (It's the same "jump to end of line" key; since the line ends with the suggestion, that fills it in. The → arrow works too, but reaching for it is the habit worth dropping.) And !! repeats your last command (great as sudo !!), while !$ reuses its last argument.

#Folders and files

These are the folder moves beginners ask for first, and the commands experienced developers still type all day. . means "this folder"; .. means "the parent folder."

#The daily drivers

eza — listing files

Everything ls did, plus git status, icons, and a real tree view. The name is best remembered as the maintained, modern successor to exa.

$ ll
$ lt
# a two-deep tree of the current folder (eza --tree --level=2); ltt goes three deep

bat — reading files

A cat that highlights code, numbers lines, and marks git changes in the gutter. Piped into something else it quietly behaves like plain cat, so it never breaks a pipeline.

$ bat README.md
$ bat -p script.sh
# -p = plain, no line numbers or borders

ripgrep — searching inside files

Search every file in a project for text, fast. Groundwork configures rg with smart case: lowercase searches match any casing, while a capital letter makes the search case-sensitive. By default it respects .gitignore and skips hidden files; use rga when you deliberately want hidden and ignored files too.

$ rg test              # smart-case: finds test, Test, TEST
$ rg Test              # capital letter makes it case-sensitive
$ rg -t md heading     # only markdown files
$ rga api_key          # include hidden + ignored files, still skip .git

For fuzzy content search, use rgf. It runs ripgrep, opens the matches in fzf, previews with bat, and opens the selected line in your editor.

$ rgf button
$ rgf                 # live search as you type

fd — finding files by name

A simpler, quicker find. Type part of a name; it searches from here down, ignoring junk folders.

$ fd config
$ fd -e png            # files ending in .png

zoxide — jumping to folders

It remembers the folders you visit. After you've been somewhere once, z plus a few letters teleports you back from anywhere — no long paths.

$ z groundwork
$ z know               # jumps to ~/code/my-knowledge

fzf — fuzzy-finding anything

A fuzzy picker wired into the shell. Groundwork points its file picker at rg --files, so fuzzy file selection respects the same ignore rules as ripgrep. Three keystrokes are worth memorizing:

yazi — browsing the folder landscape

When you want to see a directory rather than list it — skim a tree, preview files as you arrow through them, do a quick bulk rename or move — y opens Yazi, a visual file browser. It is a choice, not a replacement for cd, fd, and eza: those composable commands stay the fundamentals and the shared language with agents. Yazi is the visual layer on top for the moments you would otherwise leave the terminal for a GUI file manager. Quitting is a choice between two keys: q lands the shell in whatever folder you were browsing, so a visual detour ends where you looked; Q quits without changing directory, for when the browsing was just a peek and you want to stay where you started.

$ y
# arrow keys or hjkl to move, Enter to open in the editor, O to pick an opener
# q quits into the folder you were browsing; Q quits back where you started

Groundwork manages ~/.config/yazi/yazi.toml so the preview pane gets most of the width — the panes are for navigating, the preview is for reading. The preview is still a glance, not a reader: press Enter to open the file in the editor, or O and choose Read with bat for a highlighted, scrollable view that drops you back into Yazi when you quit it.

Image, PDF, and video previews render inline in Ghostty, which speaks the Kitty graphics protocol. Yazi already uses the fd, rg, fzf, and bat that Groundwork installs; for richer previews of more formats you can optionally add poppler (PDF) and ffmpeg (video thumbnails).

largest: find space, then clean by owner

largest wraps dust in a command that is easier to remember. It shows the biggest entries first, stays on one filesystem, and follows the scan with a cleanup guide. Start in the narrowest useful folder: scanning a project is cheaper and easier to reason about than scanning the whole drive.

$ largest                 # current folder, top 50
$ largest ~               # home folder
$ largest --files /       # files on the startup filesystem
$ largest --folders -n 25 /Users
$ largest --help

On macOS, a root scan can only see protected locations when the terminal app has Full Disk Access in System Settings. On Linux, rerun with sudo only when the permission errors hide a location you actually need to inspect. Neither changes what is safe to delete.

copy-context — sharing exact files with another AI tool

When a chat app or outside reviewer cannot see your repo, copy a small, explicit bundle instead of pasting random snippets. copy-context takes files or folders, expands folders through rg --files when available, and puts path-labeled contents on the clipboard. It works the same way inside tmux because it is just a shell command.

$ copy-context AGENTS.md src tests
$ copy-context --stdout docs/workflow.html
$ copy-context --paths-only src

Default folder expansion respects ignore rules, so dependency and build folders stay out of the prompt. Use --stdout before pasting when the files are sensitive or large, and never copy secrets into a chat tool.

#Also installed

You won't reach for these every hour, but they're there when you need them.

#Practice

#Under the hood: the zsh setup

The shell you're typing into is zsh, and a few small pieces make it feel modern. You don't configure any of this by hand — it's all in ~/.zshrc and managed by the setup — but here's what's running and why.

Plugins, loaded by antidote

antidote is the plugin manager. It reads a plain list of plugins from ~/.zsh_plugins.txt and loads them fast (it pre-compiles them so your shell still starts instantly). Three plugins are on that list:

The init lines — what each tool hooks into your shell

Several tools need a line in ~/.zshrc to wire themselves in. This is where the prompt, directory-jumping, history, and version-switching come from:

History that's actually useful

zsh is tuned to keep a long, shared, de-duplicated history: 100,000 lines, written across all your open tabs at once, with exact duplicates collapsed. Two habits this unlocks: start a command with a space and it's kept out of history entirely (for anything with a secret in it), and CtrlR (atuin) searches the whole thing instantly.

Per-project tool versions — mise

The experienced-developer payoff. Instead of juggling nvm, pyenv, and friends, mise reads a mise.toml (or .tool-versions) in a project and gives you exactly the runtimes it asks for — the moment you cd in.

$ cd ~/code/my-app
$ mise use node@22 python@3.13   # pins them in mise.toml + installs
$ node --version                 # the pinned version, here only
$ mise install                   # on a fresh clone: grab everything the toml asks for

Walk into a different project and the versions change to match it automatically. Globally, this setup pins Node LTS, pnpm, and Python (in ~/.config/mise/config.toml), so every machine agrees on the baseline. mise install installs missing declared versions; mise upgrade deliberately advances floating baselines such as Node LTS to the newest matching patch. Upgrades are live at your next prompt, even in terminals that are already open, because mise refreshes the shell's PATH before each prompt. Python projects should still use uv for dependencies and virtual environments; mise supplies the interpreter and will source an existing uv .venv when you enter the project.

Resource defaults — open files and parallel builds

Two lines in ~/.zshrc make sure commands actually use a modern machine. Both are derived from the machine they run on, so the same setup behaves correctly on a laptop, a Linux box, or inside a container.

What's deliberately not configured: hard CPU or memory caps. macOS can't enforce per-process memory limits anyway, and a cap that silently kills a build is a worse beginner experience than a slow one. When you genuinely need hard limits — a runaway workload, or bounding an agent's sandbox — run it in a container, which is where real limits live: docker run --cpus 2 --memory 2g …. To see what's using the machine right now, run btop.

#Going deeper

• The Missing Semester: shell tools & scripting — how these fit together.
• Command line & Unix — this guide's deeper page: core commands, scripting, and curated resources.
• ShellCheck & explainshell — lint a script / explain any command line, piece by piece.
• mise documentation — per-project tools, env, and tasks in depth.