Build iOS Apps From Your iPhone: Remote Development with Claude Code
January 10, 2026Development

Build iOS Apps From Your iPhone: Remote Development with Claude Code

What if you could build iOS apps from a coffee shop, a train, or your couch—using only your iPhone? No laptop required. Just your phone, a remote Mac, and Claude Code doing the heavy lifting.

This isn't a hypothetical workflow. It's a practical setup that takes about 15 minutes to configure, and once it's running, you can code from anywhere in the world.

The Architecture

The core loop is simple:

iPhone (SSH) → Claude Code on Mac → Build triggers → App installs on your device

You SSH into your Mac from a terminal app on your iPhone, run Claude Code remotely, and have it build and deploy apps directly to the phone you're holding. One device does everything.

What You'll Need

  • A Mac with Xcode installed (your build machine)
  • An iPhone with a terminal app
  • A Tailscale account (free tier works)
  • About 15 minutes

Step 1: Enable SSH on Your Mac

Open System Settings → General → Sharing and toggle on Remote Login.

Note which users can access—your account should be listed. This enables SSH connections to your Mac.

Step 2: Install Tailscale on Your Mac

Download Tailscale from tailscale.com or the Mac App Store. Sign in or create an account.

Tailscale assigns your Mac:

  • An IP address like 100.x.x.x
  • A hostname like your-mac.tail1234.ts.net

This creates a secure virtual private network that works across any physical network—home, office, cellular, anywhere.

Step 3: Install Tailscale on Your iPhone

Get Tailscale from the App Store and sign in with the same account.

Now both devices are on the same virtual network, regardless of where they physically are. Your iPhone can reach your Mac whether you're on the same WiFi or on the other side of the planet.

Step 4: Get a Terminal App

Two solid options:

Blink Shell (paid) — Best experience, supports Mosh for unstable connections, native feel.

Termius (free tier available) — Clean UI, easy host configuration, works well for most use cases.

Step 5: Configure Your Connection

In Termius:

  1. Tap + → New Host
  2. Alias: Whatever you want (e.g., "Mac")
  3. Hostname: your-mac.tail1234.ts.net (or the 100.x.x.x IP)
  4. Username: Your Mac username (run whoami in Terminal on your Mac to find it)
  5. Password: Your Mac login password
  6. Port: 22 (default)

In Blink:

  1. Go to Settings → Hosts
  2. Add your hostname and username
  3. Save, then type ssh Mac from the terminal

Important: Your username is your actual Unix username (like peter), not your Mac's display name (like "Peter's MacBook Air"). Run whoami on your Mac to confirm.

Step 6: Fix macOS Privacy Permissions

When you first try to access folders like Documents or Desktop via SSH, you'll likely see "Operation not permitted." This is macOS protecting sensitive directories.

Fix it:

  1. Open System Settings → Privacy & Security → Full Disk Access
  2. Click the + button
  3. Press Cmd + Shift + G and type /usr/libexec/sshd
  4. Add it and toggle it on
  5. Reconnect via SSH

Alternatively, work in unprotected directories like ~/Developer or ~/Projects—these don't have the same restrictions and are better locations for code projects anyway.

Step 7: Run Claude Code

Once connected via SSH:

claude

That's it. You're now running Claude Code on your Mac, from your iPhone, from anywhere.

Adding Voice Input

Typing on a phone keyboard gets tedious. Fortunately, you have options:

iOS Built-in Dictation

Tap the microphone icon on your keyboard and speak. It transcribes directly into the terminal. Say "new line" for line breaks. Simple and requires no setup.

Whisper-Based Apps (More Accurate)

For better accuracy, especially with technical terms:

Aiko — Free app that runs OpenAI's Whisper model locally. Speak, transcribe, copy, paste into terminal.

Whisper Transcription — Similar approach, excellent for code-related vocabulary.

Custom iOS Shortcut + Whisper API — Create a shortcut that records audio, sends it to OpenAI's Whisper API, and copies the result. Costs about $0.006/minute but very accurate.

The workflow becomes: tap shortcut → speak → paste into terminal. Adds one step but the accuracy improvement is significant.

The Build-Deploy Loop

Once you're SSH'd in and Claude Code is running, you can have Claude build and deploy apps to your phone. The trick is OTA (Over-The-Air) installation—your Mac builds an .ipa, serves it over HTTPS, and you tap a link in Safari to install.

Wireless debugging via devicectl doesn't work reliably over Tailscale because Apple's device discovery requires being on the same physical network. OTA is the solution.

Prerequisites

  1. Enable Developer Mode on your iPhone (Settings → Privacy & Security → Developer Mode)
  2. Make sure your device is registered in your Apple Developer account

Step 1: Create the Build Script

Create a script on your Mac (e.g., ~/scripts/ota-build.sh):

#!/bin/bash

# Configuration - edit these
APP_NAME="YourApp"
SCHEME="YourApp"
PROJECT_DIR="$1"
BUNDLE_ID="com.yourcompany.yourapp"
OUTPUT_DIR="$HOME/OTAServer"

# Your Mac's Tailscale hostname
TAILSCALE_HOST="your-mac.tail1234.ts.net"
PORT="8443"

# Create output directory
mkdir -p "$OUTPUT_DIR"
cd "$PROJECT_DIR"

# Build archive
xcodebuild -scheme "$SCHEME" \
  -archivePath "$OUTPUT_DIR/$APP_NAME.xcarchive" \
  -configuration Release \
  archive

# Export IPA
xcodebuild -exportArchive \
  -archivePath "$OUTPUT_DIR/$APP_NAME.xcarchive" \
  -exportPath "$OUTPUT_DIR" \
  -exportOptionsPlist "$OUTPUT_DIR/ExportOptions.plist"

# Generate manifest.plist with correct URLs
cat > "$OUTPUT_DIR/manifest.plist" << EOF
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
    <key>items</key>
    <array>
        <dict>
            <key>assets</key>
            <array>
                <dict>
                    <key>kind</key>
                    <string>software-package</string>
                    <key>url</key>
                    <string>https://$TAILSCALE_HOST:$PORT/$APP_NAME.ipa</string>
                </dict>
            </array>
            <key>metadata</key>
            <dict>
                <key>bundle-identifier</key>
                <string>$BUNDLE_ID</string>
                <key>bundle-version</key>
                <string>1.0</string>
                <key>kind</key>
                <string>software</string>
                <key>title</key>
                <string>$APP_NAME</string>
            </dict>
        </dict>
    </array>
</dict>
</plist>
EOF

echo "Build complete!"
echo "Install URL: itms-services://?action=download-manifest&url=https://$TAILSCALE_HOST:$PORT/manifest.plist"

Make it executable: chmod +x ~/scripts/ota-build.sh

Step 2: Create ExportOptions.plist

This tells Xcode how to sign your app:

mkdir -p ~/OTAServer
cat > ~/OTAServer/ExportOptions.plist << 'EOF'
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
    <key>method</key>
    <string>development</string>
    <key>teamID</key>
    <string>YOUR_TEAM_ID</string>
</dict>
</plist>
EOF

Replace YOUR_TEAM_ID with your Apple Developer Team ID (find it at developer.apple.com → Membership).

Step 3: Set Up HTTPS Server

iOS requires HTTPS for OTA installs. With Tailscale, this is straightforward:

# Install Caddy (simple HTTPS server)
brew install caddy

# Get Tailscale HTTPS certificate
tailscale cert $(tailscale status --json | jq -r '.Self.DNSName' | sed 's/\.$//')

Start the server:

cd ~/OTAServer
caddy file-server --listen :8443 --root . --browse

Keep this running in a separate terminal session (or use tmux/screen).

Step 4: One-Time iPhone Setup

Your iPhone needs to trust the certificate. Do this once:

  1. Open Safari on your iPhone
  2. Go to https://your-mac.tail1234.ts.net:8443/ (your Tailscale hostname)
  3. If prompted about the certificate, you may need to install it:
    • Download the certificate
    • Go to Settings → General → VPN & Device Management
    • Install the profile
    • Go to Settings → General → About → Certificate Trust Settings
    • Enable full trust for the certificate

Step 5: Install the App

After building, open Safari on your iPhone and navigate to:

itms-services://?action=download-manifest&url=https://your-mac.tail1234.ts.net:8443/manifest.plist

Safari will prompt you to install the app. Tap Install, and it appears on your home screen.

Automating with Claude Code

Once set up, tell Claude to run the build script:

Build and deploy the app using ~/scripts/ota-build.sh

Claude runs the script, and you get an install URL. Open it in Safari, tap Install, done.

The Complete Workflow

Once everything is configured:

  1. Open Termius on your iPhone
  2. Connect to your Mac via Tailscale
  3. Run claude
  4. Describe what you want to build (speak it using dictation)
  5. Claude writes the code, builds the project
  6. New build appears on your phone
  7. Switch apps, test, switch back, continue

You're now doing iOS development from your phone. The Mac is just a remote build server.

Tips for Smooth Operation

Use Mosh instead of SSH — If you're on unstable connections (cellular, spotty WiFi), Mosh handles disconnections gracefully. Blink supports it natively.

Keep the Mac awake — Disable sleep in Energy Saver settings, or use a tool like Amphetamine to keep it running.

Set up SSH keys — Skip password entry every time by setting up key-based authentication.

Use a dedicated project folder — Keep your code in ~/Developer or similar to avoid permission issues.

When This Makes Sense

This workflow shines when you:

  • Have downtime away from your desk (commute, travel, waiting rooms)
  • Want to iterate on ideas quickly without pulling out a laptop
  • Need to push a quick fix from anywhere
  • Prefer dictating code changes over typing

It's not going to replace sitting at your desk for deep work. But for the times when you're away from your workstation and want to make progress—it's remarkably capable.

Conclusion

The barrier between "I need my laptop" and "I can work from anywhere" is lower than most developers realize. A terminal app, Tailscale, and Claude Code turn your phone into a capable development interface.

The setup takes 15 minutes. The capability lasts forever.

Try it on your next commute. You might be surprised how much you can build from a 6-inch screen.

Ready to fix your marketing measurement?

Take assessment →