Your Cockpit: Making the Terminal a Place You Like

The default white-on-black is fine, but "fine" is not what you want from a tool you'll live in. Every terminal app ships with themes, font settings, and transparency — five minutes of setup pays off every day after:

A taste of prompt customization

The prompt itself — that user@host:~$ from the intro — is just a variable named PS1, short for prompt string 1, and you set it the way you set any variable (Environment Variables):

PS1="\w > "
# ~/projects >              <- your prompt is now the current directory

PS1="🌲 \W $ "
# 🌲 projects $             <- yes, emoji work

The name implies a PS2, and there is one: the continuation prompt — the bare > you get if you press Enter with a quote still hanging open. That's the shell asking you to finish the line, not an error.

Hand-rolling a fancy PS1 with colors and git status is a classic rabbit hole. The modern shortcut is Starship — a fast, cross-shell prompt that works in bash, zsh, and every OS in this course. One install, one line in your shell config (Your Shell Config, .bashrc / .zshrc), and your prompt shows the current directory, git branch, language versions, and whether the last command failed — the useful stuff, with zero maintenance.

Pair it with a couple of small zsh plugins — extra files your shell config loads at startup, the same mechanism as the aliases you added there yourself, only someone else wrote the file. Two earn their place: zsh-autosuggestions greys in the rest of a command as you start typing it, and zsh-syntax-highlighting turns a command red before you press Enter if the shell can't find it. A framework like oh-my-zsh bundles hundreds instead, and charges you startup time for the ones you'll never use.

Try It: Design Your Prompt

Enough talk — build one. Pick a design, make it yours, and take the real starship.toml home. This is a genuine config for Starship, the cross-shell prompt — nothing here touches your machine until you choose to install it.

"$schema" = 'https://starship.rs/config-schema.json'

add_newline = false

format = """
[░▒▓](fg:#7aa2f7)\
$directory\
[](fg:#7aa2f7 bg:#bb9af7)\
$git_branch$git_status\
[](fg:#bb9af7 bg:#7dcfff)\
$nodejs\
[](fg:#7dcfff bg:#9ece6a)\
$python\
[](fg:#9ece6a bg:#e0af68)\
$cmd_duration\
[](fg:#e0af68)\
$character"""

[character]
success_symbol = '[❯](bold fg:#9ece6a)'
error_symbol = '[❯](bold fg:#f7768e)'

[directory]
truncation_length = 3
truncation_symbol = '…/'
truncate_to_repo = false
style = "fg:#1a1b26 bg:#7aa2f7"
format = '[ $path ]($style)'

[git_branch]
symbol = ' '
style = "fg:#1a1b26 bg:#bb9af7"
format = '[ $symbol$branch ]($style)'

[git_status]
style = "fg:#1a1b26 bg:#bb9af7"
format = '[ $all_status$ahead_behind]($style)'

[nodejs]
symbol = ' '
style = "fg:#1a1b26 bg:#7dcfff"
format = '[ $symbol($version) ]($style)'

[python]
symbol = ' '
style = "fg:#1a1b26 bg:#9ece6a"
format = '[ $symbol($version) ]($style)'

[cmd_duration]
min_time = 500
style = "fg:#1a1b26 bg:#e0af68"
format = '[  $duration ]($style)'

Watch someone fluent in the terminal and you'll notice they barely type. The shell writes down every command you run in a file it keeps between sessions — that record is your history, and it is not the same thing as scrollback, the output still sitting in the window above your prompt. Scrollback is what a screenshot captures, and it dies with the window; history outlives it. The recall tools built on that record are the biggest speed unlock in this course:

history | grep backup
#  212  ./backup.sh notes
#  340  ./backup.sh recipes

npm run deploy
# Error: permission denied
sudo !!
# sudo npm run deploy       <- the shell shows what !! became

# (reverse-i-search)`dep': npm run deploy     <- Ctrl+R, then "dep"

Try It: Retrace Your Steps

Here's where all of this lands in daily life. VS Code has a full terminal built into the editor — toggle it with ⌃` (Control + backtick, same keys on every OS), and it slides up as a panel beneath your code. It's not a lookalike or a simulation — it runs your real shell, with your .bashrc, your aliases, your PATH, your history. Everything from this course works in it unchanged.

Two conveniences make it better than a separate window: it opens already cd'd into your project folder (no navigating to where your code lives — you're there), and the + button in the panel spawns extra terminals in the same place, with a dropdown to pick which shell (bash, zsh, or on Windows: WSL, Git Bash, PowerShell).

That shared visibility is the practical payoff of Terminal for the AI Era: when the agent asks permission to run a command, you audit it first; when it writes a setup.sh, you read it line by line; when it says "tests failed," you can see the exit code it saw. The integrated terminal is the one place code, agent, and shell meet — all in a single window.

VS Code even builds the red-flag mental model from Read Before You Run into settings. Copilot's agent mode runs terminal commands with per-command approval, and you can maintain an allowlist and denylist of which commands auto-approve — let git status through without asking, always stop on rm -rf and sudo. Claude Code ships a VS Code extension that drives the same CLI from a panel in the editor — same terminal, same approval moments, same skills.

Sooner or later one terminal isn't enough: a dev server occupies one (it runs until you stop it, holding the prompt hostage), tail -f follows a log in another (Moving Around), and you still need a free prompt to actually work. The answer is never "quit the server" — it's more terminals, and every modern terminal app makes that cheap:

A classic three-pane cockpit for a coding session: the dev server in one pane, tail -f server.log in a second, and a free prompt in the third — with your agent's terminal from Terminal in VS Code alongside. Every shell is independent: its own working directory, its own cd, its own foreground command. Nothing you do in one pane disturbs another.

And here's the 2026 twist that turned splits from a power-user nicety into standard practice: people now run multiple AI agents in parallel — one agent per pane or tab, each pointed at its own copy of the project (git calls that a worktree) so they never collide. The split layout stops being "server here, logs there" and becomes several agents, each in its own pane: three panes, three agents on three tasks, and you sweeping your eyes across all of them, approving and course-correcting. Every pane is just a shell — which is why everything in this course scales from one terminal to ten.

One name to file away for later: tmux, a terminal multiplexer that does tabs and splits inside the terminal itself — and whose sessions survive the window closing, your laptop sleeping, even an SSH connection dropping. You log back in, reattach, and every pane is exactly where you left it (agents included — which is why people running several at once tend to live in it).

Careful with that word, though — everywhere else in this course a session is one shell's lifetime, and it dies with its window. A tmux session is a named collection of panes living in a process of its own, which is how it survives yours closing. Its keybindings feel arcane for one reason: every one of them starts with the same two keys, Ctrl+B, pressed and released before the key that does the work — so splitting a pane is Ctrl+B, then %.

Zellij is the friendlier modern multiplexer, with its shortcuts printed on screen. Overkill for today; indispensable the day you work on remote servers. It'll be waiting.