How I Use Claude Code on React Native Projects, and Where I Don't

AI coding assistants write plausible React Native code at remarkable speed. That's the opportunity and the problem in one sentence. Plausible code that compiles, looks idiomatic and passes a quick glance can still use an API removed two versions ago, re-render a list on every keystroke, or quietly break on Android. The skill isn't getting an assistant to write code. It's knowing which work to give it, how to set it up so it can check itself, and how to review what comes back.

I use Claude Code and Cursor daily for code review, refactors and tests, and every change is reviewed by me before it's merged. This is the Claude Code React Native workflow I recommend: where the tool earns its keep, where I keep it away, how to set up a repository so it works well, and a checklist for reviewing what it writes.

Key takeaways

• Best uses: tests for existing code, exploring unfamiliar codebases, mechanical refactors and migrations, typing API responses and a second pass at code review.
• Keep it away from signing, credentials and secrets, store declarations, and unreviewed changes to payments or authentication.
• Give it feedback loops: type checking, linting, tests and expo-doctor let it catch its own mistakes before you do.
• A short CLAUDE.md with commands, conventions and a "never touch" list does more than long prompts.
• Review every line. Watch especially for outdated APIs, platform differences, hook dependencies and unnecessary new packages.

What Claude Code is, and how to install it

Claude Code is Anthropic's agentic coding tool: it reads your codebase, edits files, runs commands and works with your development tools. The same engine runs in the terminal, in VS Code (and Cursor) through an extension, in JetBrains IDEs, in a desktop app for macOS and Windows, on the web at claude.ai/code, and in the Claude app for iOS and Android, so you can start a long task at your desk and check on it from your phone.

Installing the terminal version takes one command:

# macOS, Linux and WSL
curl -fsSL https://claude.ai/install.sh | bash

# Windows PowerShell
irm https://claude.ai/install.ps1 | iex

Homebrew (brew install --cask claude-code) and WinGet (winget install Anthropic.ClaudeCode) work too. Then run claude inside your project folder and sign in. On native Windows, install Git for Windows so it can use a Bash shell.

Cost. Claude Code is included with paid Claude plans, or billed per token through an Anthropic Console account. Heavy agent use is where plan limits show up, so check Anthropic's current pricing against how your team will actually use it.

Other models. Claude Code is built for Anthropic's models, used directly or through Amazon Bedrock, Google Cloud or Microsoft Foundry. Organisations can route it through an LLM gateway for cost control and auditing, but Anthropic doesn't support pointing it at non-Claude models, which rules out setups built on Ollama or other local models.

Where it earns its keep

The pattern: tasks where correctness can be checked quickly and objectively, by a compiler, a test or a clear diff.

Where I don't use it, or use it carefully

• Signing, credentials and secrets. Certificates, keystores, .env files and store credentials stay out of the assistant's reach entirely.
• Store declarations. Privacy labels, Data safety forms and review notes must describe what the app actually does. That's a question of truth, not text generation.
• Payments and authentication logic without line-by-line review. Plausible-looking billing code that double-charges on a retry is the worst kind of bug.
• Native build failures without a feedback loop. Without the real error output, an assistant guesses at Gradle and CocoaPods fixes, and guesses compound.
• Visual polish. Spacing, motion and feel need eyes on a real device.
• Performance claims. "This is faster" means nothing without a profile before and after.

Set up the repository so it can check itself

Claude Code reads a CLAUDE.md file at the root of your project into every session. Keep it short and practical:

# Project notes for Claude

## Commands
- Type check: `npx tsc --noEmit`
- Lint: `npx eslint . --max-warnings 0`
- Tests: `npx jest`
- Dependency health: `npx expo-doctor`

## Conventions
- Expo Router; screens live in `app/`, shared UI in `components/`
- Server state with TanStack Query; no fetch calls inside components
- API responses are validated with Zod in `api/`

## Never
- Edit `ios/` or `android/` directly (we use prebuild and config plugins)
- Read or change `.env*` files, credentials or signing settings

If your repository already has an AGENTS.md for other coding agents, Claude Code can read that instead, so you don't need two copies. Then make the checks automatic. Claude Code's hooks can run a command after every file edit, such as a type check on the changed files, so mistakes surface while the assistant is still working. Permission settings can deny reads of secret files outright. For Expo projects, Expo's MCP server adds documentation search, EAS build and workflow tools, and (from SDK 54, with the expo-mcp package) local capabilities such as taking screenshots of the running app and tapping elements by testID.

The workflow: plan, small diffs, verify, review

1. Ask for a plan first for anything bigger than a small fix, and correct it before any code is written.
2. Constrain the scope: one feature or one migration step per session, with the files it may touch.
3. Make it run the checks: type check, lint and tests, and fix what fails.
4. Read every line of the diff as if a new team member wrote it.
5. Run the app on a real device, both platforms, for anything touching UI or native modules.
6. Commit in small steps, so any single change is easy to review and revert.

Reviewing AI-written React Native code: a checklist

• Outdated APIs. Models learn from older code. Watch for shouldShowAlert in expo-notifications handlers (deprecated in favour of shouldShowBanner and shouldShowList), estimatedItemSize on FlashList v2 (removed), new MMKV() where MMKV v4 uses createMMKV(), and Reanimated APIs from before version 4.
• Platform differences. Shadows, keyboard behaviour, permissions and back navigation differ between iOS and Android.
• Hook dependencies and re-renders, especially in list items and context providers.
• Loading, empty and error states, which generated code often skips.
• Accessibility: roles and labels on interactive elements.
• New dependencies. Question every added package; many duplicate something already installed or available in the platform.
• Secrets and logging. No keys in the bundle, no personal data in logs.

From the field: I use Claude Code and Cursor daily for code review, refactors and tests, and I review everything before it's merged, on top of a release path I own end to end: EAS Build, Submit and Update, Fastlane and GitHub Actions, phased rollouts and Sentry crash triage. The assistant speeds up the writing; the pipeline and the review are what keep the app shippable.

When Claude Code isn't working

• claude isn't found after installing: open a new terminal; if it's still missing, the install directory isn't on your PATH yet, and the troubleshooting guide has the fix for each shell.
• It's slow or losing the thread: long sessions carry a lot of context. Start a fresh session for each task, ask for a plan first, and keep tasks small enough to review.
• Tools or MCP servers are missing: run /mcp inside a session to see which servers connected and which failed.
• The VS Code extension does nothing: open it from the Command Palette ("Claude Code: Open in New Tab") and check that you're signed in.

Is it worth it?

Measure it like any other process change: cycle time from task to merged pull request, review comments per change, and bugs that reach production. Lines of code generated is not a useful number. If the review load rises faster than the time saved, narrow the tasks you give it.

FAQ

Can Claude Code build a React Native app?

It can scaffold screens, write components, tests and configuration, and run commands such as type checks and tests. Shipping a production app still needs human decisions and review: architecture, native builds, signing, store submission, payments, security and testing on real devices.

Is Claude Code good for React Native development?

It's strong at tests, refactors, migrations, typing API data and codebase exploration, especially with a clear CLAUDE.md and automatic checks. Watch for outdated APIs, platform-specific behaviour and unnecessary dependencies, and review every change before merging.

Should I use Claude Code or Cursor for React Native?

Both work well, and many developers use both: an editor-based assistant like Cursor for in-flow edits and completions, and a terminal agent like Claude Code for multi-file tasks, migrations and running checks. The setup, feedback loops and review habits matter more than the choice of tool.

Is AI-generated code safe to ship?

Only after the same review and testing you'd apply to any other code. Run type checks, linting and tests, read every line, test on real devices, and keep secrets, signing and payment logic under close human control.

Next steps

If you want help setting up AI-assisted development on a React Native codebase, with the guardrails that keep quality up, I can help your team get there. Get in touch, or see my services.

Sources

• Claude Code overview, Anthropic
• Manage Claude's memory (CLAUDE.md), Anthropic
• Hooks reference, Anthropic
• LLM gateways, Anthropic
• Expo MCP Server, Expo documentation
• Notifications, Expo documentation