Key takeaways
- Agents are strongest in shared TypeScript or Dart code and weakest at the native boundary – plan the guardrails there.
- In Expo projects with generated native folders, the agent changes app config and config plugins, never the generated ios and android folders.
- Framework and SDK upgrades are good agent tasks only with a written plan, one step at a time and tests on both platforms.
- Over-the-air updates do not replace store releases for native changes, and store rules still apply to what you ship over the air.
One codebase, two stores, three kinds of code
A React Native or Flutter repository contains three different kinds of code, and coding agents handle them very differently:
- Shared app code in TypeScript or Dart – screens, state, networking, business logic. Agents are productive here, especially with type checks and tests.
- Native code and configuration – the
iosandandroidfolders, Info.plist and AndroidManifest entries, Podfiles and Gradle files, native modules. Mistakes here break one platform silently. - Build and release configuration – signing, bundle identifiers and application IDs, version numbers, build profiles, store metadata. Mistakes here block releases.
The workshop gives each kind its own rules. Most of the day is spent making the first kind fast and safe, and drawing a firm line around the other two.
Two tracks in one workshop
Mixed groups split into tracks for the hands-on parts. The concepts match; the commands and pitfalls differ.
| Topic | React Native / Expo track | Flutter track |
|---|---|---|
| Fast checks for the agent | TypeScript compiler, ESLint, Jest with React Native Testing Library | flutter analyze, dart format, flutter test |
| UI safety net | Component tests, end-to-end flows on a simulator or emulator | Widget tests and golden image tests |
| Native extensions | Config plugins and native modules | Plugins and platform channels |
| Builds | EAS Build in the cloud or local Xcode and Gradle builds | flutter build ipa and flutter build appbundle, locally or in CI |
| Typical agent mistake | Editing generated native folders, mixing old and new architecture patterns | Platform-specific code without checks, outdated widget APIs |
Stack-specific details are in Claude Code for React Native and Expo and Codex for Flutter. Teams with a web app wrapped for the stores may also want Capacitor apps with coding agents.
Talk to an AI Code Engineer about your agentic coding workshop.
In a free call we look at your team, your codebase and your goals and suggest a workshop format that fits – remote or on-site, in English or German.
The native boundary: where agents need guardrails
Expo with generated native folders
Many Expo projects generate their ios and android folders from the app config during prebuild. An agent that "fixes" something directly in those folders creates a change that disappears with the next prebuild. The rule in the instruction file: native changes go through the app config or a config plugin, and the generated folders are not edited by hand.
Bare React Native and Flutter
Here the native folders are real source code. The agent may change them, but every change to permissions, entitlements, manifest entries, minimum OS versions or build settings is flagged for human review – because each can change what Apple and Google ask about the app.
Platform permissions
Adding a camera or location feature in shared code usually means permission texts on iOS and manifest entries on Android. Agents often get one platform right and forget the other. The workshop adds a short "platform checklist" to the instructions that the agent must complete for any feature touching device capabilities.
Upgrades: the cross-platform minefield
React Native, Expo SDK and Flutter upgrades touch the framework, native build tooling and dozens of packages at once. They look like perfect agent work – mechanical, well documented – and often go badly when handed over in one prompt.
What works, and what we practise in the upgrade lab:
- the agent reads the official upgrade notes and writes an upgrade plan first, listing packages that need new versions or replacements,
- a human approves the plan, especially for packages that are unmaintained or incompatible with the newer architecture,
- the agent upgrades in small steps, running the checks after each one,
- both platforms are built and smoke-tested on devices before the branch is merged.
Over-the-air updates and the stores
React Native teams using Expo can ship JavaScript changes over the air with EAS Update, and similar approaches exist elsewhere. Agents make it tempting to push fixes quickly. Two rules belong in the team agreement:
- Native changes need a store release. New native modules, permissions or SDK versions require a new build and review. The agent must know which changes qualify and say so in the pull request.
- Store rules still apply. What you ship over the air must not change the app's primary purpose or add features that would need review. Check the current App Store and Google Play policies before relying on over-the-air updates for anything substantial.
Releasing to both stores from one repository
Shared code does not mean a shared release process. iOS builds need Xcode on macOS – your own Mac, a macOS CI runner or a cloud build service such as EAS Build. Android builds produce an App Bundle signed with your upload key for Play App Signing. Each store has its own listing, privacy declarations, testing tracks and review.
The workshop ends with a release map for your app: which steps the agent automates (version bumps, changelogs, build lanes), which steps need a person (signing assets, store forms, review replies). The full approach is in shipping iOS and Android with one agentic workflow. Teams starting from a prompt-to-app builder can compare Rork vs. Bolt for Expo apps.
Our AI Code Engineers release cross-platform apps to both stores every week and run this workshop remote or on-site, in English or German. If you would rather hand the store side to us entirely, the order wizard starts the process.
Cross-platform guardrails to set up
- Fast type checks, linting and unit tests the agent runs after every change.
- A clear rule on generated native folders and where native changes belong.
- A platform checklist for features that need permissions or device capabilities.
- Upgrade work done from a written plan, in small steps, with tests on both platforms.
- A team rule on which changes may ship over the air and which need a store release.
- Signing assets and store credentials kept out of the repository and agent sessions.
Frequently asked questions
Are coding agents better at React Native or at Flutter?
Both work well for shared app code. Results depend far more on type checks, tests and clear instructions than on the framework. The bigger differences show up at the native boundary and in upgrades.
Can we build the iOS version without a Mac?
The build itself needs macOS, but it does not have to be your machine: cloud build services and macOS CI runners can build and sign the app. Testing on a real iPhone is still strongly recommended before release.
Should the agent edit our ios and android folders?
If those folders are generated from config, no – changes go through config and plugins. If they are real source code, yes, but with every permission, entitlement and build setting change reviewed by a person.
Do you offer native-only workshops too?
Yes: the iOS workshop and the Android workshop go deeper into Xcode and Gradle.
Free, 15 minutes, no obligation
Plan your agentic coding workshop with us.
Our AI Code Engineers run hands-on workshops on Claude Code, OpenAI Codex, Cursor and AI app builders – and ship apps to the App Store and Google Play every week. Tell us about your team.
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.