Skip to content
Winter Sale from $619, until 31st December 2026 Book now
From agentic coding tool to the App Store iOS · App Store Lovable

Lovable to the App Store with Claude Code or Codex: The Agentic Route

Lovable builds web apps, not iPhone apps. The agentic route connects your Lovable project to GitHub, lets Claude Code or Codex build and maintain a native iOS shell and a TestFlight pipeline on a Mac, and leaves the Apple account, the store listing and the conversation with App Review to a person. Lovable stays where you design the product; the agent owns the native layer.

8 min read

Key takeaways

  • Keep three roles apart: Lovable designs and publishes the web app, a coding agent maintains the iOS shell and pipeline, and a person owns the Apple account and the review.
  • Give the native shell its own repository; the agent reads the Lovable-synced repository for context and sends small, reviewed pull requests to it.
  • Projects created since May 13, 2026 render on the server, so the shell has to load your live domain – bundling the code with Capacitor is no longer an option for them.
  • Every Lovable publish changes the app instantly, so freeze publishing while a build is in review and tie each build to a commit.

Three workers, one release: Lovable, the agent and you

The agentic route adds a coding agent – Claude Code, Codex or a similar tool – that writes and maintains the native part as real code, next to the web code Lovable already syncs to GitHub. You get a shell you fully own and can change at any time. It only works if everyone knows their job:

WhoOwnsDoes not touch
LovableScreens, flows, Lovable Cloud backend, publishing to your domainAnything native
Coding agentThe Xcode project, the JavaScript bridge, native features, the CI pipeline, small app-specific pull requests to the web repositoryApple accounts, signing secrets, the App Store Connect record
YouApple Developer Program, agreements, App Privacy answers, review notes, merge and publish decisionsNothing – you are the approver

This article covers how to set that up. For the wrapper options, sign-in traps and the review checks specific to Lovable, our guide on converting Lovable to an iOS app goes into depth – we won't repeat it here.

Step 1: Connect GitHub and give the shell its own repository

Connect the Lovable project to GitHub in the project settings. The sync runs both ways: commits on the synced branch show up in the Lovable editor, and edits in Lovable land in the repository. That is exactly why the native shell should not live in the same repository. Lovable's AI may restructure files it considers its own, and a large ios/ folder in a web project only confuses it.

A layout that works well:

  • web – the Lovable-synced repository. Humans and Lovable change it; the agent sends occasional pull requests on feature branches.
  • ios-shell – a new repository the agent creates and maintains: the Xcode project, fastlane configuration, CI workflow and its own CLAUDE.md or AGENTS.md.

Clone both side by side on the Mac so the agent can read the routes, the sign-in flow and the edge functions when it writes the bridge. Its pull requests to the web side stay small: safe-area padding, an app-mode layout triggered by a user-agent marker, a self-service delete-account flow, /privacy and /support pages. You merge, check in Lovable and publish.

Talk to an AI Code Engineer about shipping your app to the App Store.

In a free call we look at what you built, tell you honestly what stands between it and an approved release – and whether you need us at all.

Step 2: Let the Lovable generation decide the shell

Before the agent writes a line of Swift, ask it to read package.json and the build setup in the web repository and tell you which generation the project belongs to. The answer decides the architecture:

Lovable projectWhat the agent findsShell to build
Created since May 13, 2026TanStack Start, rendered on the serverA Swift project with a WKWebView that loads your live custom domain
Older projectsReact and Vite, static dist/ outputEither the live-URL shell or a Capacitor project that bundles the build – the backend stays online either way

One shortcut to forbid explicitly: pointing Capacitor's server.url at the live site – Capacitor's own documentation says that setting is not meant for production. The agent can also extend a ready-made wrapper project such as WebViewGold, which our team builds, instead of starting from scratch. Our overview of Capacitor apps with coding agents covers the bundled route.

Step 3: Brief Claude Code or Codex for the native layer

Start the shell repository with an instruction file – CLAUDE.md for Claude Code, AGENTS.md for Codex and most other agents. It should state the start URL (your custom domain, never the lovable.app address or a preview link), the hosts the web view may open, the bundle identifier and team, the deployment target, and the files the agent must not change without asking: entitlements, Info.plist purpose strings, the privacy manifest and signing settings.

Then hand over the native features as separate tasks, each with acceptance criteria:

  1. A web view that stays inside your domain and opens every other link in a Safari view.
  2. A native offline screen with a retry button instead of a blank page.
  3. Push notifications through APNs, with a script message handler that passes the device token to the web app, which stores it through an edge function.
  4. Universal links: the Associated Domains entitlement plus an apple-app-site-association file served by the web app.
  5. Google sign-in outside the web view, using ASWebAuthenticationSession and a custom URL scheme callback – Google blocks its sign-in page inside embedded web views.
  6. If you sell digital content: StoreKit purchases started from the web app through the bridge, with the entitlement recorded on the server.

Run each task in plan mode first, read the plan, then let the agent build, test and fix its own compile errors. Codex cloud tasks run in Linux containers – fine for pull requests against the web repository, useless for xcodebuild. Use the Codex CLI or Claude Code on a Mac for the shell. Our comparison of Claude Code and Codex for mobile apps helps if you haven't picked one yet.

Step 4: The agent writes the pipeline, you hold the keys

A shell you rebuild every few weeks deserves a pipeline. Ask the agent for a GitHub Actions workflow on a macOS runner (or Xcode Cloud, Bitrise or Codemagic) that selects Xcode 26, runs the tests, archives with the iOS 26 SDK and uploads to TestFlight through a fastlane lane. Apple only accepts uploads built with Xcode 26 and the iOS 26 SDK or later, so pin that in the workflow.

The agent can write every file of that pipeline. What it needs from you, and should never generate on its own:

  • the Apple Developer Program membership – organizations need a D-U-N-S Number to enroll,
  • the app record in App Store Connect, with the bundle ID the shell uses,
  • an App Store Connect API key, stored as a CI secret,
  • the certificate repository or signing setup, owned by your Apple team.

Our playbooks on fastlane with coding agents and GitHub Actions for mobile CI show the lanes and workflows in detail. Send the first builds to internal TestFlight testers right away; external testers follow after Apple's beta review.

Step 5: App Review – and the Publish button

The Lovable-specific risk at review time has nothing to do with Swift. Your app shows whatever Lovable last published, so a publish during review changes the app the reviewer is looking at. Apple treats features that appear or change after review as a Code of Conduct problem – see our posts on Lovable and Guideline 5.6 and Guideline 2.3.1.

Three habits keep this under control:

  • Publish freeze. No feature publishes in Lovable from submission until approval. Content and bug fixes are fine afterwards; new features ship with the next reviewed version.
  • Build-to-commit mapping. The pipeline writes the web repository's commit hash into the build's release notes, so you always know which web state a build was reviewed with.
  • A feature inventory. Let the agent list every screen, role and paid feature it finds in both repositories. You correct it and turn it into the Notes for Review, together with a working demo account.

Then check the usual Lovable triggers: native value under Guideline 4.2, Sign in with Apple next to Google or Microsoft (4.8), In-App Purchase instead of Paddle or Stripe for digital goods (3.1.1), and account deletion inside the app (5.1.1(v)).

Where our AI Code Engineers fit

Our AI Code Engineers set up signing and the pipeline, prepare the listing and App Privacy answers, and handle review in your own Apple Developer account – see the iOS submission service. Planning Android too? The same two-repository setup carries over, with different store rules: read Lovable to Google Play: the agentic route.

Checklist: Lovable to the App Store with an agent

  • The Lovable project syncs to GitHub, and the native shell lives in its own repository.
  • The agent confirmed whether the project uses TanStack Start or React with Vite, and the shell matches.
  • The shell loads your custom domain, never the lovable.app address or a preview link.
  • CLAUDE.md or AGENTS.md lists bundle ID, team, start URL, allowed hosts and protected files.
  • Google sign-in runs outside the web view, and Sign in with Apple is offered where Google or Microsoft is.
  • CI archives with Xcode 26 and uploads to TestFlight; account deletion and In-App Purchase are in place.
  • Lovable publishing is frozen from submission until approval, and each build records its web commit.

Frequently asked questions

Can Claude Code or Codex publish my Lovable app to the App Store by itself?

No. The agent can build the iOS shell, write the pipeline and run the upload once you have set up the Apple Developer account, the app record and an API key. Enrolling, accepting agreements, answering the privacy questions and submitting for review stay with you.

Should the iOS project live in the same repository as my Lovable code?

We recommend a separate repository. Lovable syncs its repository in both directions and treats it as a web project. Keeping the shell apart avoids conflicts and lets the native app follow its own release rhythm.

Can I use Capacitor for a Lovable app?

Only for older Lovable projects that build to a static folder. Projects created since May 13, 2026 render on the server, and Capacitor does not recommend loading a live URL in production, so those need a shell that loads your domain.

Can you take over the release for us?

Yes. Book a free call and an AI Code Engineer reviews your Lovable project and the shell with you. If you want, we take over signing, CI/CD, the listing and the review conversation in your own accounts.

Free, 15 minutes, no obligation

Get your app from agent output to approved release.

Our AI Code Engineers take apps built with Claude Code, Codex, Cursor, Lovable, Base44 and co. through signing, CI/CD, store listings and review – in your own developer accounts.

AI tools, store policies and requirements change quickly – always check the current documentation of the tools and stores you use. This article is independent advice and not affiliated with or endorsed by Apple, Google, Anthropic, OpenAI or any other company or product mentioned; all trademarks belong to their owners.