Independent AI intelligence Two editions daily · ET
Fervor AI

Analysis · November 20, 2026 · repo

mjmirza/app-store-complianceai-skillsclaude-codeagent-harness

App Store Compliance Stops Your AI Agent From Shipping an App Store Rejection

The free scanner catches App Store and Google Play rejections before you submit. Run it by hand first, then decide whether your coding agent should carry it.

AI coding tools made it easy to build a phone app in an afternoon. They did nothing to make Apple's review faster.

So the bottleneck moved. The code arrives in hours, then the submission sits in review for days, comes back with a one-line rejection, and the loop starts again. The app-store-compliance README puts the cost plainly: "A rejection costs a week."

The repo, trending at number 12 on Trendshift this morning, makes an unusual bet about where to stop that loop. It ships the checklist, then goes a step further and installs a guard into your AI coding tool that blocks the upload command itself when it finds a critical rejection risk. Your agent types fastlane deliver (fastlane is the popular command-line tool for shipping iOS and Android builds), and the guard says no.

That is a smart place to put a check. It also has edges worth knowing before you wire it into every tool on your machine. The best way in is the one the README offers first and most people will skip: run the scan once, by hand, with nothing installed.

What the repo actually is

app-store-compliance is a playbook plus a scanner for iOS and Android apps, maintained by Mirza Iqbal (mjmirza). It has three parts:

  • Docs that map Apple's and Google Play's rejection rules to fixes, plus a pre-submission checklist for the things no code scan can see.
  • A rejection database, data/rejection-patterns.json, that the scanner reads. The README says 107 of its 114 patterns can be detected from code; the other seven are store listing and account checks you do by hand.
  • A guard script, app-store-compliance-guard.sh, that scans a project folder and prints a verdict line starting with BLOCKED, CLEAR or NOT CHECKED.

The latest release is 2.4.0, published November 15. The repo sits at a little over 2,000 stars as of this morning (GitHub's page and the shields.io badge disagree slightly).

The guard looks for the things that sink first submissions. The README singles out two: a demo account with a live backend for the reviewer, and a privacy declaration that matches what the app and every SDK inside it actually do. It also checks for a missing privacy manifest (the PrivacyInfo.xcprivacy file Apple requires to declare data collection), which the README calls "the top modern Apple upload rejection."

Step one: scan by hand, install nothing

The README's first instruction needs only git and bash. If you want the exact version reviewed here, add git -C ~/repositories/app-store-compliance checkout v2.4.0 after the clone.

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 Android app. The README says "nothing is installed and nothing in your app is changed," and that a small project scans in about a second, a large one in up to a minute.

Look for the verdict line near the end. It starts with one of three words, and a blocked or incomplete run adds a Next. line after it telling you what to do:

  • BLOCKED. A critical rejection risk was found. Each [CRITICAL] line has a fix. line under it. Fix, then run it again.
  • CLEAR. No critical risk in the code. Now open the checklist and do the account and listing checks, because the scan cannot see your App Store Connect settings.
  • NOT CHECKED. The guard found no iOS or Android project in that folder, or could not write its scan files. Run by hand, this exits with an error so you notice.

If you build with Expo, run npx expo prebuild first. The README says native code stays unchecked otherwise, though the guard still reads app.json for purpose strings and permissions.

The scan also runs the repo's deadline checker, which prints regulatory deadlines that fall inside a rolling 90-day window, so a privacy or age-rating rule that takes effect next month shows up before review does. If you want a written record, scripts/release-audit.py runs the guard plus a store-listing audit and writes a RELEASE-READINESS-REPORT.md into your project, with exit code 0 for clear, 2 for blocked and 3 for incomplete. That last code is the useful one for a CI job, because "incomplete" is a different answer from "fine."

That one-time scan is the whole value for most people. It takes two minutes, changes nothing, and you get to see what the tool thinks of your app before you trust it with anything else.

Step two: decide whether your agent should carry it

The second mode is the clever one. Run the installer and the guard becomes a hook, a small script your AI coding tool runs before it executes a shell command. In Claude Code that is a PreToolUse hook (one that fires before a tool runs) in ~/.claude/settings.json.

bash ~/repositories/app-store-compliance/scripts/install.sh --dry-run
bash ~/repositories/app-store-compliance/scripts/install.sh

Run the --dry-run line first. It prints what the installer would write and writes nothing. The README lists the targets: the guard into the tool's own folder, a skill (a folder of instructions and data your agent reads) into ~/.claude/skills/, and one hook entry in the tool's config, with a dated backup next to any file it changes. --tool all repeats this for every supported tool it finds, which is a dozen of them, including Codex, Gemini CLI, Cursor and Copilot.

After install, the guard watches for submit commands. Its pattern list (in the guard script) covers the usual ways a build leaves your machine: fastlane upload actions, Expo's eas submit, Apple's xcrun altool and notarytool upload tools, Gradle release bundles for Android, xcodebuild archive, Flutter release builds and more. When the agent types one of those and the scan finds a critical risk, the command stops and the agent sees why.

The installer also checks its own work. A run prints Install verified. only after it has fed a test submit command to the hook and watched it get blocked. (OpenCode on a machine without Node says Installed, but not fully verified. instead.) install.sh doctor repeats that test later, and install.sh uninstall removes the hook and keeps your other hooks.

Once installed in Claude Code, Gemini CLI or OpenCode, you also get an /app-store-audit slash command that runs the full audit on request.

Codex users get one extra step that is a feature, not a bug: Codex runs no new hook until you approve it with /hooks.

Four edges to know before you install

It guards the agent, not the upload

A hook sees the commands your AI tool runs. It does not see you. If you archive and upload from Xcode's Organizer window, or from Transporter, the hook is not in that path at all. The guard is a seatbelt for agent-driven releases, which is exactly where it is most useful, since an agent will happily run fastlane release at the end of a long task. It is not a gate on your App Store account.

"Not checked" passes as a hook

This is the detail I would want to know before trusting it. When the guard runs as a hook and cannot find a project, the README says the command goes through: "As a hook it lets the command through." The script does the same when it cannot create its scratch file in the temp folder. It writes a NOT CHECKED note and exits as a pass.

That is a defensible choice. A hook that blocked every unrelated command in a folder with no app in it would get uninstalled within a day. But it means a release run from the wrong directory, or a monorepo layout the guard does not recognize, sails through unscanned. The fix is cheap: keep running the hand scan as a deliberate step in your release checklist, and treat the hook as the backup.

The hook tells the agent how to get past it

When the guard blocks a submit, the message it hands back says to fix the findings "or set APP_STORE_GUARD_OK=1 to override." The script then lets the command through with a note that critical findings are present. An override is a sensible escape hatch for a human who has read the report. An agent racing to finish a task can read the same sentence. If you install the hook, add a line to your agent instructions (CLAUDE.md or its equivalent) saying it must never set that variable, and stop to ask you instead.

It is no longer MIT

The repo's license is the OpenRoots Agent License 2.3, not a standard open-source license. In practice, per the README:

  • Free for individuals, nonprofits, schools, government, and any company at or below USD 20 million in annual gross revenue (adjusted for inflation each January).
  • Above that, a royalty of 0.5% applies only to the revenue of the product that uses the playbook, and only to the part above the threshold, capped at USD 250,000 a year.
  • Training an AI model on the repo is not included at any tier and needs a separate license.
  • Copies must keep the attribution inside the package manifest, not only in a README.

Earlier versions stay under their old terms: everything published before August 24, 2026 remains MIT for code and CC BY 4.0 for content, according to the README. For a solo developer this changes nothing. For a company near the threshold, or one that redistributes tooling, it is a legal review item before the hook lands on a hundred laptops.

Honest limitations

A clean scan is not an approval. The guard reads code. It cannot see whether your developer account is active, whether you accepted the latest agreements, or what your App Store Connect privacy answers say. The README is upfront about this, and the agent install prompt tells the agent to walk the account checklist with you.

The success stories are anecdotes. The README shows two developers saying their apps passed on the first try after a scan. That is encouraging and it is not a measurement. Nobody has published a rejection rate with and without the tool.

The statistics are second-hand. The README's "why now" section cites figures like 1.93 million Apple rejections in a year and a surge in AI-built app submissions, sourced to TechCrunch and store policy pages. Treat them as the author's framing, and check the links before you repeat them.

It asks for a star. The paste-in agent prompt ends by having your agent print the repo and author links. To its credit, it also says "Never star, follow, fork, or watch on my behalf." Read any agent prompt before you paste it, this one included.

Global hooks are global. --tool all touches config in every AI tool it finds. The backups and uninstall make that reversible, but start with one tool you actually ship releases from.

Where this leaves you

The pattern here outlasts this one repo. Agents now run release commands, so the checks that used to live in a human's head have to live in front of the command instead. app-store-compliance is a good example of that idea done carefully: a verdict line every time, a self-test on install, a dry run, an uninstall.

Start where the README starts. Clone it, point the guard at your app, and read the last line. If it catches something real, you have saved a week. Then decide, on purpose, whether your agent should carry it.

Sources: app-store-compliance README and repo (reviewed at v2.4.0, November 15, 2026); guard script; LICENSE pointer, OpenRoots Agent License 2.3; release feed; Trendshift daily board, read about 07:15 ET on November 20, 2026.