Your dev environment, properly set up

You will spend the next several thousand hours inside a terminal and an editor. The compound cost of a bad setup is enormous, and the cost of the right setup is two or three hours, once. This module gets you there.

The trap most students fall into is not “my setup is broken.” It is “my setup is fine, plus I keep tinkering with it instead of building.” We will set you up on opinionated defaults and stop. Tinkering with terminal themes and editor color schemes is procrastination wearing engineering clothes. Do the setup, close this tab, and write code.

One more thing before we start. If you are on Windows: do not develop on Windows directly. Use WSL2 (instructions below) and treat your machine as a Linux box that happens to have a nice GUI. Almost every guide, every error message, every Stack Overflow answer assumes Linux semantics. Fighting that is a multi-year tax for no benefit.

Set up

Pick your OS section. Run the commands. Skip nothing.

macOS

# Install Homebrew (the package manager you will use forever)
/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

# Add it to your PATH (Apple Silicon)
echo 'eval "$(/opt/homebrew/bin/brew shellenv)"' >> ~/.zprofile
eval "$(/opt/homebrew/bin/brew shellenv)"

# Core tools you actually need
brew install git gh tmux ripgrep fd jq bat fzf wget curl
brew install --cask iterm2 visual-studio-code

Ubuntu / Debian Linux

sudo apt update && sudo apt upgrade -y
sudo apt install -y build-essential git curl wget tmux jq fzf ripgrep fd-find bat
# Note: on Debian, ripgrep is rg, fd is fdfind, bat is batcat — alias them:
mkdir -p ~/.local/bin
ln -sf "$(which fdfind)" ~/.local/bin/fd
ln -sf "$(which batcat)" ~/.local/bin/bat

Windows (you are using WSL2)

# In an admin PowerShell:
wsl --install -d Ubuntu-22.04
# reboot, finish Ubuntu setup with a username + password
# from now on, you live inside the Ubuntu shell — install VS Code on Windows,
# but use the "WSL: Connect to..." extension to develop inside Linux

Then run the Ubuntu commands above.

If any of this fails, do not start configuring. Fix the install first. A half-installed environment will haunt you for months.

Read these first

Four sources, in this order, then stop.

1. Julia Evans — Bite Size Linux / Bite Size Bash. zines · 30 min · the friendliest serious intro to the shell. Worth the small fee.
2. Microsoft — WSL2 docs. link · 20 min · only if you’re on Windows; skim, don’t memorize.
3. Mathias Bynens — dotfiles. repo · 15 min skim · the canonical example of a real engineer’s dotfiles.
4. Wes Bos — Command Line Power User (free). link · 90 min · the cleanest video walkthrough of a modern setup.

Don’t read 30 “best terminal in 2026” Medium posts. They are all derivative of these.

Shell: pick zsh, stop tinkering

macOS and most Linux distros default to zsh now. That is fine. Do not install oh-my-zsh. It is a beginner trap — it adds 200ms of startup time, drags in 80 plugins you don’t use, and obscures what your shell is actually doing. Use vanilla zsh with a couple of focused plugins.

Add this to ~/.zshrc:

# Better history
HISTSIZE=50000
SAVEHIST=50000
HISTFILE=~/.zsh_history
setopt HIST_IGNORE_DUPS HIST_IGNORE_SPACE INC_APPEND_HISTORY SHARE_HISTORY

# Useful aliases
alias ll='ls -lah'
alias gs='git status'
alias gd='git diff'
alias gp='git pull'
alias rg='rg --hidden --smart-case'

# fzf integration (after `brew install fzf` and running its install script)
[ -f ~/.fzf.zsh ] && source ~/.fzf.zsh

# A simple, fast prompt — no Powerline nonsense
autoload -Uz vcs_info
precmd() { vcs_info }
zstyle ':vcs_info:git:*' formats ' (%b)'
setopt PROMPT_SUBST
PROMPT='%F{cyan}%~%f%F{yellow}${vcs_info_msg_0_}%f $ '

That is enough. If you want syntax highlighting and autosuggestions later, install zsh-syntax-highlighting and zsh-autosuggestions — two small plugins, not a framework.

If you are on fish, that’s fine too. The point is: pick one, stop tweaking it.

Language version managers: fnm and uv

Two tools, both fast, both modern. They replace nvm and pyenv, which were the old standards and are slower and clunkier.

# fnm — Node version manager (Rust, near-instant)
brew install fnm           # macOS
# or: curl -fsSL https://fnm.vercel.app/install | bash
echo 'eval "$(fnm env --use-on-cd)"' >> ~/.zshrc

fnm install 22             # Node 22 LTS
fnm default 22

# uv — Python package + version manager (Rust, replaces pip + venv + pyenv)
curl -LsSf https://astral.sh/uv/install.sh | sh
uv python install 3.12

A new project then looks like:

mkdir myproj && cd myproj
uv init                    # for Python
uv add requests
# or for Node:
pnpm init
pnpm add zod

If you have ever lost a weekend to nvm conflicts or “pip vs pip3 vs pipenv vs poetry” — that pain stops here. uv and fnm are the answer.

Editor: VS Code or Cursor, not vim

Pick VS Code or Cursor. Both are free for students. Cursor is VS Code with stronger AI built in — recommended if you can spare the $20 a month, but VS Code with the Continue extension or Copilot is fine.

A small set of extensions covers 90% of what you need:

ms-python.python              # Python
charliermarsh.ruff            # Python lint+format
dbaeumer.vscode-eslint        # JS / TS lint
esbenp.prettier-vscode        # JS / TS format
rust-lang.rust-analyzer       # Rust
golang.go                     # Go
ms-vscode-remote.remote-wsl   # if on Windows
github.copilot                # or Continue / Cursor

Settings worth turning on (in ~/.config/Code/User/settings.json or via the GUI):

{
  "editor.formatOnSave": true,
  "editor.tabSize": 2,
  "editor.rulers": [100],
  "files.trimTrailingWhitespace": true,
  "files.insertFinalNewline": true,
  "terminal.integrated.defaultProfile.osx": "zsh"
}

The unpopular take: don’t learn vim deeply yet. Vim is a beautiful tool and a giant time-sink for new students. Learn hjkl, i, :wq, and dd — enough to edit a config file over SSH — and come back to vim/nvim seriously after a year of shipping.

tmux in five minutes

tmux lets you have multiple terminal panes and detach/reattach sessions. You will need it the first time you SSH into a server and don’t want your work to die when the network blips.

brew install tmux           # if you didn't already
# minimal ~/.tmux.conf
cat > ~/.tmux.conf <<'EOF'
set -g mouse on
set -g base-index 1
set -g default-terminal "tmux-256color"
bind | split-window -h
bind - split-window -v
EOF

# Use it
tmux new -s work
# Ctrl-b | to split vertical, Ctrl-b - to split horizontal
# Ctrl-b d to detach
tmux attach -t work

That is enough tmux for the first year. Don’t install plugins. Don’t theme it.

SSH keys + gh login

You will use git constantly. Set this up once.

# Generate an ed25519 key (modern; do not use RSA)
ssh-keygen -t ed25519 -C "you@example.com"
# Press enter to accept defaults; set a passphrase or skip

# Start the agent
eval "$(ssh-agent -s)"
ssh-add ~/.ssh/id_ed25519

# Authenticate gh (uses GitHub OAuth, simpler than uploading the key by hand)
gh auth login
# choose: GitHub.com → SSH → Yes (upload key) → Login via browser

Test it:

ssh -T git@github.com   # should print "Hi <username>!"
gh repo create test-repo --private --confirm
gh repo delete test-repo --confirm

If those work, you are done with auth forever.

Dotfiles: do this on day one

A dotfiles repo is the habit that pays the most over time. Every config file you care about — ~/.zshrc, ~/.tmux.conf, ~/.gitconfig, your editor settings — lives in a single repo. New machine? You clone the repo, run one script, you’re back in your environment in ten minutes.

Minimal starter:

mkdir ~/dotfiles && cd ~/dotfiles
git init
mkdir home

# Move (don't copy) the configs in
mv ~/.zshrc home/.zshrc
mv ~/.tmux.conf home/.tmux.conf
mv ~/.gitconfig home/.gitconfig

# Symlink them back
ln -s ~/dotfiles/home/.zshrc ~/.zshrc
ln -s ~/dotfiles/home/.tmux.conf ~/.tmux.conf
ln -s ~/dotfiles/home/.gitconfig ~/.gitconfig

# A tiny install.sh for next time
cat > install.sh <<'EOF'
#!/usr/bin/env bash
set -e
HERE="$(cd "$(dirname "$0")" && pwd)"
for f in .zshrc .tmux.conf .gitconfig; do
  ln -sf "$HERE/home/$f" "$HOME/$f"
done
EOF
chmod +x install.sh

git add . && git commit -m "initial dotfiles"
gh repo create dotfiles --private --source=. --push

That repo will grow with you. In two years it will have 30 files in it and will be one of the most valuable artifacts you own.

What to NOT spend time on

A short list of things that look like setup and are actually procrastination.

• Terminal color schemes. Pick one of the iTerm presets and never look at it again.
• Custom prompt with weather, CPU temp, Git branch ahead/behind, kubernetes context. No. Branch name is enough.
• Nerd Fonts and 17 ligatures. Use a default monospace font.
• Vim/Emacs holy wars. You are not in the war yet. Use VS Code.
• Window manager rabbit holes. Yabai, Aerospace, i3 — fascinating, also a one-week tax for almost no productivity gain.

The test: if you’ve spent more than 90 minutes on any of the above this week, you are tinkering, not learning.

Going deeper

When you have specific questions, in this order:

1. The Missing Semester of Your CS Education (MIT). link · the canonical course on tooling. Do lectures 1, 2, 3, 5.
2. Atlassian — Dotfiles. post · the bare-repo trick for tracking dotfiles without symlinks.
3. chezmoi. docs · once your dotfiles repo grows past 20 files, this manages it more cleanly than handwritten symlinks.
4. Wezterm docs. link · if iTerm2 ever annoys you, this is the upgrade.

Checkpoints

If any one wobbles, the corresponding section above is what to reread.

1. Why is WSL2 the right answer for Windows users, and why isn’t “develop on Windows directly” a real option?
2. Why fnm and uv instead of nvm and pyenv? Name one concrete advantage for each.
3. What does a dotfiles repo give you that copying configs to a new machine by hand doesn’t?
4. Name three “setup activities” that are actually procrastination, and explain how to spot the trap.
5. Run gh repo create test-and-delete --private --confirm && gh repo delete test-and-delete --confirm from a fresh terminal. If that works without prompting for credentials, your auth is done.

If you can answer all five and the gh test passes, you’ve earned 00.2. Next: 00.3 — Using AI as your tutor. Now that your environment is real, the AI module shows you how to use it inside that environment.