Key takeaways
- The cheapest review happens before the code: approve the agent’s plan and keep tasks small enough to produce reviewable diffs.
- Automate everything mechanical – builds on both platforms, tests, linting, secret scanning and an AI first-pass review.
- Human review focuses on a short list of high-risk areas where agent mistakes look plausible but cost the most.
- An agent never merges its own pull request into the release branch.
The volume problem
A developer working with an agent can produce several pull requests a day, each touching dozens of files. In a team of two or three, nobody has time to read all of that with the attention a hand-crafted change used to get. Teams react in one of two ways: they rubber-stamp, or they become the bottleneck. Neither works for long.
The fix is to move effort to where it pays off. Some checks belong before the code is generated, some belong to machines, and a few belong to a person who knows the app. The layers below add up to a process that two people can sustain.
Layer 1: Review the plan, not just the diff
Most agents can plan before they edit – Claude Code has a plan mode, Cline separates Plan and Act, and every agent will describe its approach if asked. Reading a ten-line plan takes a minute and catches the expensive mistakes: the wrong library, a new table where an existing one would do, a change to the auth flow nobody asked for.
Two rules make the later review easier:
- One task, one pull request. "Add password reset" is a task. "Improve the login experience" is a week of diffs nobody can review.
- Acceptance criteria in the task. If the brief says what done looks like, the reviewer can check against it instead of reverse-engineering intent.
If a diff grows beyond what you can review in one sitting, ask the agent to split it into a stack of smaller pull requests. It is good at that.
Talk to an AI Code Engineer about shipping your app to the App Store and Google Play.
In a free call we look at what you built, tell you honestly what stands between it and an approved release – and whether you need us at all.
Layer 2: Gates that run without you
Every pull request should pass the same automated checks before a person looks at it:
- a build for both platforms – an agent fixing an Android bug can break the iOS build,
- unit and UI tests, type checks and linters,
- secret scanning and a dependency diff that lists added packages,
- an AI first-pass review: Codex code review, Cursor's Bugbot, Copilot code review or a headless agent in your CI.
The AI reviewer is useful for catching obvious bugs, missing null checks and inconsistent naming. Treat its comments as input, not approval – it shares many blind spots with the agent that produced the code. Our playbook on GitHub Actions for mobile CI shows how to set up these gates, including macOS runners for the iOS build.
Layer 3: Where human attention goes
With the mechanical part covered, a reviewer can concentrate on the patterns that agents produce and that look fine at a glance:
| Look at | What goes wrong |
|---|---|
| Changed or deleted tests | The agent made a failing test pass by weakening the assertion, mocking the unit under test or skipping it |
| Error handling | Broad try/catch blocks that swallow errors and return empty data, so failures become silent |
| New dependencies | A package for something the platform already does, an abandoned library, or a name that does not exist as described |
| Authorization | Checks only in the UI, user IDs taken from the request, database rules loosened to make a query work |
| Migrations | Destructive schema changes without a migration path for existing users' data |
| Protected files | Entitlements, Info.plist permission texts, Android manifest, privacy manifest, signing and CI config |
| Scope | Features nobody asked for – they become undocumented functionality in review |
| Duplication | A new helper next to an existing one that does the same thing |
Unrequested features deserve special attention in mobile apps: App Review rejects functionality the review notes don't describe. Our post on Guideline 2.3.1 and hidden features in AI-built apps explains why.
How to read an agent’s diff
Reading order matters more with generated code, because it is consistent in style and easy to skim past. A sequence that works:
- Tests first. Do they test the behavior from the task, and would they fail without the change?
- Interfaces next. New endpoints, function signatures, database columns, navigation routes.
- Implementation last, starting with the files in the high-risk table above.
- Run it. Pull the branch onto a device or simulator for anything users see. Screenshots or a screen recording attached by the agent help, but they do not replace a tap-through.
When something looks odd, ask the agent in the pull request why it chose that approach. A coherent answer is reassuring; a confident answer that contradicts the code is a sign to look deeper.
Sizing the process to your team
| Team | Process |
|---|---|
| Solo developer | Plan review, CI gates, AI first-pass reviewer, then your own review the next morning with fresh eyes. Protected files always reviewed line by line. |
| Two to five people | As above, plus one human approval per pull request and CODEOWNERS rules that require a specific reviewer for auth, payments, signing and store-related files. |
| Larger or regulated teams | Two approvals for high-risk paths, documented review criteria and periodic audits of merged changes. |
In all cases: the agent may open pull requests and push fixes to them, but merging into the release branch is a human decision.
Turn review findings into agent rules
Every finding you see twice belongs in the agent's instruction file: "never weaken a test to make it pass – explain why it fails instead", "no new dependency without asking". Over a few weeks, the same mistakes stop appearing and reviews get shorter. Our article on CLAUDE.md and AGENTS.md for mobile projects shows where those rules go, and the AI code review workshop trains a team on this process with its own pull requests.
Review checklist for agent pull requests
- The plan was reviewed before code was generated.
- The pull request covers one task with acceptance criteria.
- Both platforms build; tests, linters and type checks pass.
- Secret scan clean; every new dependency is justified.
- No test was weakened, skipped or rewritten to pass.
- Authorization is enforced on the server, not only in the UI.
- Changes to entitlements, manifests, permission texts, privacy and signing files reviewed line by line.
- No unrequested features; anything user-visible was tried on a device.
- A human merged it.
Frequently asked questions
Can an AI reviewer replace human review?
No, but it reduces the work. Use it to catch mechanical issues early, and keep human review for intent, risk and the areas listed above.
How big should an agent’s pull request be?
Small enough that one person can review it carefully in one sitting. If it is larger, ask the agent to split it into a stack of smaller pull requests with one purpose each.
Should agent-generated code be labelled?
It helps reviewers to know which pull requests came from an agent and which session or task produced them. Many teams use a label or a line in the description; the review standard is the same either way.
Can you help us set up a review process?
Yes. Book a free call and an AI Code Engineer looks at your repository, CI and team size and suggests a process – or trains your team in a hands-on workshop.
Free, 15 minutes, no obligation
Get your app from agent output to approved release.
Our AI Code Engineers take apps built with Claude Code, Codex, Cursor, Lovable, Base44 and co. through signing, CI/CD, store listings and review – in your own developer accounts.
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.