What are the best tools to ship from your phone?

Why can indie hackers suddenly ship real products from a phone?

Indie hackers can genuinely ship software from a phone now because AI agents can do the heavy development work on remote machines while we give instructions and review the result from mobile.

A few years ago, “coding from an iPhone” usually meant fighting a tiny editor, SSHing into a server, or using a browser version of VS Code. The experience was possible, but usually worse than opening a laptop.

The newer workflows remove much of that friction. Anthropic's current Claude Code platform supports cloud sessions from the Claude app on both iOS and Android. Cursor launched its native iOS app in June 2026 with always-on cloud agents. GitHub Mobile lets us send work to Copilot's cloud agent, inspect its changes and create or review the pull request from the phone. Replit's mobile app can generate, preview and publish web apps directly from iOS or Android.

Pieter Levels' Infinite Slop experiment gives us a useful example because the stack was extremely simple. Levels said he built infiniteslop.ai entirely on his phone using Termius to access a Hetzner VPS, with Claude Code doing the coding and Safari handling the preview. The important part of that workflow was how little conventional mobile coding he needed to do.

Several large developer-tool companies have reached the same idea independently. They are moving compilation, tests, package installation and code generation to machines in the cloud while reducing the phone experience to prompts, status updates, screenshots, diffs and approvals.

That makes phone shipping much more useful than it was even a year or two ago.

What actually counts as shipping an app from your phone?

Shipping from your phone means we can take a product change from idea to production without needing to open a laptop during that session.

Checking Slack, approving a pull request or restarting a server from an iPhone is useful, but we would not call that phone development. A credible workflow needs to let us request a change, generate or edit the code, verify the result, inspect it and push it live.

The computer doing those jobs can live somewhere else. In fact, the strongest mobile setups today rely heavily on remote compute.

Claude Code cloud sessions run on Anthropic-managed infrastructure. Cursor gives each cloud agent an isolated development environment. GitHub's cloud agent can research a repository, write code on its own branch and prepare a pull request. Replit hosts the development environment itself. Codespaces gives us a remote Linux development machine. Termius lets us control whatever Linux server we choose.

There is also a big difference between maintaining an existing product from a phone and creating the entire infrastructure from scratch from a phone.

Once GitHub, deployment, domains, databases and secrets are configured, working mobile-first becomes surprisingly easy. Initial setup can still expose awkward web dashboards, OAuth screens, DNS configuration and environment-variable forms. We can usually get through them on a phone, but the advantage shrinks quickly.

For this article, we therefore judge tools by how much of the normal shipping loop they let an indie hacker complete comfortably from a phone.

Do we still need a mobile code editor?

For most indie-hacker work today, we need a good mobile interface for an agent more than we need a great mobile code editor.

This is probably the biggest change in how we should think about the category.

Cursor's iPhone app makes the shift obvious. We can speak a task aloud, launch a cloud agent, leave the app, receive a notification later, inspect screenshots and diffs, then merge the pull request. The agent gets its own virtual machine and can run normal development tools there.

Claude follows the same general pattern. Anthropic's current platform documentation describes mobile as a place for starting and monitoring Claude Code tasks, including cloud sessions that keep running when we disconnect. The full CLI still exists for cases where we want direct control.

GitHub is moving in the same direction. Earlier this year, GitHub expanded its mobile cloud-agent workflow so Copilot could research a repository, make an implementation plan, change code on a branch, show us the diff and create a pull request only when we were ready. GitHub Mobile subsequently added native session logs and more controls for active agents.

The phone therefore becomes much more useful when every interaction represents a high-level action. “Fix the checkout bug and test the Stripe webhook cases” works well on a six-inch screen. Manually editing 17 files does not.

Tool	Where the coding happens	What we mainly do on the phone
Claude Code	Anthropic cloud or our own machine	Prompt, steer and review
Cursor	Isolated cloud VM or our own machine	Launch agents, review artifacts and merge
GitHub Copilot	GitHub cloud environment	Assign work, review changes and manage PRs
Replit	Replit cloud environment	Build, preview and publish
GitHub Codespaces	GitHub cloud VM	Directly use an IDE and terminal
Termius + VPS	Our own Linux server	Control the machine through SSH

Is Claude Code the best tool for shipping from your phone?

Claude Code is currently our best default choice for an indie hacker who already has a real codebase and wants to work from either iPhone or Android.

Anthropic now supports Claude Code cloud sessions directly through the Claude mobile apps. We can pick up work from the phone, steer an existing task or launch work that continues while we are offline. Claude Code can then work inside the repository, run commands, modify multiple files and push changes through a normal Git workflow.

That solves one annoying weakness of older remote-development setups: our own computer does not have to remain open somewhere at home.

Anthropic also offers Remote Control, but that mode serves a different use case. Remote Control connects the phone to a Claude Code session running locally on our own machine, so the computer must stay running. Cloud sessions are much more interesting when the goal is true laptop independence.

Claude also fits cleanly into an existing indie-hacker stack. We can keep GitHub, Vercel, Railway, Cloudflare, Supabase or whatever infrastructure already runs the business. There is little pressure to rebuild the product around Anthropic.

The current Pro plan costs $20 month-to-month, or $17 per month on annual billing, and Claude Code is included. Heavy users can hit shared usage limits because Claude and Claude Code draw from the same subscription pool, so someone running agents continuously may end up needing Max or additional usage credits.

We would choose Claude Code when the product already exists and we want the phone to become another serious way of operating that product. It gives us unusually broad capability without forcing us into a new hosting platform.

Is Cursor better than Claude Code on an iPhone?

Cursor currently gives iPhone users the nicest purpose-built mobile coding-agent experience, and we would choose it over Claude when Cursor is already our main development environment.

Cursor's native iOS app entered public beta in June 2026, so this is a genuinely recent change in the phone-shipping landscape. The app can launch always-on cloud agents, take voice instructions, show screenshots and logs, display diffs, send push notifications and merge pull requests.

Those details make a difference on mobile. If we notice a layout problem while using our own site, we can screenshot it, explain the correction verbally and give the image to an agent. Cursor can work on the repo remotely and bring back something we can actually inspect from the same phone.

Cursor's cloud agents run inside isolated virtual machines with complete development environments. Its current documentation also says agents can work across several connected repository providers, including GitHub, GitLab, Bitbucket and Azure DevOps.

The main limitation is platform support. Cursor has a native iOS app, while Android users currently access its cloud agents through the web app or installable PWA. Claude has native mobile access on both iOS and Android.

There is also still a meaningful difference between Cursor Mobile and Cursor Desktop. Cursor itself describes the phone product around managing agents rather than replacing every desktop development interface.

Cursor Pro currently costs $20 per month and includes cloud agents. Cursor's own pricing guidance says limited agent users will often remain within the base plan while daily agent users can end up closer to $60–$100 in total monthly usage.

On an iPhone, especially for an existing Cursor user, Cursor may be the best mobile coding interface available right now. For a cross-platform setup we could recommend to almost any indie hacker, Claude remains easier to pick.

Is Replit the easiest way to launch a new web app from your phone?

Replit is currently the easiest option if we have an idea, almost no existing setup and want to turn it into a live web app from our phone as quickly as possible.

Replit approaches the problem from the opposite direction to Claude. Instead of adding an agent to our existing development environment, Replit can provide the agent, workspace, database, preview and deployment in one place.

Its current iOS and Android app explicitly supports creating, modifying and publishing websites and web apps from a phone. We describe the product to Agent, watch it build, open the preview, ask for changes and deploy the result to a public URL.

That makes Replit unusually strong for the first few hours of a project. The annoying setup between “I have an idea” and “somebody else can open this URL” can become extremely small.

The Starter plan currently includes daily Agent credits, a built-in database and one live published project. Core is currently listed at $20 month-to-month or $17 per month when billed annually, with more Agent capacity, parallel agents and additional model credits.

Replit becomes less obviously superior once the project already has its own infrastructure and complicated development habits. A mature SaaS might have several repositories, custom CI, staging databases, workers, unusual services and hosting split across vendors. Claude, Cursor or GitHub can often slot into that architecture more naturally.

For a weekend experiment or a small new SaaS, however, Replit removes more setup work than any other option we looked at.

Can you build a native iPhone or Android app entirely from the Replit phone app?

Replit can now generate real native mobile apps, but its current phone app still does not provide the full native-app workflow from start to App Store submission.

This distinction is easy to miss because Replit launched a much stronger native mobile-app product earlier this year. Agent can generate native app code, connect backends, use phone features, preview through Expo and guide developers toward App Store submission.

Replit's current mobile documentation adds an important qualification: the iOS and Android Replit apps are designed for building websites and web apps. For a native iOS or Android project, Replit tells users to open the fuller web workflow.

So if an indie hacker asks, “Can I create a web SaaS from the Replit iPhone app and put it online?”, our answer is clearly yes.

If the question is, “Can I stay inside the Replit iPhone app and take a native iOS application all the way through the complete store workflow?”, the answer is currently no.

That boundary may disappear. Replit has already built most of the technical pipeline around Agent, Expo previews and guided submission. As of now, though, web apps are where Replit's phone-only story is strongest.

Is GitHub Mobile with Copilot enough to ship real changes?

GitHub Mobile has quietly become one of the strongest options for shipping existing products from a phone because the coding agent now sits directly inside the Git workflow.

The useful part is how little new infrastructure we need.

On the current GitHub Mobile app, a paid Copilot user can start a cloud-agent session, choose a repository and describe a task. Copilot can research the codebase, create a plan, change code on a branch and show us what it did. We can then continue the session, create a pull request, review it and merge.

GitHub has expanded this workflow aggressively during 2026. Mobile users gained model selection, native agent-session logs, deeper review controls and the ability to let the agent work without immediately producing a pull request.

GitHub also now exposes several model families through Copilot, and its paid plans increasingly treat GitHub itself as the place where different coding agents can be dispatched. That reduces the importance of which model's standalone mobile app we happen to prefer.

The cheapest paid Copilot plan is currently Pro at $10 per month. It includes the cloud agent and $15 of total monthly GitHub AI Credits under GitHub's current pricing structure. How fast those credits disappear depends on the model and the complexity of the tasks.

We particularly like this setup for small existing products with good CI. An issue can become an agent session; the session becomes a branch; CI checks it; a preview deployment appears; we review it on the phone and merge.

For many bug fixes, content changes, small features and maintenance jobs, we could complete the entire loop without seeing an IDE.

When is Termius plus a VPS better than Claude, Cursor or Replit?

Termius plus a VPS is still the best phone setup for indie hackers who want complete Linux access and are comfortable managing their own machine.

Termius is fundamentally an SSH client, which sounds less exciting than a native AI coding app. The advantage is that SSH places almost no limit on what we can run remotely.

A small VPS can host Claude Code, Git, Docker, Node, Python, database clients, cron jobs, logs, custom scripts and whatever else the project needs. Termius then gives us a mobile terminal for controlling that machine from iOS or Android.

This is the architecture Pieter Levels described for Infinite Slop. His phone ran Termius, Hetzner supplied the VPS, Claude Code handled much of the implementation and Safari displayed the site. The setup worked because the real development environment was an ordinary Linux server.

Termius currently includes SSH, SFTP and port forwarding on its free Starter plan. Pro is listed at $10 per month when paid annually and adds features such as cloud synchronization across devices.

On iPhone, Blink Shell is also worth knowing. Blink focuses heavily on the terminal itself and supports Mosh, which is useful when mobile connections change or the phone sleeps. It currently costs $19.99 per year. Android users have another unusual option in Termux, which provides a Linux-style environment directly on the device, although running long or compute-heavy development jobs locally remains less reliable than using a remote server.

We would choose the VPS route for scrapers, workers, bots, unusual infrastructure, long-running processes or products where direct server access is already part of normal operations.

For a conventional Next.js SaaS sitting on GitHub with managed hosting, a dedicated VPS adds work we may never need. Managed cloud agents are easier in that case.

Do GitHub Codespaces still make sense on a phone?

GitHub Codespaces is still extremely useful on a phone as the place we go when an AI agent gets stuck and we need direct control.

Codespaces gives us a real remote development machine with browser-based VS Code, a terminal, extensions, repository files and forwarded ports. The compute runs in GitHub's cloud, so the phone only has to render the interface.

That flexibility remains valuable because agent workflows eventually hit strange cases. We may need to inspect three files at once, run an unusual migration command, resolve a merge conflict manually or look through raw logs.

Codespaces lets us do those jobs without searching for a laptop.

The experience becomes cramped on a normal phone. A terminal, file tree, editor, source control and preview all compete for the same small display. On an iPad with a keyboard, Codespaces can feel surprisingly close to conventional development. On an iPhone, we would reserve it for shorter interventions.

GitHub's current free allowance for personal accounts is generous enough to make Codespaces an easy backup tool: 120 core-hours per month, equivalent to roughly 60 hours on a two-core machine, plus 15 GB of storage on GitHub Free. GitHub Pro raises those allowances further.

For any project we seriously intend to operate from a phone, we would keep a codespace configured. We just would not make it our default interface.

What is the fastest way to preview and deploy phone-built code?

The fastest phone workflow is to give every branch its own live preview URL and make production deployment happen automatically when we merge.

This is where a well-configured project can make phone development feel almost effortless.

Vercel's current Git integration creates preview deployments on branch pushes and pull requests, then automatically deploys the production branch after the change is merged. Each preview receives its own URL. Similar workflows exist with Cloudflare, Netlify, Railway and other Git-connected platforms.

Now connect that infrastructure to one of the mobile agents.

We ask Claude to fix a checkout issue. Claude pushes a branch. CI runs. Vercel creates a preview. We open the preview in Safari or Chrome and actually use the feature. If it works, we review the diff and merge. Production follows automatically.

The same sequence works with Cursor or GitHub Copilot.

This is much cleaner than making an AI agent modify production files directly over SSH. Git preserves every change, CI can reject broken work, preview deployments give us something tangible to inspect, and reverting a bad release becomes straightforward.

Pieter Levels said he simply used Safari to preview Infinite Slop while building it. That basic idea scales surprisingly well: when the product is a website, the browser on our phone is already one of the best places to test what customers will experience.

For serious phone shipping, we would spend time improving this deployment pipeline before spending money on a fancy mobile IDE.

How much does a good phone coding setup cost?

A capable phone-shipping stack currently starts around $10–$20 per month, although heavy autonomous-agent use can push the real bill much higher.

The entry prices are surprisingly close.

GitHub Copilot Pro currently starts at $10 per month. Claude Pro costs $20 monthly, or $17 per month on annual billing. Cursor Pro costs $20. Replit Core is currently around the same range, with the annual plan listed at $17 per month. Termius can handle basic SSH for free.

Those subscriptions increasingly function as access prices rather than unlimited-development prices. Claude shares usage limits across Claude and Claude Code. GitHub now meters AI activity through credits. Cursor explicitly says that daily agent users can end up spending substantially more than the base subscription. Replit also meters Agent and model usage through credits.

Codespaces is a useful exception for light usage because GitHub Free includes about 60 hours per month on a two-core environment.

That means cost should rarely determine which architecture we choose at the beginning. The differences between a $10 and $20 base subscription are tiny compared with the value of a workflow we will actually use. Agent consumption becomes worth watching once we are dispatching substantial work every day.

Tool	Current entry point	What that gives us
GitHub Copilot Pro	$10/month	Cloud agent, GitHub Mobile workflow, AI credits
Claude Pro	$20/month or $17/month annual	Claude Code and mobile cloud sessions
Cursor Pro	$20/month	Cloud agents and native iOS agent workflow
Replit Core	About $20 monthly or $17 annual	More Agent use, parallel agents and publishing
Termius Starter	Free	SSH, SFTP and port forwarding
GitHub Codespaces	Free allowance	About 60 hours/month on a 2-core machine

Where does coding from a phone still become painful?

Phone-only development still becomes painful when we need to understand a large amount of code or infrastructure at the same time.

AI agents have reduced the typing problem dramatically. Screen size remains stubbornly physical.

A small bug is a perfect mobile-agent task. “Users who sign in with Google are being redirected to /login again; reproduce it, find the cause and fix it” gives the agent a bounded problem.

A migration touching authentication, billing, database schemas, queues and several services demands much more attention from us. We may want to inspect dozens of files, compare architectural options, watch several logs and understand exactly how the pieces interact.

Large visual work has the same problem. We can spot a broken button on a phone easily. Reworking an entire responsive dashboard across desktop, tablet and several mobile sizes is far easier with more screen space.

Cursor's own product design reflects this boundary. The iOS app focuses heavily on starting agents, tracking them and reviewing artifacts. Claude describes mobile in similar terms around starting and monitoring work. Codespaces can technically bring the full IDE to a phone, but using a desktop-style IDE on a six-inch display quickly reminds us why delegation became attractive in the first place.

We would be comfortable running an indie business for days from a phone when the product is stable and the changes are reasonably contained.

We would still open a laptop for a messy production incident or a major architectural rewrite. Avoiding one in those situations becomes an arbitrary constraint rather than an advantage.

Is it safe to let AI agents ship code from your phone?

Phone-based development is safe enough for a real product when the agent works through branches, tests and controlled credentials instead of receiving unrestricted production access.

The phone itself is rarely the weakest part of the setup.

A GitHub-based workflow gives us a useful safety boundary. Claude, Cursor or Copilot can work on a separate branch. CI can test the result. A preview environment can show us what changed. We approve the merge. The deployment system takes over from there.

That structure also gives us a record of exactly what the agent changed.

The VPS route requires more judgment. An agent running under a powerful user on the same machine that holds production data can do much more damage after a bad instruction or mistaken command. We would separate development environments, limit credentials and keep normal backups even when the founder is comfortable moving fast.

Cloud agents create their own trade-off because source code and development context may run through vendor-managed infrastructure. Cursor, Anthropic and GitHub provide security controls around these systems, but founders with unusually sensitive code may still prefer to keep execution on infrastructure they control.

For a typical indie SaaS, our preference is simple: let agents move quickly inside reversible boundaries. Branches, CI, preview deployments, limited secrets and backups do more for safety than whether we tapped “merge” from an iPhone or a MacBook.

So what are the best tools to ship from your phone today?

Claude Code is our best overall tool for shipping from a phone today, while Cursor wins for the strongest iPhone-specific agent experience, Replit wins for starting a web app from zero, and Termius plus a VPS wins when we want full control.

We would build our default indie-hacker setup around Claude Code, GitHub and automatic preview deployments.

That combination keeps the architecture conventional. The code remains in GitHub. Claude can work from the mobile app on iOS or Android. A hosting provider turns branches into preview URLs. We test the result in the phone's browser and merge when we are happy.

Cursor deserves the top spot for some iPhone users. Its native app was designed specifically around managing coding agents, and features such as voice prompts, screenshots, artifacts, notifications and PR review make unusually good use of a phone.

Replit has a different advantage. When no project exists yet, it can remove most of the setup between an idea and a working public web app. That makes it our first recommendation for someone who wants to try an idea immediately and cares more about speed than infrastructure flexibility.

GitHub Mobile with Copilot is the sleeper option. At $10 per month for Pro, it now covers much more of the actual development cycle than many indie hackers realize, especially when CI and deployment already revolve around GitHub.

Termius plus a VPS remains hard to beat for people who understand Linux. We can install almost anything on the server and control it from almost any phone. Levels' Infinite Slop build is a good example of how powerful that freedom can become once an AI coding agent sits inside the terminal.

Codespaces completes the setup by giving us manual access to a real development environment when delegation stops working.

The broader conclusion is stronger today than it was recently: an indie hacker can now build, fix, preview and deploy serious web software from a phone without treating the exercise as a gimmick. The experience works best when the project has been designed around agents, Git and automatic deployments. A laptop is still better for deep debugging and large engineering changes, but we no longer need one for a surprisingly large share of everyday shipping.

Situation	Best tool or stack	Our judgment
Existing SaaS on iPhone or Android	Claude Code + GitHub + automatic previews	Best overall
Existing SaaS, heavy Cursor user on iPhone	Cursor Mobile + cloud agents	Best mobile interface
New web app with almost no setup	Replit	Fastest idea-to-URL workflow
GitHub-centered existing project	GitHub Mobile + Copilot	Best value
VPS, bots, scrapers or unusual infrastructure	Termius + VPS + Claude Code	Most flexible
Agent gets stuck and manual coding is needed	GitHub Codespaces	Best fallback