Vibecoding from Your Phone – Your Own AI Dev Server on a Raspberry Pi. You get an idea. You're on the bus. You pick up your phone, open an app, and start building a website – AI writes the code, on your own server at home. You test it live in your browser. Done. This guide shows you how to set that up. No prior server experience needed. When something is unclear, just paste the command or error into Claude, ChatGPT, or any AI – they'll help you through it.

What you need Raspberry Pi 5 (8GB) ~$75 microSD card (32GB+) ~$10 Storage device (USB stick or external drive) ~$10 Claude Pro account $20/month Tailscale — free Termius (phone app) — free Windows, Mac or Linux? All terminal commands in this guide work on Mac and Linux out of the box. Windows users should use WSL2 (Windows Subsystem for Linux) – ask an AI how to set it up, it takes about 5 minutes.

What you end up with ✅ A server at home that's always on and always ready ✅ Control it with AI from your phone, anywhere in the world ✅ Test your sites on a real mobile browser as you build ✅ No monthly cloud bills just to test an idea ✅ Your code stays on your own hardware

Part 1 – Flash the operating system Think of this as installing Windows or macOS – but on a tiny card that goes into the Pi. Download Raspberry Pi Imager at raspberrypi.com/software (available for Windows, Mac and Linux) Insert your microSD card into your computer Open Imager and select: Device: Raspberry Pi 5 OS: Raspberry Pi OS Lite (64-bit) — the "Lite" version has no desktop, which saves resources on a server Click the pencil/settings icon before writing – this is important: Hostname: pick a name, e.g. myserver Enable SSH: ✅ Username: pick a username, e.g. dev Password: choose something strong WiFi: fill in if not using an ethernet cable Timezone: set to your local timezone Click Write and wait for it to finish Insert the card into your Pi, plug in ethernet and power Wait 2–3 minutes for the first boot

Part 2 – Connect to your Pi Your Pi has no screen. You'll connect to it from your computer via SSH – a way of controlling one computer from another through text commands. Find your Pi's IP address – check your router's admin page (usually at 192.168.1.1 or 192.168.0.1) under "Connected devices". Look for your Pi's hostname. Or from your terminal: nmap -sn 192.168.1.0/24

Connect via SSH: ssh yourusername@192.168.1.x

Replace yourusername with the username you chose and x with your Pi's IP. Enter your password when asked. You're now inside your Pi. Everything from here is typed into this window.

Part 3 – Update and install essentials sudo apt update && sudo apt full-upgrade -y sudo apt install git curl build-essential fail2ban -y

sudo means "run as administrator". The Pi will ask for your password the first time.

Part 4 – Set up your storage device Your project files should live on a separate storage device, not the microSD card (which is just for the OS).

See what storage devices are connected

lsblk -f

You'll see something like sda – that's your USB stick or drive. Double-check it's the right one before continuing – this will erase everything on it.

Format and set up the storage device (replace 'sda' if yours is different)

sudo wipefs -af /dev/sda sudo parted /dev/sda -- mklabel gpt sudo parted /dev/sda -- mkpart primary ext4 1MiB 100% sudo mkfs.ext4 -L projects /dev/sda1

Mount it permanently (auto-mounts on every reboot)

sudo mkdir -p /mnt/projects sudo chown $USER:$USER /mnt/projects echo "UUID=$(sudo blkid -s UUID -o value /dev/sda1) /mnt/projects ext4 defaults,nofail,noatime 0 2" | sudo tee -a /etc/fstab sudo mount -a

Create a shortcut to it from your home folder

ln -s /mnt/projects ~/projects

Verify it works: ls ~/projects df -h /mnt/projects

Part 5 – Tailscale (access from anywhere) Tailscale creates a secure, private connection between your Pi and your phone – no router settings, no port forwarding, no technical networking knowledge needed. On the Pi: curl -fsSL https://tailscale.com/install.sh | sh sudo tailscale up

A link appears – open it in your browser and log in with Google or GitHub. On your phone: Install the Tailscale app and log in with the same account. Your Pi appears automatically in the list. Note your Pi's Tailscale IP: tailscale ip -4

Looks like 100.x.x.x – save this number

Part 6 – Security SSH keys – log in without a password On your computer:

Create a key if you don't have one

ssh-keygen -t ed25519 -C "my-computer"

Copy it to your Pi

ssh-copy-id yourusername@192.168.1.x

Windows users, run this in PowerShell instead: type $env:USERPROFILE.ssh\id_ed25519.pub | ssh yourusername@192.168.1.x "mkdir -p ~/.ssh && cat >> ~/.ssh/authorized_keys"

Then disable password login on the Pi: sudo nano /etc/ssh/sshd_config

Find and change these lines: PasswordAuthentication no PermitRootLogin no

Save with Ctrl+O → Enter → Ctrl+X, then: sudo systemctl restart ssh

⚠️ Test that you can still log in from a new terminal window before closing your current session. Firewall sudo ufw allow from 192.168.0.0/16 to any port 22 proto tcp sudo ufw allow from 100.64.0.0/10 to any port 22 proto tcp sudo ufw enable

Fail2ban Already installed – it automatically blocks repeated failed login attempts. Verify it's running: sudo systemctl status fail2ban

Part 7 – GitHub setup GitHub stores your code and keeps everything in sync between your computer, your Pi and your phone. Create a GitHub account Go to github.com and sign up for a free account. Generate an SSH key on your Pi This lets your Pi push and pull code to GitHub without a password: ssh-keygen -t ed25519 -C "my-pi"

Press Enter on all questions (no passphrase needed on a server). Show the public key: cat ~/.ssh/id_ed25519.pub

Copy the entire output. Add the key to GitHub Go to github.com → click your profile picture → Settings Click SSH and GPG keys → New SSH key Give it a name like "My Pi" and paste the key Click Add SSH key Test the connection ssh -T git@github.com

You should see: Hi yourusername! You've successfully authenticated...

Configure Git git config --global user.name "Your Name" git config --global user.email "your@email.com"

Create your first repo On github.com, click New repository, give it a name, and copy the SSH clone URL. Clone it to your Pi: cd ~/projects git clone git@github.com:yourusername/your-repo.git cd your-repo

Part 8 – Install Claude Code Use the native installer: curl -fsSL https://claude.ai/install.sh | sh

If that doesn't work on your Pi, fall back to npm: curl -fsSL https://deb.nodesource.com/setup_22.x | sudo -E bash - sudo apt install nodejs -y mkdir -p /.npm-global npm config set prefix ~/.npm-global echo 'export PATH=/.npm-global/bin:$PATH' >> ~/.bashrc source ~/.bashrc npm install -g @anthropic-ai/claude-code

Log in – a link appears, open it in your browser: claude

Part 9 – Install Docker Docker lets you run apps in isolated containers – perfect for backends, databases and full-stack projects. curl -fsSL https://get.docker.com | sudo sh sudo usermod -aG docker $USER sudo apt install docker-compose-plugin -y

Log out and back in, then verify: docker --version docker compose version

Part 10 – The workflow At home – working from your computer Connect to your Pi from your computer's terminal: ssh yourusername@myserver.local

Navigate to your project and start Claude Code: cd ~/projects/my-project claude

When done, ask Claude to push your changes: "Commit everything and push to GitHub" Test your site in your phone's browser while still at home: http://myserver.local:3000

Out and about – idea strikes Open Termius on your phone → connect via Tailscale IP (100.x.x.x) Create or navigate to your project: mkdir ~/projects/my-idea && cd ~/projects/my-idea

or: cd ~/projects/existing-project && git pull

Start Claude Code with Remote Control: claude --remote-control

A link appears – open it in your phone's browser Close Termius Open the Claude app → your session appears → start describing what you want to build Ask Claude to start a server: "Start a dev server so I can test this in my browser" Open your mobile browser: http://100.x.x.x:3000

See your site live on your actual phone When done: "Commit everything and push to GitHub"

Why this works so well When you start a Remote Control session, Claude Code keeps running locally on your Raspberry Pi the entire time. Nothing moves to the cloud – your filesystem, tools and project configuration all stay available. The web and mobile interface is just a window into that local session. The Pi runs 24/7 on about 5–10W of power – less than a phone charger. It's always there, always ready, and costs almost nothing to run. And because you're testing on your actual phone against a real server, what you see is what your users will see.

Total setup time: ~2 hours. Total cost: one Pi + Claude Pro. Total vibe: immaculate.