I just shipped four major features to EllyMUD while traveling. Not from a laptop. Not even from my iPad. From my phone, over Tailscale, using Blink Terminal.

The features:

  • NPC Spawn System: Automatic monster respawning with configurable timers
  • NPC Mobility: NPCs that wander between connected rooms
  • Stealth System: Sneak and hide commands for player infiltration
  • Race, Class & Level Progression: A complete character advancement system with 5 races and 17 classes

Each of these touched multiple files, required writing tests, and went through the full CI pipeline. All from a 6.1” screen in the back of a car.

The Setup (Yes, Phone)

Everything from my iPad setup works on iPhone with Blink. Same Tailscale mesh. Same mosh connections. Same SSH into WSL on my home machine where the actual compute happens.

The difference is screen real estate. You can’t tile three terminals and a browser. But you can do one thing at a time really well.

My phone workflow:

  1. Mosh into my dev machine (session survives network hops)
  2. Claude Code (AI pair programming in the terminal)
  3. Git (commits, pushes, the usual)

That’s it. No file browser, no fancy IDE. Just a terminal and an AI that knows the codebase.

What Got Built

NPC Spawns

The MUD needed monsters that respawn after being killed. Classic dungeon crawl stuff. The spawn system:

  • Tracks which NPCs belong to which rooms
  • Respawns them on a configurable timer after death
  • Handles initial spawning when the server boots

Sounds simple. It was three files and some careful state management to make sure NPCs don’t double-spawn or resurrect mid-combat. The edge cases are always where the real work is.

NPC Movement

Static NPCs are boring. Now they wander:

  • Each mobile NPC has a movement interval
  • They pick valid exits from their current room
  • They pathfind avoiding certain room types
  • Players see “A goblin arrives from the north” messages

The fun part was making movement feel natural. Too fast and the world feels chaotic. Too slow and you never see anything move. Tuning game feel from a terminal on a phone. Totally normal development activities.

Stealth

Players can now sneak and hide:

  • Sneak: Move between rooms without appearing in look/who lists
  • Hide: Become invisible in your current room
  • Both break on combat or noisy actions

This required threading a “hidden” flag through the entire message broadcast system. Every writeToRoom call needed to check if players should see each other. The kind of cross-cutting concern that touches everything.

Character Progression

The big one. A complete race/class system:

5 Races with stat modifiers:

  • Human (balanced, +5% XP)
  • Elf (+DEX/INT, +10% mana)
  • Dwarf (+STR/CON, +10% health)
  • Halfling (+DEX/AGI/CHA, +5% crit)
  • Orc (+STR/CON, +5% attack)

17 Classes in a tiered tree:

Adventurer (tier 0)
    |-> Fighter -----> Paladin, Berserker, Knight
    |-> Magic User --> Wizard, Necromancer, Elementalist
    |-> Thief -------> Assassin, Ranger, Shadow
    +-> Healer ------> Cleric, Druid, Shaman

Tier 1 requires level 5 and a trainer NPC. Tier 2 requires level 15, a trainer, and completing a class quest. Each class grants permanent stat bonuses that stack through your progression history.

This touched:

  • User data model (new fields for race, class, quest flags)
  • State machine (race selection during signup)
  • The train command (class advancement)
  • Stats display (show race bonuses, class tier, XP progress bar)
  • 4 new trainer NPCs
  • Full test coverage

Why Phone Works

The secret is Claude Code. Seriously.

I describe what I want. It reads the codebase, understands the patterns, writes the implementation. I review, request changes, approve. It’s pair programming where I’m the senior dev giving direction and my pair has perfect memory of every file in the project.

On a laptop, I might open 10 tabs, grep through files, context-switch constantly. On a phone, I have one terminal. Everything goes through the AI. It becomes the interface to the codebase.

This isn’t “phone development is great, everyone should do it.” It’s “phone development is possible when your tooling compensates for the interface limitations.” The limiting factor isn’t the screen. It’s whether your tools can work with just a prompt and a response.

The Full Workflow

Here’s what “shipping a feature” actually means in this codebase. It’s not just writing code:

1. Implementation: The feature itself. New files, modified files, type definitions.

2. Unit Tests: Each new manager (RaceManager, ClassManager) gets a full test suite. Mock the dependencies, test every method, cover the edge cases. 81 unit tests for the race/class system alone.

3. Repository Pattern Integration: The codebase uses a repository abstraction for all data. New entities need:

  • Interface definition (IAsyncRaceRepository)
  • File-based implementation (AsyncFileRaceRepository)
  • Registration in the RepositoryFactory
  • Schema validation

This matters because the same interface works against SQLite, Postgres, or flat files. Auto-migration reads from old storage, writes to new storage, same API. Adding races? The migration scripts pick them up automatically.

4. E2E Testing via MCP: The MUD has an MCP server that exposes game actions as tool calls. Tests can:

  • Create sessions
  • Send commands
  • Read output
  • Manipulate player stats
  • Advance the game timer

E2E tests don’t need to parse Telnet output or manage socket connections. They call agent.sendCommand(sessionId, 'train class fighter') and get structured responses.

5. Adding to CI: New tests go into the test suite. Pre-commit hooks run ESLint with zero warnings. Pre-push hooks run the full test suite. GitHub Actions run on every push.

All of this happened from my phone. Not just “I wrote some code.” The full engineering workflow: implementation, testing, validation, integration.

That’s the part that surprised me. I expected to do quick fixes and small tweaks. I didn’t expect to maintain the same quality bar I’d hold myself to on a desktop.

The Traveling Part

I was literally in transit for most of this work. Car, airports, waiting rooms. The kind of dead time that usually means doom-scrolling.

Mosh handled the network chaos. Tailscale meant I didn’t care what WiFi I was on. The phone fit in my pocket.

The MUD is now meaningfully more complete because I had a way to convert idle hours into shipped features. That’s the real win here. Not “look what I can do from a phone” but “look at all the time that used to be wasted.”

The Stack

Same as the iPad setup, just smaller:

  1. Tailscale: Mesh VPN connecting phone to home machine
  2. Blink Terminal: mosh/SSH client on iOS
  3. Mosh: Connection persistence across network changes
  4. WSL: Linux dev environment on Windows
  5. Claude Code: AI pair programming

Total additional cost: $0 (Blink is a one-time purchase but I already had it).

What’s Next

The MUD still needs:

  • Actual class quests for tier 2 advancement
  • Abilities that unlock per class
  • Equipment restrictions by class
  • The content to fill all these systems

But the scaffolding is there. Four features that would have taken a weekend of focused laptop time, done in fragments during travel.

Your phone is not a toy either. It just needs the right tools behind it.