I moved my side projects to a $5/mo Linux box (and my laptop battery finally stopped screaming)

I used to have a dozen side projects scattered across my laptop. Each one dragged in its own node_modules, Python venvs, Go caches, and Docker containers. My fans spun up just opening a terminal. And every time I came back to a project after a few weeks, I had to replay the ritual: update packages, fix broken paths, figure out why the database wouldn't start. I called it environment rot, and it was quietly smothering my motivation.

A simple fix changed everything. I moved most of my side projects to a cheap remote Linux shell. It costs less than a coffee a month, and it turned my laptop into a thin client that I can close without losing my place. No more it works on my machine because the machine is the same machine every time I connect.

The problem with local-only development

Local dev environments are fragile. You install a tool with a version manager, then forget which version you pinned. A Python package gets upgraded system-wide and breaks an old Flask app. Your laptop goes to sleep, and the long-running test suite you started at 11 p.m. is gone. If you use an AI coding agent like borg, the situation is worse: the agent runs in a terminal session, and a sleeping laptop means a dead agent. You come back to a half-finished refactor and no context.

This isn't laziness. It's a mismatch between the way we work on side projects (sporadically, on different machines, with long gaps) and the assumption that a dev environment lives on a single physical disk.

How a remote shell changes the game

Here's what I do now. I spin up a shell on a remote Linux host. I connect over SSH, fire up a tmux session, and do everything there. If I close my laptop, the session lives on. When I open it tomorrow, I reattach and pick up exactly where I left off. The project's dependencies, background processes, and even that running borg agent are all still humming.

A concrete example:

ssh [email protected]
tmux new -s myproject
cd ~/projects/side-thing
python -m venv .venv && source .venv/bin/activate
pip install -r requirements.txt
uvicorn main:app --reload &

Now I detach (Ctrl-b d) and my API server is running on the remote host. I can reach it from my browser, test it from a phone, or let borg poke at the endpoints while I sleep. The next day I just reconnect and reattach:

ssh [email protected]
tmux attach -t myproject

No reinstall, no environment drift, no battery drain from a local Docker daemon.

What about my laptop's resources?

When I moved heavy compilation and long-running watchers to the remote shell, my laptop stopped torturing its battery. My local machine became a terminal emulator with a decent web browser. I can now work on a plane with a Chromebook and still interact with my full environment. The remote shell is always on, so I can schedule tasks via cron, run a persistent IRC bouncer, or let borg iterate on a codebase overnight. The only thing I send locally is keystrokes and rendered text.

Consistency for AI coding agents

AI agents like borg need a stable workspace. They might read your entire codebase, run tests, and propose changes. If they lose their session because you closed the lid, you lose progress and context. A remote shell gives the agent a permanent home. I keep a tmux window with borg running in the background. It watches my repo, suggests fixes, and occasionally rewrites a module while I'm offline. When I come back, I see a clean diff and a commit message.

This is not a gimmick. It's the difference between an agent that feels like a helpful pair programmer and one that keeps forgetting what you were talking about.

The setup that works for me

I use a dedicated shell host (xShellz provides shells with common dev tools, tmux, and optional borg access, but you can replicate this with any VPS). The key is that the environment is my permanent home. I clone my repos once, set up the environment, and then I never touch it again except to work. I use mosh when I'm on a flaky connection, which keeps the terminal responsive even over mobile data.

Some of my side projects have been running for months without a single npm install on my local machine. I know that when I open a project, it will work. That predictability has a huge effect on my willingness to pick up old code.

Trade-offs you should know

Remote shells are not magic. You'll notice a little latency on every keystroke, especially if the host is far away. mosh helps, but it's still not a local terminal. If you're doing heavy graphical work or need a local GPU, this won't replace your workstation. And there's a small monthly cost, though I find it easier to swallow than the time I used to spend fighting environment rot.

For my side projects, the trade-off is worth it. My laptop battery lasts longer, my projects are always ready to work on, and borg has a permanent home where it can actually do its job.

The terminal-first mindset

Treating my remote shell as the primary home for my side projects changed how I think about development. I stopped worrying about whether my laptop had the right version of Ruby. I stopped leaving docker-compose up running and hoping the machine wouldn't sleep. I started thinking of my environment as a place, not a configuration.

If you're tired of fighting environment rot every time you return to a side project, give a remote shell a try. It's a small change that makes a big difference, and your laptop's battery will thank you.