Everyone is hyping Claude Code. I used Google Jules to build and ship a phone tracking app—entirely from my phone on the beach.

Mauro Gentile — Sat, 22 Aug 2026 20:14:57 +0000

Don't get me wrong: I love Claude Code. I use it every single day. I’ve used its various models to build several apps, utilities, reports, presentations, and tools, and I rely on it heavily for bug fixing and surgical refactoring.

In fact, one of my favorite things about Claude Code is that you don't even need an IDE—I use it almost exclusively in my terminal.

But there is a catch with local AI agents: you still need your computer and a local workspace.

Recently, I had an idea for a location-sharing app. But I was on holiday, taking in the sun on the beach. I didn't want to spin up my local environment, and I definitely wasn't going to open a laptop. I wanted a system that could generate boilerplate, iterate directly on GitHub, and build out a full CI/CD pipeline from verification to release—all from my mobile browser.

So, I put Claude down, opened my smartphone, and navigated to Google Jules [https://jules.google/].

What started as a browser-based prototype eventually evolved into a published Android app, built and verified through an automated pipeline. It took a couple of days of casual iteration from my beach chair, and I managed the entire architecture without ever touching a keyboard. Here is exactly how the agentic workflow played out.

The Problem: Friction and Registration Bloat

I wanted to build MobTracker [https://play.google.com/store/apps/details?id=com.mobtrack.app]: an app that can locate any phone just by specifying the phone number.

Existing locators are packed with friction. I wanted a clean utility with no forced account creation, no logins, no complex registration workflows, and no password managers. You just enter a number and press a button and that's it.

Because I was developing this purely from the web interface of Google Jules on a mobile screen, I needed a phased architectural approach.

Phase 1: Proving the Concept (Web-Only)

You don't jump straight into native mobile development when testing a core mechanic. I first used Jules to build a web-only application.

The workflow with Google Jules is asynchronous. I connected it to a fresh repository and prompted it to build the core pairing logic and web interface so that the app could run in any browser.

Jules analyzed the request, formulated a plan, and began submitting Pull Requests to my repository. I reviewed the code diffs directly on my phone and merged them. Once the web application was stable and the frictionless phone-number pairing proved successful, it was time to go native.

Phase 2: Transitioning to Mobile (iOS & Android)

With the web prototype working, I directed Jules to adapt the architecture to support native applications for both Android and iOS.

Honestly, porting to mobile was as easy as asking for it. I prompted Jules to handle the native translation using Capacitor, and the agent did the heavy lifting. I spent my time just iterating a bit to refine the security rules, update the app icon, adjust the viewport, and polish some mobile specificities.

Instead of opening a local code editor, I simply communicated these tweaks to Jules via the web dashboard, and it pushed the fixes directly to GitHub. Since I am already an approved Google Developer, I decided to compile and publish the Android version first.

Phase 3: The CI/CD Pipeline (Verification to Ship)

To maintain the app moving forward, I wanted a fully automated CI/CD pipeline. I couldn't run local tests or build App Bundles (AAB) from my phone.

Because Jules integrates natively with the repository, I used it to help structure an automated multi-platform release loop via GitHub Actions. Instead of manually writing out YAML on a touchscreen, Jules built out a comprehensive, automated pipeline that triggers on every push to main.

Here is the high-level picture of what the pipeline automatically executes:

Verification: It spins up a Node.js environment, installs dependencies, and runs all linting and automated unit tests.
Web Deployment: If the push is on the main branch, it compiles the web assets and seamlessly deploys the PWA version straight to GitHub Pages.
Mobile Sync: It triggers Capacitor to sync the web code with the native Android and iOS platform folders.
Android Compilation: It provisions the Android SDK, securely masks my keystore credentials, and compiles both a signed APK and a Play Store-ready App Bundle (AAB).
iOS Packaging: It zips the Xcode workspace structure for easy deployment later.
Automated Release: Finally, it dynamically extracts the version number from package.json, tags the git commit, and creates a formal GitHub Release attaching all the generated artifacts.

All of this happens in the cloud, while I just watch the green checkmarks appear.

The Google Jules Experience: Agentic Co-working

As a Tech Director at Ubisoft Milan with a couple of decades in the industry, I am used to giving direction, following production steps, suggesting improvements, leading development, and fixing pipeline issues. Jules perfectly fits this dynamic—in fact, Jules feels like your next-desk coworker.

The UI is incredibly clean and intuitive, perfect for mobile use. When you give Jules a task, it doesn't just start coding. It reads your repository, formulates a step-by-step plan, and asks for your approval. Once approved, it spins up a secure workspace, writes the code, and opens a formal Pull Request in your GitHub repository.

You review the PR just like you would with a human colleague. If something isn't right—say, a UI element is misaligned or a security permission needs tweaking—you don't have to fix it yourself. You literally just leave a comment on the PR tagging @jules (e.g., "@jules the viewport scaling is slightly off on smaller screens, could you fix the issue?").

Jules reads the comment, jumps back into the code, writes the fix, and pushes a new commit to the exact same PR. You just hit merge when it's perfect. The friction of translating AI output into your codebase is completely eliminated.

The Result

By using Google Jules, I managed the entire lifecycle of an application—from a web-based proof-of-concept to a native mobile build with a fully automated CI/CD pipeline—in a couple of days, during my holidays, while taking sun on the beach using my smartphone.

MobTracker is now live on the Google Play Store.

I decided to make it a premium, paid app. Why? Because I wanted to build a tracking utility that genuinely respects your privacy and removes all the onboarding friction. Free tracking apps monetize by selling your data to advertisers; MobTracker sustains itself through a straightforward upfront price, ensuring your data stays strictly yours.

I will always rely on Claude Code for deep local debugging and rapid terminal-based execution. But for orchestrating an entire repository, collaborating via PRs, migrating from web to native, and managing GitHub Actions purely from a smartphone browser, Google Jules is an incredibly powerful agent.

If you want to support me and need a privacy-first, frictionless tracker, check out what an AI agent and I built from the beach:
👉 Get MobTracker on Google Play [https://play.google.com/store/apps/details?id=com.mobtrack.app]