No Laptop, No Problem: Tablet + Remote Servers as a Dev Rig

My laptop died. The obvious move was to replace it. Instead, I asked a different question: do I actually need a laptop?

What happened

My laptop died. I had two options: buy another one, or test a theory I'd been sitting on for a while.

The theory: a developer doesn't need local compute anymore. Not with remote servers. Not with AI agents that write, test, and review code autonomously.

I picked up a tablet with a keyboard. That's it. No laptop replacement. No backup machine. Just a screen, a keyboard, and a connection.

The setup

The entire rig:

• Device: tablet + keyboard
• Terminal: SSH client — clean interface, multiple server connections
• Servers: remote servers running my full dev environment
• AI agents: coding agents running server-side — they write code, run tests, and iterate while I do other things
• Network: zero-trust overlay network — same encrypted network anywhere, any connection

That's the stack. No local IDE. No local build tools. Web and mobile development—all running on remote servers.

Why it works

The device is a thin client

Everything I type goes to a remote server. The tablet renders output. That's the division of labor—input and display locally, compute remotely.

This changes the economics of hardware. The device doesn't need to be powerful. It needs to be light, have a great screen, and stay connected.

AI changed the equation

This setup wouldn't have made sense two years ago. What changed: AI coding agents.

My remote servers run AI agents that work around the clock. I define the task, the agent implements it, runs tests, iterates. I review, approve, move on. The agent doesn't need my local machine—it needs server compute and network access.

The bottleneck shifted. It's no longer "how fast can my machine compile?" It's "how clearly can I define what needs to happen?" The device I use to type that definition is irrelevant.

Replaceable by design

A tablet costs a fraction of a high-end laptop. If it breaks, I replace it and continue working the same day. My environment isn't on the device—it's on the servers. New device, open SSH client, reconnect. Done.

This is minimalism applied to compute: own the interface, rent the power.

What a day looks like

1. Open SSH client. Connect to servers.
2. Check what AI agents shipped—review, merge or comment.
3. Define next tasks. Agents start working.
4. SSH sessions for hands-on work when needed.
5. Monitor agent progress. Course-correct when they drift.
6. Everything runs server-side—builds, tests, deploys.

The device stays cool, quiet, and lasts all day on battery. The servers do the sweating.

The tradeoffs (real ones)

No connectivity, no work. This is the biggest tradeoff. If I lose internet, I lose my dev environment. In practice, connectivity is everywhere now—even airlines offer fast Wi-Fi via Starlink. Dead zones exist but they're shrinking fast.

Social perception. People see an iPad and assume you're watching YouTube. Minor, but real in co-working spaces and meetings.

Who this is for

This setup works if:

• Your workflow is terminal-centric (SSH, CLI tools, vim/neovim)
• You have reliable remote servers
• You use AI coding agents that run server-side
• You value portability over local power
• You're comfortable with connectivity as a dependency

This setup doesn't work if:

• You need heavy local-only apps (Figma desktop, video editing suites)
• You work offline frequently
• You don't enjoy working in a terminal—SSH and CLI tools are the interface
• Your workflow depends on platform-specific desktop tooling

Three days in, a new record

On day three of the switch, I beat my all-time commit record—from a tablet. With remote servers and AI agents doing the heavy compute, the output didn't drop. It spiked.

Two weeks later, I'm not going back. The constraint forced clarity: I needed less than I thought. The tablet handles my actual workflow—define tasks, review output, SSH when hands-on work is needed. The servers handle everything compute-intensive. The AI agents handle the volume.

The laptop dying wasn't a loss. It was an upgrade disguised as a problem.

Try this incrementally

Don't throw away your laptop. Test the theory:

1. Set up a remote server with your full dev environment.
2. Install an SSH client on your tablet.
3. Work from the tablet for one full day. Note what breaks.
4. Fix what broke. Repeat for a week.
5. If after a week you haven't reached for the laptop—you have your answer.

For more on the philosophy behind this, see Minimalism That Moves: Living Out of a Pelican 1535.

If this resonates, the rest of my notes live under the Freedom category.