Skip to content
Winter Sale from $619, until 31st December 2026 Book now
Agentic coding workshops iOS + Android

Agentic Coding Workshop for React Native and Flutter Teams: One Codebase, Two Stores

Cross-platform teams get a lot out of coding agents because most of their code is shared TypeScript or Dart. The risks sit at the edges: generated native folders, platform permissions, dependency upgrades, over-the-air updates and two different store processes. A React Native and Flutter workshop sets up fast checks for the shared code and firm guardrails for everything native and release-related.

6 min read

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 ios and android folders, 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.

TopicReact Native / Expo trackFlutter track
Fast checks for the agentTypeScript compiler, ESLint, Jest with React Native Testing Libraryflutter analyze, dart format, flutter test
UI safety netComponent tests, end-to-end flows on a simulator or emulatorWidget tests and golden image tests
Native extensionsConfig plugins and native modulesPlugins and platform channels
BuildsEAS Build in the cloud or local Xcode and Gradle buildsflutter build ipa and flutter build appbundle, locally or in CI
Typical agent mistakeEditing generated native folders, mixing old and new architecture patternsPlatform-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:

  1. the agent reads the official upgrade notes and writes an upgrade plan first, listing packages that need new versions or replacements,
  2. a human approves the plan, especially for packages that are unmaintained or incompatible with the newer architecture,
  3. the agent upgrades in small steps, running the checks after each one,
  4. 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.

Workshop for your team?

Talk to an AI Code Engineer – free, 15 minutes, in English or German.

Book a call for free

Chat and hotline are open 24/7. Answers from our senior AI Code Engineers (real humans) usually take closer to 72 hours than 1 hour.