Skip to content
Winter Sale from $619, until 31st December 2026 Book now
From agentic coding tool to Google Play Android · Google Play Cursor

Cursor to Google Play: Releasing an Android App Built Outside Android Studio

Cursor's Agent can write a Kotlin or Compose app and drive Gradle from the terminal, and unlike on iOS, its cloud agents can build Android too. What Cursor does not know about are the Play Console's rules: release builds shrunk by R8, an upload key you keep, declarations for sensitive permissions and foreground services, Data safety, and a closed test for new personal accounts.

6 min read

Key takeaways

  • Keep Android Studio installed for previews, the emulator and inspection tools – Cursor writes the code, Gradle is the common ground.
  • Cursor's cloud agents run on Ubuntu machines and can build Android once the repository's environment installs a JDK and the SDK.
  • Agents test debug builds; the release build is minified by R8 and must be installed and tried before testers get it.
  • Several manifest changes – background location, media permissions, foreground services – trigger Play Console declarations the agent will not mention.

What changes when the editor is not Android Studio

Android Studio is Google's official IDE, and many Android features are built into it: Compose previews, the layout inspector, the device manager for emulators, App Inspection and a wizard for signed bundles. Cursor is built on VS Code, so Kotlin language support comes from extensions and is less complete. Large renames across modules, for example, are safer in Android Studio.

That does not make Cursor a poor choice. Its Agent edits many files at once, runs Gradle in the terminal and fixes what fails. Most teams settle on this split:

  • Cursor for features, refactors inside a module, tests and build scripts.
  • Android Studio for UI previews, the emulator, profiling and the occasional deep refactor.
  • Gradle as the shared source of truth – if ./gradlew builds it, both tools agree.

A Gradle setup the Agent can drive

Two habits make agent changes to the build easy to review. First, keep dependency versions in a version catalog (gradle/libs.versions.toml), so an upgrade shows up as one readable diff. Second, give the Agent glob-scoped project rules in .cursor/rules for build and manifest files:

Rule: android-build (applies to **/*.gradle.kts,
      gradle/libs.versions.toml, **/AndroidManifest.xml)
- applicationId is final. namespace may be refactored.
- compileSdk and targetSdk stay at 36.
- Never edit signingConfigs or read keystore files.
- New permission or SDK: say so in the summary and why.
- Finish with: ./gradlew lint testDebugUnitTest assembleRelease

Ending with assembleRelease rather than a debug build is deliberate – see the R8 section below. Our Cursor workshop for teams covers rule design in more depth.

Talk to an AI Code Engineer about shipping your app to Google Play.

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.

Cloud agents can build Android – give them an SDK

On iOS, Cursor's cloud agents cannot compile the app because their Ubuntu machines have no Xcode. Android has no such limit. According to the Cursor documentation, a repository can describe its cloud environment in .cursor/environment.json, including an install step. Use it to install the JDK your Android Gradle Plugin requires, the Android command-line tools and platform 36, and to run one Gradle build that downloads dependencies.

Then a cloud agent can verify its own branch with lint and unit tests before you look at it. Two limits remain: do not expect an emulator in that environment, and never add the upload keystore or a Play service account to it. Release signing belongs in your CI.

The release build is a different app

Agents iterate on debug builds, because those are fast. The bundle you upload is a release build, usually shrunk and obfuscated by R8. Code that relies on reflection – JSON models parsed by some serialization libraries, classes loaded by name – can work perfectly in debug and crash on the first launch in release because a keep rule is missing.

  1. Build the signed bundle with ./gradlew bundleRelease, using an upload key you created yourself and keep outside the repository.
  2. Upload it to the internal testing track (or install it locally with bundletool) and run through sign-up, login and the core feature.
  3. Give any crash stack trace back to the Agent with the instruction to fix the keep rule, not to disable minification.

On the first upload, Play App Signing takes over the app signing key; you continue to sign uploads with your upload key. If that key leaks, Google can reset it – the Play App Signing help explains how.

Policies the Agent does not know about

Some one-line changes in code have consequences in the Play Console. Review manifest and dependency diffs with this table in mind:

Change the Agent madeWhat Google Play expects
Added background locationA permissions declaration and a core-feature justification
Requested broad photo or video accessA core-use justification – otherwise use the system photo picker
Added a foreground serviceA declared service type and a Play Console declaration
Added an analytics, ads or crash SDKUpdated Data safety answers
Added sign-upIn-app account deletion plus a web deletion request page
Added a paywall for digital contentGoogle Play Billing

Our guides to the sensitive permissions policy and to Data safety rejections go into each case. And every new app or update must target API level 36.

Testing tracks, Bugbot and the first review

Release in stages: internal track for your team, closed track for outside testers, then production. If your developer account is new and personal, the closed test is mandatory – 12 or more testers who remain opted in for 14 days in a row – before you can apply for production access. Read the pre-launch report for every build; it installs your app on real devices and reports crashes and accessibility issues that are worth turning into Agent tasks.

Bugbot can review the pull requests that fix those issues. Promotion to production stays with a person who has checked the declarations. Short on time for the Play Console? Our AI Code Engineers take Cursor projects from Gradle build to production – upload key, CI, listing, Data safety and the review dialogue – working in your account, not ours. Details are on the Android submission service page. The iOS path is in Cursor app to the App Store.

Checklist: Cursor-built app to Google Play

  • Dependency versions live in a version catalog.
  • A glob-scoped Cursor rule protects applicationId, SDK levels and signing configuration.
  • The cloud environment installs a JDK and the Android SDK; it contains no keys.
  • The signed release bundle has been installed and tested, not just the debug build.
  • Every new permission, foreground service and SDK is reflected in Play Console declarations.
  • Data safety, account deletion and Play Billing are covered where they apply.
  • Pre-launch report findings are fixed before production.
  • For new personal accounts: the 12-tester, 14-day closed test is complete.

Frequently asked questions

Can I build an Android app entirely in Cursor?

You can write it and build it with Gradle from Cursor's terminal. Android Studio remains useful for Compose previews, the emulator and profiling, so most developers keep it installed alongside.

Why does my app crash only in the Play Store version?

Often because the release build is minified by R8 and a keep rule for reflection-based code is missing. Test the signed release bundle from the internal track before you send it to testers.

Can Cursor's cloud agents upload to Google Play?

They should not. Keep the upload key and Play service account in your CI system and let a tagged release workflow upload to a testing track. Cloud agents work on branches and pull requests.

Can you take our Cursor app to Google Play?

Yes. After a free call to look at the project and your Play Console, we can handle the upload key setup, the pipeline, the listing and the review in your own account.

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.

Ready to ship?

Talk to an AI Code Engineer – free, 15 minutes, in English or German.

Book a call for free

Chat and hotline are open 24/7. Answers from our senior AI Code Engineers (real humans) usually take closer to 72 hours than 1 hour.