app-store-compliance is a public GitHub repo, free for individuals and small companies, that turns App Store and Google Play rejection into a check you run before you submit. It holds 117 documented rejection patterns with fixes, a guard script that scans your iOS or Android project, 95 tracked regulatory deadlines, and a skill that makes an AI coding agent run the scan before any submit command. It gained roughly 540 GitHub stars in a single day this week, which is why it is trending. The core idea is simple: you find the risk while the fix is cheap, not after a reviewer has said no.
This post explains what is in the repo, how to run the guard in two commands, how it hooks into Claude Code and other agents, what its own README claims versus what you should verify, and where a code scan stops being useful. Everything below comes from the project's README on GitHub and the official store policies it points to. We did not run the guard against a real app for this article, so the behaviour described is the README's account of it.
What app-store-compliance is
The repo calls itself an enterprise reference and automated guard for mobile store review. It has three layers:
- A playbook. Markdown docs split by store and topic: an Apple rejection map, a Google Play rejection map, a pre-submission checklist for both stores, an appeal playbook, and routing by app type (subscriptions, social, kids, health, games, AI, VPN and others).
- Machine-readable data. A taxonomy of rejection patterns (the repo's description says 117), detection recipes, and a regulatory deadline database (95 tracked dates covering the EU AI Act, the Digital Services Act, US children's privacy rules and age laws).
- Automation. A guard shell script, a set of monitor scripts, and an agent skill with an
/app-store-auditcommand in some tools.
The README says every guideline number and statistic traces to a live Apple or Google source, and it ships a citation verifier (scripts/verify-citations.py) that checks about 300 links. One detail we found useful: the verifier fetches a deliberately bogus control page per host, because Apple serves a byte-identical news index for unknown article ids. An invented link would return HTTP 200 while being fabricated, and the control check catches that.
Why this is trending now
The README makes an argument about timing. AI coding tools let anyone build a mobile app in an afternoon, and the repo cites a rise in app releases in the first quarter of 2026 of about 60 percent year over year across both stores, and around 80 percent on iOS alone. It also cites new submissions growing roughly 30 percent to nearly 600,000 in a recent period, and credits AI-assisted coding, Claude Code among them, as the working theory behind the surge.
The stores, it says, did not loosen up. The README quotes figures that we have not independently checked:
- Apple reviewed about 7.77 million submissions in a recent year and rejected roughly 1.93 million, nearly one in four.
- Apple rejected more than 320,000 submissions for spam, copying or being misleading, removed over 17,000 for bait and switch, and stopped more than 37,000 potentially fraudulent apps.
- Google blocked more than 1.75 million Play submissions in 2025 for policy violations.
Treat those as the repo's claims. The primary sources are Apple's App Review Guidelines and Google's Play policy center; read them before you rely on any statistic. For context on how Apple's rules are shifting for AI-built apps, see our report on Apple's review guideline changes on nudify apps and the bait-and-switch rule.
Run it in two commands
You need git and bash. The README says nothing is installed and nothing in your app is changed.
git clone https://github.com/mjmirza/app-store-compliance ~/repositories/app-store-compliance
bash ~/repositories/app-store-compliance/agent-os/hooks/app-store-compliance-guard.sh "/path/to/your/app"
Point the path at the folder that holds your Xcode project or your Android app. A small project scans in about a second and a large one can take up to a minute. Findings print first, critical ones on top, each with the file and line that triggered it when there is one. The last line tells you where you stand:
| Last line | Meaning | What to do |
|---|---|---|
| BLOCKED | A critical rejection risk was found | Fix each critical line using the fix line under it, then rerun |
| CLEAR | No critical risk in your code | Do the account and listing checks in the checklist |
| NOT CHECKED | No iOS or Android project found, or the guard could not write its scan files | Point it at the right folder and check the temp folder is writable |
Managed Expo apps with no native folders still get their app config read for purpose strings, the privacy manifest and Android permissions, and the README suggests running npx expo prebuild to cover native code. The repo also lists coverage notes for Flutter, React Native, Capacitor, Ionic, Cordova, Unity, .NET MAUI, Tauri mobile and Kotlin Multiplatform apps.
The no-install option: one prompt
If you only want a one-time audit, the README gives a prompt you paste into any coding agent. It tells the agent to read the repo's docs and rejection-pattern data, audit your app against every Apple and Google rejection pattern, return a ranked findings table with the guideline and the fix, and list regulatory deadlines that fall within 90 days for your regions. It also says read only: do not modify the project and do not act on your GitHub account.
That last instruction is worth noticing. The prompt even asks the agent to never star or follow on your behalf. If you paste prompts like this, always read what they ask your agent to do first. Our guide to letting a coding agent drive real tools covers a similar rulebook approach on phones.
Hooking it into Claude Code, Codex and others
The more interesting mode is the always-on one. One command installs a rule, a hook and a skill so that your agent runs the guard before any submit command:
bash ~/repositories/app-store-compliance/scripts/install.sh --tool all
According to the README, --tool all installs into every supported tool it finds in your home folder. You can pass a single name instead. The supported list covers Claude Code, Codex CLI, Gemini CLI, OpenCode, Cursor, GitHub Copilot (CLI, VS Code, JetBrains and the cloud agent), Grok, Qwen Code, Kimi Code and Factory Droid.
A few practical notes from the README:
- Claude Code gets a hook, a skill and the
/app-store-auditcommand. Restart it after install. - Codex runs no new or changed hook until you approve it with
/hooks. - Gemini CLI hooks work from version 0.22; the skill needs 0.24 or later.
- Every tool other than Claude Code also needs python3.
- The Copilot cloud agent reads hooks only from your default branch, so you commit
.github/hooks.
The guard fires before submission commands such as fastlane, eas submit, gradle bundleRelease and xcrun altool. If it finds a critical risk, it stops the command and names the fix. The README's pitch is that your AI tool now refuses to help you ship a rejection. If you already run a mobile workflow with a coding agent, such as the setup in our Claude Code over SSH for iOS builds guide, this is a natural final gate before upload.
What the guard checks first
The repo says two checks cause most modern rejections, and it ranks them above everything else:
- A working demo account with a live backend. Reviewers need to get past your login. If the backend is down or the demo account is dead, the review fails.
- A privacy declaration that matches runtime behaviour. That includes every SDK in the app, not just your own code.
It adds a few other 2026 specifics, again as the README's claims:
- A missing privacy manifest (
PrivacyInfo.xcprivacy) is described as the top modern upload-time rejection, enforced since 2024. - Since late 2025, an app that sends personal data to an external AI without a consent modal naming the provider is rejected.
- Its docs cover age-rating and AI disclosure changes, the EU AI Act transparency rule for August 2026, the Digital Markets Act, and Android items such as developer verification, foreground service types, Play Integrity and Play Billing.
If your app calls an LLM API, the AI-consent point is the one to check today. Our coverage of Meta's Muse gadgets SDK and of Google's no-code Playground game maker shows how many new AI-built apps are about to hit review.
Monitors and the deadline checker
Besides the guard, the repo has monitor scripts. monitor.py compares your project against Apple's developer news feed across 25 tracked areas such as guidelines, privacy manifests, alternative payments and child safety. Other commands cover regulatory rules, Android and Play, generative AI policy, privacy, mobile security (17 requirements), release readiness, accessibility, and a regulatory timeline. deadline-checker.py lists open regulatory deadlines.
One honest caveat is printed in the README itself. The monitors other than monitor.py read built-in sample announcements unless you pass --live, and monitor-regulatory.py and monitor-security.py have no live feed. Each monitor prints a "Data." line that says whether its items are live or sample. So treat the sample output as a worked example of the migration tasks, not as news. That is the right way to build such a tool, and it is a reason to read the output line before you act on it.
Claimed versus verified
| Claim in the README | Status |
|---|---|
| 117 rejection patterns, 95 tracked deadlines | Stated in the repo description; the README also says 107 of 114 patterns have code-scan recipes and the rest are manual checks. We did not audit each entry |
| Guard blocks critical risks before a submit command | Described in the README; we did not run it on an app |
| A developer's app was approved first try after a one-time audit | A quote from a Reddit thread and a German approval mail, reported in the README; not independently confirmed |
| Apple and Google rejection statistics | Cited from outside sources; check the originals |
| Citations are machine-verified | The verifier script exists; you can run it yourself |
The README is also candid about limits. In the Reddit example, the audit flagged items it could not confirm, such as review notes and declared data usage inside App Store Connect. The repo says that is deliberate: an item that cannot be verified is surfaced rather than assumed clean. The accessibility audit has the same honesty. It is a static scan, it computes no contrast ratio for icons, and it does not check focus order in custom controls, so you still test with VoiceOver, TalkBack and Accessibility Inspector.
Limits and risks to weigh
- It is a static scan. It reads your files. It cannot see your App Store Connect state, your store listing text, your screenshots, or whether your demo backend is up on review day. The repo handles those through a checklist and a separate metadata audit script that you run on a pulled listing.
- A CLEAR result is not approval. Apple and Google make the final call, and rules change. The repo's own checklist covers account and program readiness that code cannot show.
- Hooks run code with your permissions. Installing a hook into your agent's settings changes what runs before commands. Read
install.shand the guard script before you run them, as with any third-party tool, and keep the guard in version control so you can see changes. The installer prints a block to paste by hand if it cannot editsettings.json. - The license is not MIT. The README says the repo uses the OpenRoots Agent License 2.3. It is free for individuals, nonprofits and companies at or below USD 20 million in annual revenue. Above that, a 0.5 percent royalty applies to product revenue over the threshold, capped at USD 250,000 a year. Training AI models on the repo needs a separate license. Earlier releases stay under MIT and CC BY 4.0. Read the license before using it at a larger company.
- A solo maintainer. The repo is run by one developer and asks for stars and follows in its README. That is normal for open source, but it means support and long-term maintenance are not guaranteed. The repo has 81 commits and a changelog, which suggests active work.
- Treat the numbers as claims. The surge and rejection statistics are cited, not measured by us.
For teams that let agents run real commands, a pre-submit hook is one small guard. The same logic applies to any agent that can ship code or touch a store account: keep a human in the loop for the final upload. For more on parallel agent workflows you may want to pair this with, see our guide to Orca, an open-source agent orchestrator with worktrees.
Who should use it
- Solo builders shipping AI-built apps. Run the two-command scan before every release. The cost is a minute; a rejection costs about a week by the README's estimate.
- Teams with a coding agent in the release path. Install the hook so the agent cannot run
eas submitorfastlaneon a critical finding. - Non-developers and founders. Open the pre-submission checklist and do its first two checks, the demo account and the privacy form. The README says this takes about five minutes.
- Anyone already rejected. Go to the appeal playbook before you resubmit, and match your rejection email to the named guideline.
If you build mobile apps with AI, consumer spending patterns matter too. Our look at the a16z top 100 consumer AI apps and who pays shows how crowded the category is, which makes a clean first submission more valuable.
Bottom line
app-store-compliance is a practical, open, well-documented gate for a problem that is getting worse as AI makes apps cheap to build and the stores stay strict. Run the two commands on your next release. Install the hook if an agent ships your builds. Then do the manual checklist for the parts a code scan cannot see, and keep checking Apple's and Google's own pages for the current rules. Follow @explainx_ai for more trending developer tools.
