Read the plan before the slow build starts.

Mobile development constrains what an AI coding agent can check for itself: a simulator build is slower than a unit test, so the self-correction loop that makes agents reliable on the backend runs less often here. The recipes below cover React Native, Expo and Flutter, and the patterns that keep that loop short.

$59.99 once for 12 months of access. Nothing renews on its own. 30-day refund on a first purchase.

Pages picked for this work
4
Steps on the reading path
16
Questions in the free scorecard
25
By-role data last updated
2026-08-17

Pages: React Native recipes, Expo recipes, Flutter recipes, Mobile patterns.

One change, two ways to work.

One mobile feature, drawn two ways: five steps and a slow build.

  • Written by you
  • Read by you
  • Agent and checks

A build after each step

The third build tells you.

An agent that needs a simulator build to check itself does not iterate until it passes: you find out on the third build that step two was wrong.

  1. Build 1 You wait
  2. Build 2: step two is wrong You wait
  3. Build 3: you find out You wait

Plan first, build once

Read the plan, then build.

Reviewing five steps before a slow build starts costs less than discovering on the third build that step two was wrong.

Plan

plan.md

A named engineer accepts the plan before application code changes.

You write and read

One task for the agent

  • Types
  • Unit tests
  • Lint

Iterates on the fast checks until they pass, then runs the build.

Agent writes, checks read

Evidence

Screenshots and tests

From both platforms, so you check evidence instead of reading every line.

You read

The verification step gets expensive. An agent that can run a test suite in seconds will iterate until it passes; one that needs a simulator build will not, so the value moves toward the parts a fast check still covers — types, unit tests, lint. That makes the plan phase worth more here than almost anywhere else. Reviewing five steps before a slow build starts costs less than discovering on the third build that step two was wrong.

Drawing
One change, two ways to work.
Source
Drawn from the by-role text for mobile developers, last updated 2026-08-17; the plan line is from the build stage guide, the evidence line from the mobile patterns recipe.
Note
An illustration of the by-role data, not a measurement

The failures your tests do not catch.

Each recipe opens with the failure it exists to prevent. Here are 4, in the recipes’ own words, with the page that fixes them.

  1. The scene
    “Your FlatList stutters on a mid-range Android phone once it passes a few hundred rows. The release build crashes on a native module that the development build never loaded. The offline screen from last week’s demo drops writes when the network flaps.”

    The page that fixes it React Native recipesReact Native with Claude Code, Codex, and Cursor: offline-first state, FlashList v2, biometric gates, release-build debugging, and the gates that prove it.

    Open React Native recipes 2026-10-12

  2. The scene
    “A teammate adds react-native-vision-camera, Expo Go stops loading the app, and the agent keeps writing code for whichever setup it guessed. A week later an over-the-air (OTA) update reports success, yet no phone picks it up, because the update targets a runtime that no installed build has.”

    The page that fixes it Expo recipesExpo SDK 57 with Claude Code, Codex, and Cursor: Expo skills and MCP, Expo Router auth gates, a fingerprint-gated EAS pipeline, and safe OTA updates.

    Open Expo recipes 2026-10-12

  3. The scene
    “You ask for a provider and get a StateNotifierProvider, which Riverpod 3 moved to a legacy.dart import. You ask for a Dio retry interceptor, and a failing screen now fires dozens of requests, because Riverpod 3 also retries failing providers on its own.”

    The page that fixes it Flutter recipesFlutter with Claude Code, Codex, and Cursor: the official Dart and Flutter plugin, Riverpod 3 codegen, go_router, Dio, and a gate that checks every change.

    Open Flutter recipes 2026-10-12

  4. The scene
    “You ask for a swipeable card and get Gesture.Pan(), which react-native-gesture-handler 3 deprecates. You ask for a fast feed and get FlashList’s estimatedItemSize, a prop that FlashList 2 removed. The iOS simulator looks fine, and nobody opens the Android emulator.”

    The page that fixes it Mobile patterns12 copy-paste agent prompts for React Native and Flutter UI, pinned to current package majors, each with the device evidence that proves it works.

    Open Mobile patterns 2026-10-12

Scenes are the opening scenarios of the pages and are written as examples, not as reader reports. Quotations are trimmed. The pages are documentation pages and come with the Toolkit.

Your reading path, in the order it pays off.

From the 16 steps on the developer path, 5 picked for slow builds: the plan you read first and the fast checks that still run. The numbers are each step’s place in the full path, and each one says what you can show when it is done.

  1. Step 1 of 16 Free

    The Autonomy Ladder: Which Level Is Your Workflow At?

    Place your current workflow on the ladder, so every later step is a move up one rung.

    Done whenYou can name your level and the one habit that keeps you on it.

  2. Step 3 of 16 Toolkit

    AGENTS.md and CLAUDE.md — concise repository context

    The instructions file is the cheapest lever on output quality; write it before you scale use.

    Done whenA reviewed CLAUDE.md or AGENTS.md under 150 lines with the real test commands.

  3. Step 5 of 16 Toolkit

    The artifact chain

    Intent, spec and plan are what you review instead of every line the agent writes.

    Done whenOne change shipped from an accepted intent.md, spec.md and plan.md.

  4. Step 6 of 16 Toolkit

    Executable acceptance criteria: from story to failing test

    Acceptance criteria written as failing tests are the contract the agent works to.

    Done whenA story whose criteria exist as tests before the agent starts.

  5. Step 7 of 16 Toolkit

    Test: give the session a feedback loop

    A single-command feedback loop lets the agent prove its own work before you look.

    Done whenThe agent runs the loop and reports exit status on every task.

Steps and “done when” lines: the developer reading path, 16 steps and 2 further reading, last updated 2026-10-12. The ladder pages are free; every other step is marked.

Read the whole path

Where your mobile work sits on the ladder.

Dan Shapiro’s levels describe how much of the work you hand to an agent. Each row shows what one mobile screen looks like at a rung the scorecard can place you on.

Not sure which row is yours?

The AI Dev Score asks 25 questions in about 8 minutes, scores 6 sections and gives you a 30/60/90-day plan for the next rung. Free.

Take the AI Dev Score

No account, no card. An email only at the end, and only if you want the full playbook.

  1. 4

    The engineering team

    “leave for 12 hours, and check to see if the tests pass”

    One mobile screenYou write the spec and accept the plan, the agent works until types, unit tests and lint pass, and you read the evidence from both platforms. Authentication and payment code still gets a named reader.

    Where the toolkit points
  2. 3

    The developer

    “Your life is diffs.”

    One mobile screenThe agent writes the screen and you read the whole diff, then run the build yourself.

    The valley, levels 2 and 3
  3. 2

    The junior developer

    “feels like you are done. But you are not done”

    One mobile screenYou and the agent build the screen together, and each step waits for a simulator build.

  4. 1

    The coding intern

    “you offload specific, discrete tasks to your AI intern”

    One mobile screenYou hand over one widget or one function, and you paste the result into your own screen.

Level names and quotations: Dan Shapiro, “The Five Levels: from Spicy Autocomplete to the Dark Factory”, 2026-01-23 (opens in a new tab). The ladder runs from Level 0 to Level 5 and the scorecard places you on 1 to 4. The “One mobile screen” column is our illustration.

Your first week, planned.

  1. Day 1

    Generate your Setup Pack.

    Answer 9 questions about your stack and tools, including language, framework, package manager and test runner. Your agent runs INSTALL-PROMPT.md and checks each setting against what you have installed. About 20 minutes. The Setup Pack is included in the Toolkit.

  2. Days 2 to 5

    Hand over one real change.

    Pick one screen. Write intent.md and spec.md, have the agent draft plan.md and accept it before any build starts, then let it iterate on the fast checks and read the evidence.

  3. By day 30

    Decide with evidence.

    You have one change done the new way. If it did not change how you work, ask for a refund before day 30.

Buy the Toolkit

The Toolkit includes the guides, the Setup Pack and all eight books, for 12 months. $59.99 once for 12 months of access. Nothing renews on its own. 30-day refund on a first purchase.

Questions about this work.

Something else? Write to support@developertoolkit.ai.

Are there recipes for React Native, Expo and Flutter?

Yes — the cookbook covers all three, alongside the mobile-web patterns that overlap with them. They are linked above.

Why does plan mode matter more in mobile work?

Because verification is slow. An agent iterating against a fast test suite can afford to be wrong once; one waiting on a simulator build cannot, so reading the plan before the build starts is where the time is saved.

What do I read instead of the diff?

The evidence the change carries: the spec delta, the acceptance results, the strength of the oracle and runtime signals from a running build. A named person still reads the code for authentication, money, schema and migrations, changes to the tests themselves, and anything no check covers.

I only use one of the three tools.

That works. Where Claude Code, Codex and Cursor differ, the guides and recipes show a tab for each, so you read the one for your tool.

Read the plan. Then start the build.

Within the 30-day refund window, ship one screen this way on your own app.

$59.99 once for 12 months of access. Nothing renews on its own. 30-day refund on a first purchase.