I Shipped an iPhone Build From 1,000 Miles Away

I was at an event, away from home, bored, and staring at a feature that was almost done.

The agents could keep building it on my laptop. But I could not test the result on my phone.

That gap between “the build passed” and “I tried it on the device” was the whole problem.

Normally, this is easy. My Mac builds the app, signs it with my local certificate, and I install it on my iPhone while connected to my home network.

But I was not home. I was not on the same Wi-Fi. I was not even close.

I wanted the workflow to work whether I was in the next room, 100 miles away, or 1,000 miles away.

The Real Constraint

The agents were perfectly capable of writing code and producing a build. The bottleneck was delivery.

How could an app built on my Mac reach my phone privately, without opening my home network to the public internet or manually moving files around?

• The Mac needed to build and sign the app.
• The phone needed a trusted path to retrieve the install metadata and app package.
• The connection needed to remain private and encrypted.

My first instinct was simple: Tailscale is already my private network.

If a local install workflow can reach a machine over my home network, the distance should not matter when both devices are connected through an encrypted mesh network.

The problem was not whether the idea made sense. The problem was getting an agent to follow the idea all the way through.

The First Answer: “Not Possible”

I gave the task to Fable 5. It thought for a while, then gave me a hard stop: this was not possible and not allowed.

That answer did not sit right with me.

“Not possible” is often a conclusion about the first approach, not a proof that no approach exists.

The signing process was legitimate. The devices were mine. The connectivity was private. There had to be a path.

A Second Agent, A Different Outcome

I handed the same challenge to GPT 5.6 Sol.

It did not immediately claim victory. It worked through the constraints for 15 to 20 minutes, tracing the pieces of an iOS installation flow and figuring out how they could fit together.

Then it found the missing bridge: a small private app catalog hosted on my Mac, reachable from my phone through Tailscale.

The Architecture That Made It Work

The solution was not a public app store and not an exposed home server. It was a focused delivery pipeline running inside my existing private network.

• The agent builds the feature on my Mac.
• It signs the resulting IPA using my existing local signing setup.
• It adds the signed build and its install manifest to a private catalog.
• Tailscale provides encrypted connectivity between my iPhone and Mac.
• The agent returns an install link for the new build.

The important detail is that the phone is not blindly accepting an arbitrary app from the internet.

The installation flow uses Apple’s ITMS install mechanism: the phone retrieves a manifest, downloads the IPA, and verifies the Apple signing before installation.

My Mac is doing the same signing work I already do locally. The agent simply automates the sequence and makes the finished build available through the private path.

The Moment It Clicked

The agent finished the build and replied with a link.

I tapped it on my phone.

The manifest loaded. The app downloaded. The app installed.

Build on my Mac. Tap on my phone. Test from anywhere.

That was it. No trip home. No waiting until I was back on the right Wi-Fi. No pretending a feature was done because the simulator looked good.

Why This Changes the Workflow

Remote coding gets much more valuable when it includes the last mile: real-device feedback.

A feature can compile and still feel wrong. Gestures can be awkward. Layout can break. Permissions can behave differently. Performance can surprise you. The phone is where the product becomes real.

With a private delivery path, an agent can keep iterating while I am away, and I can validate the work as soon as the build is ready.

What Made This Safe Enough to Be Useful

This was not about bypassing platform security. It was about connecting legitimate pieces of an existing development workflow.

• Private connectivity: Tailscale keeps the route between my devices encrypted.
• Existing signing: the build is signed through my normal local process.
• Controlled distribution: the catalog lives on my Mac, not on a public server.
• Device verification: iOS still performs its signing and installation checks.

The goal was convenience without turning a development machine into an open download portal.

The Bigger Lesson About Agents

The most interesting part was not the install link. It was the contrast between two responses to the same problem.

One agent treated the constraints as the end of the conversation. The other treated them as a system to reason through.

Capability is not only about knowing the answer immediately. Sometimes it is about having the persistence to keep decomposing the problem until the path appears.

If You Want to Build a Similar Flow

Start with the workflow you already trust, then remove one manual step at a time.

• Keep signing credentials and build tooling on your own development machine.
• Use a private network layer rather than exposing a catalog publicly.
• Have the build process generate the manifest and catalog entry automatically.
• Return a clear install link only after the build is complete.
• Test the full flow while you are home before relying on it remotely.

The magic is not one tool. It is connecting build, signing, delivery, and testing into one loop.

I left the house thinking I would have to wait to test my feature.

Instead, I ended up with a remote development loop that works wherever I am: the agent builds, my Mac signs, Tailscale connects, and my phone installs.

The distance between the developer and the device is no longer the limit. The workflow is.