# Android app with AI

> Same shape as the iOS stack, swap the platform tools. Cursor handles Kotlin and Jetpack Compose well. Android Studio's Gemini integration covers the simple completions; AI agents in Cursor cover the multi-file work. Distribute via the Play Console after a one-time $25 fee.

Source: https://aistack.sh/stack/android-app-with-ai
Category: Code · Mobile
Level: Intermediate
Last verified by a human: 2026-05-05

## The tools

### Claude — Product + plan

- Pricing: Free · $20/mo Pro · $100/mo Max 5x · $200/mo Max 20x · Sonnet API $2/$10 per M tokens (input/output)
- Site: https://claude.ai
- Why this one: Same role as the iOS stack. Spend the planning time before you open the IDE. Android also has Play Store policies that bite late-discovered scope (background location, accessibility services, foreground service types).
- Swap in instead: ChatGPT, Gemini
- More: https://aistack.sh/tool/claude

### Cursor — Kotlin / Compose editing

- Pricing: Free Hobby · $20/mo Pro · $60/mo Pro+ · $200/mo Ultra · $40/seat Teams · $120/seat Teams Premium
- Site: https://cursor.com
- Why this one: Strong Kotlin completions, Composer for cross-screen edits, and good interop with Gradle config files. Cursor handles Compose's declarative style well.
- Swap in instead: Claude Code, Android Studio
- More: https://aistack.sh/tool/cursor

### Android Studio — Build, profile, sign, upload

- Pricing: Free · Play developer account $25 one-time
- Site: https://developer.android.com/studio
- Why this one: Where the app actually builds and signs. Studio's Gemini is fine for inline completions if you want a second opinion. Profilers (CPU/Memory/Energy) are essential for the Play Store's Android Vitals section.
- More: https://aistack.sh/tool/android-studio

## Monthly cost

### $22/mo — Solo, first app (small)

- Claude: Free tier
- Cursor: $20
- Android Studio: Free
- + play-account: $2 (one-time $25, annualized)

### $42/mo — Solo, multiple apps (medium)

- Claude: $20
- Cursor: $20
- Android Studio: Free
- + play-account: $2

### $220/mo — Small team (heavy)

- Claude: $20
- Cursor: $200 (5x $40 Business)
- Android Studio: Free
- + play-account: $0 (org-wide)

## Workflow

### 1. Plan in Claude (Claude)

Same scoping pass as the iOS stack — but the Play Store review concerns are different.

**Prompt: Android app scoping prompt**

```
Plan a small Android app for the idea below. Don't write Kotlin yet.

Idea:
"""
{{1-line product description}}
"""

Constraints:
- Jetpack Compose only. No XML layouts unless legacy interop forces it.
- Single-activity architecture with Navigation Compose.
- Local-first storage (Room) unless I ask for sync.
- No background services unless I justify the foreground service type.
- No accessibility services unless explicitly asked (Play Store policy gate).

Output, in this order:
1. **Screens** (3 to 6 max) — name + 1-line purpose.
2. **Data model** — Room entities + DAOs.
3. **Permissions** — exactly what's needed + the Play Console justification.
4. **Play Store hooks** — name candidates (3), category, short description, screenshot story.
5. **Out of scope for v1** — 3 to 5 things I should NOT build first.

Flag any Play Store policy risks (especially around background location, foreground services, and SMS/Call permissions).
```

### 2. Scaffold with Cursor (Cursor)

Cursor at the project root. Composer scaffolds screen-by-screen. Use Android Studio side-by-side for previews; the @Preview cycle is fast.

### 3. Run on Emulator + a real device (Android Studio)

Android Studio: Pixel 9 emulator + at least one cheap real device (Samsung mid-range). Layout breakage on smaller / older devices is the most common Play Store quality complaint.

### 4. Profile with Android Vitals (Android Studio)

Studio Profiler before release. The Play Console grades you on startup time, ANR rate, and battery — get them green before the first Play submission.

### 5. Sign + upload (Android Studio)

Build → Generate Signed Bundle → upload to Play Console as Internal testing first. Promote to Production after a few days of internal testing.

## What it produced

**Indie shop, hobby app shipped in 3 weeks**

Solo dev built a niche utility app. Cursor handled the bulk of Compose code; Studio Profiler caught a startup regression that would have failed Android Vitals. Internal testing for 5 days, promoted to production at week 4. Initial install rate: 1.2k organic in month 1.

## Pitfalls

- **Composer suggesting XML layouts** — AI agents trained on older Android codebases sometimes default to XML. Re-prompt for Compose; mixing XML and Compose works but doubles the surface area.
- **Forgetting the Play data-safety form** — Like Apple's nutrition labels, but more aggressive. Walk through every dependency with Claude before submitting. Mismatches between actual SDK behavior and the form get apps removed, not just rejected.
- **Treating Studio's Gemini as the agent** — Studio's Gemini integration is fine for inline completions but doesn't reach Cursor's Composer or Claude Code for cross-file edits. Don't fight Gemini; treat it as a faster Tab key.

## Recent changes affecting this stack

- **Cursor launches Projects to coordinate large bodies of work with subagent delegation** (2026-09-10, feature) — Projects enables managing feature development, migrations, and full apps with a coordinator agent that plans work, delegates to subagents, and maintains context over months. The coordinator runs agents in parallel and can watch Slack channels or run on schedules to automatically pick up work without explicit prompting. Source: https://cursor.com/changelog
- **Cursor launches Projects for coordinating multi-month work across thousands of subagents** (2026-09-10, feature) — Projects maintain context over months of work, with a coordinator agent that plans work and delegates to subagents running in parallel. Projects can watch Slack channels or run on schedules to take action without being prompted, keeping shared context across all agents involved. Source: https://cursor.com/changelog
- **Cursor launches Projects for coordinating large bodies of work with multiple subagents** (2026-09-10, feature) — Projects is a new feature that maintains context over months of work and delegates tasks to thousands of subagents. A coordinator agent plans the work and delegates to implementation agents that run in parallel. Projects can watch Slack channels, follow PRs, or run on a schedule to take action automatically without prompting. Source: https://cursor.com/changelog
- **Cursor adds self-hosted machine support with dynamic pool scheduling and computer use** (2026-09-02, feature) — Cloud agents can now execute on internal infrastructure, keeping codebases and secrets on-premise. Features include dynamic pool scaling that grows with demand and hibernates idle workers, plus computer use (clicks, typing, screenshots) on Linux and Mac self-hosted workers. Source: https://cursor.com/changelog
- **Cursor adds self-hosted machines with dynamic pool scheduling and multi-platform computer use** (2026-09-02, feature) — Cursor now supports self-hosted machines that keep tool execution entirely in your infrastructure. Features include dynamic pool scheduling for teams with auto-scaling capacity, execution on existing platforms (AWS Lambda, Coder, Cloudflare, Modal, etc.), and computer use support on Linux and Mac for browser automation and desktop interaction. Source: https://cursor.com/changelog

---

Curated by alex-w on aistack.sh. Last updated 2026-05-05.
