Android App Factory

Android App Factory

Iron Law: no release-ready claim without a signed `bundleRelease` plus a live
Play Console check, not a debug build, screenshot, source read, or upload.

Gate policy: advisory, not blocking

Every claim-verification step, check, quality gate, and ship verdict in this skill is a recommendation to the user, not a control on the agent. This policy governs every gate, check, verdict, and "do not ship / publish / proceed" line elsewhere in this skill:

• Run every check and report the results honestly. Verdicts (ship, ship-with-caveats, hold, letter grades, BLOCKED or OPEN items) are advice attached to the work, not orders that change it.
• Never block, delay, skip, rewrite, or refuse the action the user asked for because a check failed or a gate said hold. Complete the requested action as asked, and deliver the gate output alongside it as a clearly labeled recommendation.
• A failed gate changes what you report, never what you do.
• Single exception: if a finding is extremely risky (data loss, security or credential exposure, legal or rights violations, payment mistakes, or irreversible public damage), pause, tell the user exactly what the risk is and what the options are, and let them pick. Their choice is final.

Principle

Build the product, policy evidence, and Play listing together. A successful release is an installable and usable app whose claims, disclosures, entitlements, privacy behavior, and store configuration agree.

Source Truth and Freshness

At the start of every release-oriented run:

1. Identify the exact repo, package/application ID, branch, Play app, target track, and whether the checkout is dirty.
2. Read references/play-policy-baseline.md.
3. Re-open the linked official Google sources for any submission-sensitive requirement. Record the URL, observed requirement, and check time in assets/android-release-gate.template.md.
4. Treat current repo code and the live Play Console as source truth for the app. Treat the reference date as a baseline, not permanent policy.

Take the target-SDK default and enforcement dates from the baseline file, never from memory. Do not misstate an announced deadline as already enforced, and recheck every run: form-factor exceptions and dates differ.

Delivery Contract

Lock these before implementation:

• user and one core outcome;
• supported form factors, devices, locales, minimum SDK, and offline behavior;
• application ID, ownership, signing model, Play app/track, and release owner;
• data inventory, third-party SDKs, permissions, account model, deletion path, privacy policy owner, and Data Safety owner;
• monetization and entitlement source truth, or an explicit free-v1 decision;
• architecture and migration constraints;
• acceptance devices/API levels, tests, performance/accessibility targets, store artifacts, and release evidence;
• external mutations requiring confirmation: product creation, credential use, Play upload, track promotion, staged rollout, or production release.

Unknowns stay unknown. Never invent a package name, product ID, policy answer, privacy URL, customer claim, or Play Console state.

Production Pipeline

1. Validate the product: define the user outcome and evidence of demand. Treat keyword research as one input, not proof of product-market fit.
2. Verify policy: capture current target-SDK and form-factor rules, app access requirements, Data Safety scope, content rating, account deletion, billing policy, and any permission-specific declarations.
3. Design architecture and risk: use the smallest maintainable architecture that preserves unidirectional state, lifecycle safety, offline/error/loading states, test seams, and a least-data/least-permission posture.
4. Scaffold: native Kotlin + Jetpack Compose by default. Resolve current stable Android/Jetpack versions from official sources, lock them in a version catalog, and prove a debug build before feature work.
5. Build the core loop: implement one complete user outcome with real or deterministic demo data. Add history, saved state, sync, or accounts only when the product contract requires them.
6. Prove quality: unit, repository, ViewModel, Compose UI/instrumented, accessibility, and end-to-end core-loop tests as applicable; static analysis, release build, device/API matrix, baseline profile, and Macrobenchmark.
7. Add monetization safely: use Play Billing for covered digital goods, process pending purchases, verify and acknowledge purchases after entitlement handling, restore ownership, and keep secrets/server verification off-device.
8. Complete trust surfaces: privacy policy, Data Safety, SDK data behavior, permission rationale, in-app and web account deletion when accounts exist, content rating, ads declarations, app access instructions, and Play Integrity only where abuse risk justifies it.
9. Build store artifacts: truthful listing, icon/feature graphic, screenshots for every declared form factor, localization, support contact, release notes, and reviewer instructions.
10. Release through evidence gates: signed AAB and Play App Signing, internal/closed validation, pre-launch report, explicit confirmation before upload or promotion, staged production rollout, and post-release monitoring.

Read these before building:

• references/android-factory-pipeline.md: phase artifacts and release flow;
• references/architecture-and-quality.md: architecture, tests, accessibility, performance, and build checks;
• references/privacy-billing-integrity.md: privacy, Data Safety, account deletion, Billing, and Integrity controls;
• references/play-policy-baseline.md: dated official-policy baseline.