Skip to content
Winter Sale from $619, until 31st December 2026 Book now
Agentic coding workshops Android · Google Play

Agentic Coding Workshop for Android Developers: Kotlin, Compose and Gradle with Agents

Coding agents can write solid Kotlin and Jetpack Compose code, but Android projects punish them in predictable places: slow Gradle builds, scattered dependency versions, multi-module structure, outdated APIs and release signing. An Android-focused workshop turns Gradle into the agent's feedback loop, writes Kotlin and Compose rules into the instruction file and draws a clear line around keystores and Play Console decisions.

6 min read

Key takeaways

  • Give the agent narrow Gradle tasks per module – fast feedback beats a full build after every edit.
  • Keep dependency versions in the version catalog and require approval for new libraries.
  • Compose rules on state, ViewModels and previews, plus screenshot tests, keep agent-made UI consistent and reviewable.
  • Upload keys, target API changes, the Data safety form and Play Console settings stay under human control.

Where Android projects trip up coding agents

We start every Android workshop by looking at the team's own repository for the spots where agents tend to go wrong. The list is remarkably consistent:

AreaTypical agent mistakeWhat the workshop sets up
DependenciesBumps versions, adds libraries in the wrong module, hardcodes versions in build filesVersions only in gradle/libs.versions.toml; new libraries need approval
Build timeRuns a full build after every small edit and waits minutes for feedbackModule-specific Gradle tasks and unit tests as the default check
ModulesPuts code where it compiles rather than where it belongsA module map in the instruction file with allowed dependencies
Platform APIsUses deprecated APIs or adds manifest permissions casuallyMinimum and target SDK in the instructions; manifest changes reviewed
ComposeBusiness logic inside composables, state in the wrong placeCompose rules, previews and screenshot tests
ReleaseTouches signing configs or version codesSigning and release files listed as protected

Android Studio's agent or a terminal agent?

Android developers have a built-in option: Gemini in Android Studio, whose agent mode handles multi-step tasks inside the IDE. Recent Android Studio releases also let you plug in other remote model providers or local models, read instructions from AGENTS.md files and connect MCP servers – check the current release notes for what your version offers. Our article on Gemini in Android Studio covers that route through to release.

Many teams also use terminal agents such as Claude Code or the Codex CLI, which drive Gradle directly and fit well into scripts and CI. In the workshop, pairs solve the same ticket with both and compare. Stack-specific deep dives: Claude Code for Kotlin and Jetpack Compose and Codex for Android and Kotlin.

Talk to an AI Code Engineer about your agentic coding workshop.

In a free call we look at your team, your codebase and your goals and suggest a workshop format that fits – remote or on-site, in English or German.

Gradle as the agent's feedback loop

An agent is only as good as the signal it receives after each change. On Android that signal comes from Gradle, and the trick is to make it fast and specific. A typical commands section that the team writes during the workshop:

## Checks (run the narrowest one that covers your change)
./gradlew :feature:orders:testDebugUnitTest
./gradlew :app:assembleDebug
./gradlew lintDebug
./gradlew detekt   (only if the project uses detekt)

## Instrumented tests (only when asked, needs a running emulator)
./gradlew :app:connectedDebugAndroidTest

We also tune the build where it helps the agent most: configuration cache and build cache enabled, a warm Gradle daemon, and an emulator that can start without a window for instrumented tests on the workshop machines or in CI. The goal is a loop of seconds, not minutes, for the checks the agent runs most often.

Compose with agents: rules, previews and screenshots

Agents write Compose code quickly, and quick UI code drifts. The team agrees on a short rule set and puts it into the instruction file:

  • screens get state from a ViewModel exposing immutable UI state, composables stay stateless where possible,
  • no repository calls or business logic inside composables,
  • design system components and theme values instead of hardcoded colours and sizes,
  • every new screen gets previews for its main states – loading, empty, error, content.

Previews make reviews faster for humans. Screenshot tests make them safer: Google's Compose preview screenshot testing or libraries such as Paparazzi or Roborazzi catch visual regressions that unit tests miss. In the lab, the agent builds a screen against existing screenshot tests and has to keep them green.

How the workshop day runs

  1. Repository walk-through. The table above, filled in for your codebase.
  2. Instruction file. Commands, module map, Kotlin and Compose rules, protected files.
  3. Feature lab. Pairs take a real ticket from plan to tested pull request.
  4. Refactoring lab. A deprecated API or an old screen moved to Compose, with tests as a safety net.
  5. Release boundaries. What the agent may do in the release lane, what stays human.

Teams that want to focus on test suites can add the agentic testing workshop; a minute-level plan for a full day is in the sample agenda.

Keystores, target API and Play Console: the human part

Google Play has rules an agent will not keep track of on its own. The workshop makes them explicit:

  • Signing. New apps ship as Android App Bundles with Play App Signing; your team keeps the upload key. The keystore and its passwords never go into the repository or an agent session – CI gets them as secrets.
  • Target API level. New apps and updates must target Android 16 (API level 36) since August 31, 2026. Raising the target is a planned task with testing, not a one-line change an agent makes in passing. See the target API level guide.
  • Data safety. A new SDK can change what the app collects and shares, and the Data safety form must match – see Data safety with AI agents.
  • Accounts and payments. Apps with accounts need in-app deletion and a web link for deletion requests; digital goods use Google Play Billing.
  • Testing tracks. Internal, closed and open tracks before production, with the pre-launch report as an extra device check. New personal developer accounts must run a closed test with at least 12 testers for 14 consecutive days first.

The Google Play review checklist for AI-built apps turns these into a pre-release routine.

Running the workshop with us

Our AI Code Engineers ship Android apps to Google Play every week, from Gradle setup to Play Console review. We run the Android workshop remote or on-site, in English or German, on your repository where policies allow. Participants need Android Studio, the SDK versions your app uses, a working local build and the chosen agent installed. If your team would rather hand off signing, listings and the release process, the Android submission service covers that.

Frequently asked questions

Is Gemini in Android Studio enough, or do we need another agent?

For many teams the built-in agent is a good start because it knows the IDE. Teams that want automation, scripting and CI runs often add a terminal agent. The workshop lets you compare both on your own code before deciding.

Can coding agents work with large multi-module projects?

Yes, if they know the module structure and run module-specific tasks. A short module map in the instruction file and narrow Gradle commands make a big difference.

Should the agent update our dependencies?

Dependency updates are a good agent task when done deliberately: one library or group at a time, with tests and a changelog check. Random version bumps as a side effect of other work are what you want to prevent.

Do you run an iOS version of this workshop?

Yes – see the workshop for iOS developers. Cross-platform teams fit the React Native and Flutter workshop better.

Free, 15 minutes, no obligation

Plan your agentic coding workshop with us.

Our AI Code Engineers run hands-on workshops on Claude Code, OpenAI Codex, Cursor and AI app builders – and ship apps to the App Store and Google Play every week. Tell us about your team.

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.

Workshop for your team?

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.