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

Cline App to Google Play: The Release Path from Gradle Build to Production

An Android app built with Cline reaches Google Play in stages: a release build Gradle can reproduce, an App Bundle signed with your upload key, the internal testing track, a closed test with the pre-launch report, the Play Console forms and finally production. Cline handles the Kotlin and Gradle work in VS Code; keys, testers, policy declarations and the production decision stay with you.

7 min read

Key takeaways

  • Make the Gradle wrapper the single source of truth, so Cline in VS Code and Android Studio build exactly the same thing.
  • Check the merged manifest after Cline adds a library – dependencies can bring permissions that change your Data safety answers.
  • Use the internal track for fast feedback and the closed track for the pre-launch report and, on new personal accounts, the 12-tester, 14-day requirement.
  • Production access, staged rollout and every policy declaration are human decisions in Play Console.

VS Code for the agent, Android Studio for the device

Cline lives in VS Code. It edits Kotlin and Gradle files, runs commands in the integrated terminal and asks for approval along the way. Android Studio is still worth keeping installed: its emulator manager, Logcat, layout inspection and merged manifest view make device problems much faster to understand.

The two tools stay in sync if the Gradle wrapper is the contract between them. Put that into a .clinerules file at the project root:

# Android release rules
- Build only with ./gradlew. Never use a global Gradle install.
- JDK and Android Gradle Plugin versions are set in the repo. Do not change them.
- applicationId is fixed. Never change it.
- targetSdk is 36. Never lower it to silence a warning.
- Do not edit signing configuration or keystore files.
- After adding a dependency, list any new permissions in the merged manifest.
- Tests: ./gradlew testReleaseUnitTest lintRelease

Rules like these matter because agents tend to fix build failures by the shortest route – lowering a version, switching off a check, adding a permission. For a broader look at the agent itself, see our overview of open-source agentic coding tools.

The release path at a glance

StageCline's partYour partDone when
1. Release buildBuild types, R8 rules, version schemeReview Gradle diffs./gradlew bundleRelease works on a clean checkout
2. SigningSigning config that reads from the environmentCreate and store the upload keyCI produces a signed .aab
3. Internal testingFixes from tester feedbackCreate the app, enroll in Play App Signing, first uploadYour team uses the build daily
4. Closed testingFixes from the pre-launch reportRecruit testers, keep them engagedStable build, test requirement met
5. Store formsDrafts for Data safety and listing textSubmit forms and policy declarationsNo open items in the app content section
6. Production–Apply for access, roll out in stagesRollout at 100% without new crashes

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.

Stages 1 and 2: a reproducible, signed App Bundle

Ask Cline to prepare the release build type: R8 minification with keep rules for libraries that need them, a versionCode derived from the CI build number and targetSdk set to 36. Since August 31, 2026, new apps and updates must target Android 16 – our target API level guide covers the behaviour changes to test.

For signing, create the upload keystore yourself and keep it outside the repository. Locally, Gradle can read the passwords from ~/.gradle/gradle.properties; in CI, from secret environment variables. Cline writes the signingConfig that reads those values – it never needs to see them. With Play App Signing, Google holds the app signing key, so a lost or leaked upload key can be replaced through Play Console.

One check is easy to forget: the merged manifest. Libraries contribute their own manifest entries, so a dependency Cline adds for analytics or media can bring permissions you never wrote. Look at the merged manifest in Android Studio or in the build output after every new dependency. Those permissions feed your Data safety answers and, for sensitive ones, extra declarations.

Stages 3 and 4: internal track, closed test and pre-launch report

Create the app in Play Console, accept Play App Signing and upload the first bundle to internal testing. The internal track takes up to 100 testers and is available within minutes – ideal for daily use by your own team. Collect what they find and hand it to Cline one issue at a time, with steps to reproduce and the Logcat output.

The closed track adds two things. First, the pre-launch report: Google installs the build on real devices, crawls it and reports crashes, performance and accessibility issues. Upload the R8 mapping file with each bundle so stack traces are readable, then give them to Cline. Second, for new personal developer accounts, the closed test is a requirement: at least 12 testers opted in for 14 consecutive days before you may apply for production. Internal testing does not count toward it. Our guide to the 12-tester rule explains the details.

Stage 5: listing and policy forms

Play Console's app content section collects the declarations Google reviews alongside your build. Cline can prepare drafts from the code; you submit them:

  • Data safety – based on the merged manifest, your SDK list and what your backend stores. Our playbook on Data safety with AI agents shows how to derive the answers.
  • Privacy policy – a public URL that matches the Data safety answers.
  • Account deletion – if users can create accounts: a deletion path in the app plus a web link where they can request deletion without the app.
  • Content rating, target audience, ads – questionnaires only you can answer.
  • Payments – digital goods and subscriptions use Google Play Billing.

Stage 6: production access and a careful rollout

Accounts that ran the closed test apply for production access in Play Console, answering questions about the test and the app. After approval, release to production with a staged rollout – a small percentage first, then more as crash and ANR rates stay calm. A rollout can be halted if something goes wrong. Every later update needs a higher versionCode and the same upload key.

If you would rather not run these stages yourself, our AI Code Engineers set up the upload key, Play App Signing and a CI pipeline, prepare the listing and Data safety answers, plan the closed test and handle the review – in your own Play Console account, through the Android submission service. Shipping the same app on iPhone? Read Cline app to the App Store.

Cline Android release checklist

  • .clinerules fixes the Gradle wrapper, applicationId, targetSdk and protected signing files.
  • ./gradlew bundleRelease succeeds on a clean checkout.
  • The release build targets API level 36 and was tested on Android 16.
  • The upload keystore lives outside the repository; Gradle reads passwords from the environment.
  • The merged manifest was reviewed after every new dependency.
  • The app is enrolled in Play App Signing and the first bundle is on the internal track.
  • R8 mapping files are uploaded with each bundle.
  • The pre-launch report shows no open crashes.
  • New personal accounts: 12 testers have been opted in to the closed test for 14 consecutive days.
  • Data safety, privacy policy, account deletion link, content rating and target audience are complete.
  • Digital goods use Google Play Billing.
  • Production starts as a staged rollout.

Frequently asked questions

Can I release an Android app with Cline and no Android Studio?

Technically yes – Gradle builds and signs the bundle from the command line, and Play Console runs in the browser. In practice, Android Studio's emulator, Logcat and merged manifest view save a lot of time when something goes wrong.

Why does my app ask for permissions I never added?

Because libraries bring their own manifest entries, which Gradle merges into your app. Check the merged manifest, remove unneeded permissions with a tools:node="remove" entry where appropriate, and update your Data safety answers.

Can the Cline CLI publish my app from CI?

Cline's CLI can run tasks without the editor, which is useful for code chores in CI. Keep publishing in a deterministic pipeline step – fastlane or a Gradle plugin with a service account – rather than in an agent run.

Do internal testers count toward the closed test requirement?

No. The requirement for new personal accounts refers to a closed test. Use internal testing for your team and a closed track for the 12 testers and 14 days.

Can you take our Cline app to Google Play?

Yes. Book a free call and an AI Code Engineer looks at your Gradle setup and Play Console status with you, then explains which stages we can take over.

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.