My Raspberry Pi 5 Dev Station Setup

I’ve been meaning to do this for a while. The Pi 5 is genuinely fast enough to use as a real development machine — not a toy, not a learning board, but something you can actually point Claude Code at and get work done. So I set one up as a headless SSH dev station, and this is what I installed and why.

The baseline: shell tools first

Before anything else, I want the terminal to feel like home. There’s nothing worse than SSH-ing into a machine and finding yourself in bare bash with no fuzzy search, no decent file listing, nothing.

sudo apt install -y zsh tmux fzf ripgrep bat eza fd-find jq curl wget htop ncdu git
chsh -s $(which zsh)

The essentials here are tmux (non-negotiable for persistent SSH sessions — if your connection drops, your work doesn’t), fzf and ripgrep (fuzzy file and history search, pairs surprisingly well with AI-assisted coding), and ncdu for when you inevitably fill up the SD card and need to find out why.

I also added Starship for a cleaner prompt:

curl -sS https://starship.rs/install.sh | sh

Node and the JS toolchain

Don’t use apt’s Node. It’s always behind. Use nvm instead, which lets you manage versions properly:

curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.7/install.sh | bash
nvm install --lts
npm install -g pnpm turbo

This gives you the current LTS Node, plus pnpm and Turbo globally for monorepo work.

Docker: do it properly

There’s a tempting shortcut here — sudo apt install docker.io — that you should ignore. It’s old and doesn’t give you Compose v2. Instead, set up the official Docker apt repository from scratch.

First, clear out anything that might be lurking:

sudo apt remove $(dpkg --get-selections docker.io docker-compose docker-doc podman-docker containerd runc | cut -f1)

Then add the repo and GPG key:

sudo apt update
sudo apt install ca-certificates curl
sudo install -m 0755 -d /etc/apt/keyrings
sudo curl -fsSL https://download.docker.com/linux/debian/gpg -o /etc/apt/keyrings/docker.asc
sudo chmod a+r /etc/apt/keyrings/docker.asc

sudo tee /etc/apt/sources.list.d/docker.sources <<EOF
Types: deb
URIs: https://download.docker.com/linux/debian
Suites: $(. /etc/os-release && echo "$VERSION_CODENAME")
Components: stable
Architectures: $(dpkg --print-architecture)
Signed-By: /etc/apt/keyrings/docker.asc
EOF

sudo apt update

Now actually install it (easy to miss this step if you’re following docs in pieces):

sudo apt install -y docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin

Then add your user to the docker group so you’re not prefixing every command with sudo:

sudo usermod -aG docker $USER
newgrp docker
docker run hello-world

If you see the hello-world output, you’re done.

.NET: watch the version flag

The .NET install script is the right way to go on ARM64 — don’t try to install Mono or whatever apt tries to offer you.

wget https://dot.net/v1/dotnet-install.sh -O dotnet-install.sh
chmod +x ./dotnet-install.sh

One gotcha: --version latest sounds reasonable but can install a preview or RC build. Use a channel instead:

./dotnet-install.sh --channel 9.0   # latest stable
# or
./dotnet-install.sh --channel 8.0   # LTS, supported until November 2026

The install script also won’t update your PATH for you. Add this to your ~/.zshrc (or ~/.bashrc):

export DOTNET_ROOT="$HOME/.dotnet"
export PATH="$PATH:$HOME/.dotnet:$HOME/.dotnet/tools"

Then source ~/.zshrc and verify with dotnet --version.

Security: a quick once-over before you forget

Since this machine is SSH-facing, take five minutes here before you move on to the fun stuff.

sudo apt install -y ufw fail2ban
sudo ufw allow ssh
sudo ufw enable

And in /etc/ssh/sshd_config, disable password authentication if you’re using key-based auth:

PasswordAuthentication no

Then sudo systemctl restart ssh. Simple, but easy to skip when you’re in the flow of setting things up.

Verify everything landed

docker version
dotnet --version
node --version

If those all return version numbers rather than errors, the foundation is solid. Everything else — editors, language servers, project-specific tooling — builds on top of this.

The Pi 5 handles all of it without complaint. It’s become my preferred remote target for work that doesn’t need a full machine, and the combination with Claude Code running on the device itself has changed how I think about what a dev environment needs to be.