React Native Best Practices

CallstackOfficialPublished by Callstack

Skill
Guidelines
Software development
MIT
No issues found

From the author

Provides React Native performance optimization guidelines for FPS, TTI, bundle size, memory leaks, re-renders, and animations. Applies to tasks involving Hermes optimization, JS thread blocking, bridge overhead, FlashList, native modules, or debugging jank and frame drops.

— the description by Callstack

AutoGineer summary

Written by AutoGineer from the skill’s own files, not by the author

This skill provides a structured approach to optimizing React Native applications. It focuses on critical performance metrics including FPS, Time to Interactive (TTI), bundle size, and memory management. The guide emphasizes a data-driven workflow: Measure, Optimize, Re-measure, and Validate, ensuring that performance improvements are based on actual profiling data rather than assumptions. It covers both JavaScript-level optimizations and native-level configurations, providing actionable strategies for common bottlenecks like list rendering, re-renders, and heavy native modules.

What it does

Provides a standardized performance measurement and optimization workflow
Offers specific guidance for improving FPS and reducing UI re-renders
Details techniques for analyzing and reducing JavaScript bundle sizes
Outlines strategies for optimizing TTI and native module performance
Includes best practices for memory leak detection and management
Provides a mapping of common performance problems to specific diagnostic and fix strategies

When to use it

When debugging janky UI, frame drops, or slow animations
When investigating memory leaks in JS or native code
When optimizing app startup time and TTI
When attempting to reduce the final application bundle size
When profiling and tuning native modules or Turbo Modules
During code reviews to ensure performance-conscious implementation

Advantages

Promotes a rigorous, evidence-based approach to performance tuning
Covers the full stack from React components to native bridge and bundle configuration
Provides clear, priority-ordered guidelines for triage
Includes specific diagnostic commands for profiling and bundle analysis
Helps avoid common pitfalls like premature optimization or incorrect dependency usage

Usage examples

“My React Native app is dropping frames during list scrolling. How should I investigate?”: The agent will guide you to use the FPS and re-render profiling workflow, suggesting the use of react-devtools to identify slow components and recommending the replacement of ScrollView with optimized alternatives like FlashList.
“How can I reduce the size of my React Native iOS bundle?”: The agent will provide steps to analyze the bundle using source-map-explorer, identify heavy dependencies, and apply optimizations such as avoiding barrel imports and enabling native code shrinking.

Install

1 of its files are not mirrored here, so install it from its source:
https://github.com/callstackincubator/agent-skills/tree/59e9d17446a248b21d86f078fcd0bd2d36db1ca4/skills/react-native-best-practices

Documentation by Callstack

React Native Best Practices

Overview

Performance optimization guide for React Native applications, covering JavaScript/React, Native (iOS/Android), and bundling optimizations. Based on Callstack's "Ultimate Guide to React Native Optimization".

When to Apply

Reference these guidelines when:

Debugging slow/janky UI or animations
Investigating memory leaks (JS or native)
Optimizing app startup time (TTI)
Reducing bundle or app size
Writing native modules (Turbo Modules)
Profiling React Native performance
Reviewing React Native code for performance

Security Notes

Treat shell commands in these references as local developer operations. Review them before running, prefer version-pinned tooling, and avoid piping remote scripts directly to a shell.
Treat third-party libraries and plugins as dependencies that still require normal supply-chain controls: pin versions, verify provenance, and update through your standard review process.
Treat remote chunk loading as first-party artifact delivery only. Prefer app-bundled chunks or signed CI release manifests; hosted chunks must come from trusted HTTPS origins you control and be pinned to the current app release.

Priority-Ordered Guidelines

Priority	Category	Impact	Prefix
1	FPS & Re-renders	CRITICAL	`js-*`
2	Bundle Size	CRITICAL	`bundle-*`
3	TTI Optimization	HIGH	`native-`, `bundle-`
4	Native Performance	HIGH	`native-*`
5	Memory Management	MEDIUM-HIGH	`js-`, `native-`
6	Animations	MEDIUM	`js-*`

Impact labels are triage hints: CRITICAL first, HIGH next, MEDIUM when evidence points there.

Quick Reference

Optimization Workflow

Follow this cycle for any performance issue: Measure → Optimize → Re-measure → Validate

Measure: Capture baseline metrics before changes. For runtime issues, prefer commit timeline, re-render counts, slow components, heaviest-commit breakdown, and startup/TTI when available. Component tree depth or count are optional context, not substitutes. Do not recommend memoization, atomic state, or compiler changes without a measured render or FPS problem.
Optimize: Apply the targeted fix from the relevant reference
Re-measure: Run the same measurement to get updated metrics
Validate: Confirm improvement (e.g., FPS 45→60, TTI 3.2s→1.8s, bundle 2.1MB→1.6MB)

If metrics did not improve, revert and try the next suggested fix.

Review Guardrails

Check library versions before suggesting API-specific fixes. Example: FlashList v2 deprecates estimatedItemSize, so do not flag it as missing there.
Do not suggest useMemo or useCallback dependency changes unless behavior is demonstrably incorrect or profiling shows wasted work tied to that value.
Do not report stale closures speculatively. Show the stale read path, a repro, or profiler evidence before calling it out.
When profiling a flow, measure the target interaction itself. Do not treat component tree depth or component count as the main performance evidence.

Critical: FPS & Re-renders

Profile first:

agent-device react-devtools status
agent-device react-devtools wait --connected
agent-device react-devtools profile start
agent-device react-devtools profile stop
agent-device react-devtools profile slow --limit 5
agent-device react-devtools profile rerenders --limit 5
agent-device react-devtools profile timeline --limit 20

Drive the target interaction with normal agent-device commands between profile start and profile stop.

Manual fallback when agent-device is unavailable: open React Native DevTools from Metro (j) or the Dev Menu, use the Profiler tab, and record the same interaction.

For release-build React component profiling, connect @callstack/inspector first so React DevTools can attach to the release app, then run the agent-device react-devtools flow above.

Common fixes:

Replace ScrollView with FlatList/FlashList/Legend List for long lists
After profiling shows cascading re-renders, use React Compiler for automatic memoization
After profiling shows broad store/context updates, use atomic state (Jotai/Zustand) to reduce re-renders
Use useDeferredValue for expensive computations

Critical: Bundle Size

Analyze bundle:

npx react-native bundle \
  --entry-file index.js \
  --bundle-output output.js \
  --platform ios \
  --sourcemap-output output.js.map \
  --dev false --minify true

npx source-map-explorer output.js --no-border-checks

Verify improvement after optimization:

# Record baseline size before changes
ls -lh output.js  # e.g., Before: 2.1 MB

# After applying fixes, re-bundle and compare
npx react-native bundle --entry-file index.js --bundle-output output.js \
  --platform ios --dev false --minify true
ls -lh output.js  # e.g., After: 1.6 MB  (24% reduction)

Common fixes:

Avoid barrel imports (import directly from source)
Remove unnecessary Intl polyfills only after checking Hermes API and method coverage
Evaluate tree shaking (Expo SDK 52+ experimental unused import/export removal, or Re.Pack only if already configured)
Enable R8 for Android native code shrinking

High: TTI Optimization

Measure TTI:

Use react-native-performance for markers
Only measure cold starts (exclude warm/hot/prewarm)

Common fixes:

For React Native 0.78 and earlier, disable Android JS bundle compression to enable Hermes mmap
Use native navigation (react-native-screens)
Preload commonly-used expensive screens before navigating to them

High: Native Performance

Profile native:

iOS: Xcode Instruments → Time Profiler
Android: Android Studio → CPU Profiler

Common fixes:

Use background threads for heavy native work
Prefer async over sync Turbo Module methods
Use C++ for cross-platform performance-critical code

References

Full documentation with code examples in references/:

JavaScript/React (`js-*`)

File	Impact	Description
js-lists-flatlist-flashlist.md	CRITICAL	Replace ScrollView with virtualized lists
js-profile-react.md	MEDIUM	`agent-device react-devtools` profiling
js-measure-fps.md	HIGH	FPS monitoring and measurement
js-memory-leaks.md	MEDIUM	JS memory leak hunting
js-atomic-state.md	HIGH	Jotai/Zustand patterns
js-concurrent-react.md	HIGH	useDeferredValue, useTransition
js-react-compiler.md	HIGH	Automatic memoization
js-animations-reanimated.md	MEDIUM	Reanimated worklets
js-bottomsheet.md	HIGH	Bottom sheet optimization
js-uncontrolled-components.md	HIGH	TextInput optimization

Native (`native-*`)

File	Impact	Description
native-turbo-modules.md	HIGH	Building fast native modules
native-sdks-over-polyfills.md	HIGH	Native vs JS libraries
native-measure-tti.md	HIGH	TTI measurement setup
native-threading-model.md	HIGH	Turbo Module threads
native-profiling.md	MEDIUM	Xcode/Android Studio profiling
native-platform-setup.md	MEDIUM	iOS/Android tooling guide
native-view-flattening.md	MEDIUM	View hierarchy debugging
native-memory-patterns.md	MEDIUM	C++/Swift/Kotlin memory
native-memory-leaks.md	MEDIUM	Native memory leak hunting
native-android-16kb-alignment.md	CRITICAL	Third-party library alignment for Google Play

Bundling (`bundle-*`)

File	Impact	Description
bundle-barrel-exports.md	CRITICAL	Avoid barrel imports
bundle-analyze-js.md	CRITICAL	JS bundle visualization
bundle-tree-shaking.md	HIGH	Dead code elimination
bundle-analyze-app.md	HIGH	App size analysis
bundle-r8-android.md	HIGH	Android code shrinking
bundle-hermes-mmap.md	HIGH	Disable bundle compression
bundle-native-assets.md	HIGH	Asset catalog setup
bundle-library-size.md	MEDIUM	Evaluate dependencies
bundle-code-splitting.md	MEDIUM	Remote chunk loading safeguards

Problem → Skill Mapping

Problem	Start With
App feels slow/janky	js-measure-fps.md → js-profile-react.md
Too many re-renders	js-profile-react.md → js-react-compiler.md
Slow startup (TTI)	native-measure-tti.md → bundle-analyze-js.md
Large app size	bundle-analyze-app.md → bundle-r8-android.md
Memory growing	js-memory-leaks.md or native-memory-leaks.md
Animation drops frames	js-animations-reanimated.md
Bottom sheet jank/re-renders	js-bottomsheet.md → js-animations-reanimated.md
List scroll jank	js-lists-flatlist-flashlist.md
TextInput lag	js-uncontrolled-components.md
Native module slow	native-turbo-modules.md → native-threading-model.md
Native library alignment issue	native-android-16kb-alignment.md

Attribution

Based on "The Ultimate Guide to React Native Optimization" by Callstack.

Files

ATTRIBUTION.mdAdded by AutoGineer873 B
LICENSELicence file added by AutoGineer1.1 KiB
POWER.md8.1 KiB
SKILL.md12.1 KiB
agents/openai.yaml227 B
references/bundle-analyze-app.md5.3 KiB
references/bundle-analyze-js.md6.9 KiB
references/bundle-barrel-exports.md5.3 KiB
references/bundle-code-splitting.md7.4 KiB
references/bundle-hermes-mmap.md4.0 KiB
references/bundle-library-size.md4.1 KiB
references/bundle-native-assets.md4.9 KiB
references/bundle-r8-android.md5.2 KiB
references/bundle-tree-shaking.md5.6 KiB
references/images/bundle-treemap-source-map-explorer.png651.8 KiB
references/images/controlled-textinput-pingpong.png124.2 KiB
references/images/devtools-flamegraph.png508.5 KiB
references/images/emerge-xray-ios.png429.4 KiB
references/images/expo-atlas-treemap.png604.4 KiB
references/images/flashlight-flatlist-vs-flashlist.png305.9 KiB
references/images/fps-drop-graph.png148.9 KiB
references/images/memory-heap-snapshot.png300.8 KiB
references/images/tti-warm-start-diagram.png124.3 KiB
references/images/view-hierarchy-flattening.png(opens on GitHub)Not mirrored: opens on GitHub2.5 MiB
references/images/xcode-instruments-templates.png398.8 KiB
references/images/xcode-thread-view.png174.3 KiB
references/js-animations-reanimated.md7.8 KiB
references/js-atomic-state.md5.1 KiB
references/js-bottomsheet.md11.9 KiB
references/js-concurrent-react.md6.5 KiB
references/js-lists-flatlist-flashlist.md5.9 KiB
references/js-measure-fps.md5.2 KiB
references/js-memory-leaks.md5.2 KiB
references/js-profile-react.md5.7 KiB
references/js-react-compiler.md7.2 KiB
references/js-uncontrolled-components.md5.4 KiB
references/native-android-16kb-alignment.md3.7 KiB
references/native-measure-tti.md6.4 KiB
references/native-memory-leaks.md5.5 KiB
references/native-memory-patterns.md5.8 KiB
references/native-platform-setup.md3.7 KiB
references/native-profiling.md4.3 KiB
references/native-sdks-over-polyfills.md6.1 KiB
references/native-threading-model.md6.7 KiB
references/native-turbo-modules.md5.5 KiB
references/native-view-flattening.md5.1 KiB

references/js-lists-flatlist-flashlist.md

title: Higher-Order Lists impact: CRITICAL tags: lists, flatlist, flashlist, legend-list, scrollview, virtualization

Skill: Higher-Order Lists

Replace ScrollView with FlatList, FlashList, or Legend List for performant large list rendering.

Quick Pattern

Incorrect:

<ScrollView>
  {items.map((item) => <Item key={item.id} {...item} />)}
</ScrollView>

Correct:

<FlashList
  data={items}
  keyExtractor={(item) => item.id}
  renderItem={({ item }) => <Item {...item} />}
  // FlashList v1 only: add estimatedItemSize.
  // FlashList v2+: do not add estimated sizing props.
/>

When to Use

Rendering enough items that eager mounting affects FPS, memory, or startup
List scrolling is choppy or laggy
App freezes when loading list data
Memory usage spikes with long lists

Prerequisites

@shopify/flash-list for FlashList on React Native New Architecture
@legendapp/list for a JS/TypeScript list option without native dependencies
Understanding of list virtualization

Version Guardrail

FlashList v1: estimatedItemSize is part of the optimization guidance.
FlashList v2 and newer: estimatedItemSize, estimatedListSize, and estimatedFirstItemOffset are deprecated and no longer used. Do not flag them as missing.
Before suggesting a FlashList fix, confirm the installed major version and tailor the advice. See FlashList v2 changes.

Step-by-Step Instructions

1. Identify the Problem

Image: FPS Drop Graph

// BAD: ScrollView renders ALL items at once
const BadList = ({ items }) => (
  <ScrollView>
    {items.map((item) => (
      <View key={item.id}>
        <Text>{item.title}</Text>
      </View>
    ))}
  </ScrollView>
);

Large eager lists mount every row immediately, increasing JS work, native view count, and memory before the user can interact.

2. Replace with FlatList

import { FlatList } from 'react-native';

const BetterList = ({ items }) => {
  const renderItem = ({ item }) => (
    <View>
      <Text>{item.title}</Text>
    </View>
  );
  
  return (
    <FlatList
      data={items}
      renderItem={renderItem}
      keyExtractor={(item) => item.id}
    />
  );
};

FlatList only renders visible items + buffer (windowing).

3. Optimize FlatList with getItemLayout

For fixed-height items, skip layout measurement:

const ITEM_HEIGHT = 50;

const OptimizedList = ({ items }) => {
  const renderItem = ({ item }) => (
    <View style={{ height: ITEM_HEIGHT }}>
      <Text>{item.title}</Text>
    </View>
  );
  
  const getItemLayout = (_, index) => ({
    length: ITEM_HEIGHT,
    offset: ITEM_HEIGHT * index,
    index,
  });
  
  return (
    <FlatList
      data={items}
      renderItem={renderItem}
      keyExtractor={(item) => item.id}
      getItemLayout={getItemLayout}
    />
  );
};

4. Upgrade to FlashList

npm install @shopify/flash-list

import { FlashList } from '@shopify/flash-list';

const BestList = ({ items }) => {
  const renderItem = ({ item }) => (
    <View style={{ height: 50 }}>
      <Text>{item.title}</Text>
    </View>
  );
  
  return (
    <FlashList
      data={items}
      renderItem={renderItem}
      keyExtractor={(item) => item.id}
    />
  );
};

For FlashList v1, add estimatedItemSize with a realistic average item height. FlashList v2 requires React Native New Architecture and no longer needs size estimates; it computes sizing automatically. For old architecture apps, use FlashList v1 docs or evaluate Legend List.

FlashList advantages:

Recycles views instead of creating new ones
Often improves memory and scroll smoothness for large, complex lists
Supports item-type-aware recycling with getItemType

5. Evaluate Legend List

Legend List is a JS/TypeScript list alternative with no native dependency. It supports dynamic item sizes, bidirectional infinite scrolling, chat-friendly bottom alignment, and optional recycling.

Enable recycleItems for long lists after confirming item components do not keep item-specific local state or side effects.

Code Examples

Mixed Item Types

<FlashList
  data={items}
  renderItem={({ item }) => {
    if (item.type === 'header') return <Header {...item} />;
    if (item.type === 'product') return <Product {...item} />;
    return <DefaultItem {...item} />;
  }}
  getItemType={(item) => item.type}  // Helps recycling
/>

If the project is still on FlashList v1, keep estimatedItemSize alongside getItemType.

FlatList Optimizations (if not using FlashList)

<FlatList
  data={items}
  renderItem={renderItem}
  // Performance props
  removeClippedSubviews={true}
  maxToRenderPerBatch={10}
  updateCellsBatchingPeriod={50}
  initialNumToRender={10}
  windowSize={5}
  // Avoid re-renders
  keyExtractor={(item) => item.id}
  extraData={selectedId}  // Only when selection changes
/>

Decision Matrix

Scenario	Recommendation
Small static content	ScrollView OK
Measured eager-mount or scroll cost	FlatList minimum
Large or complex list	FlashList or Legend List
Complex item layouts	FlashList with `getItemType`, or Legend List
Fixed height items	FlatList: `getItemLayout`; FlashList v1: `estimatedItemSize`; FlashList v2+: stable item structure

Common Pitfalls

Inline renderItem functions: Causes re-renders. Define outside or use useCallback.
Missing keyExtractor: Use unique IDs, not array index when possible.
Assuming all FlashList versions need estimatedItemSize: FlashList v2 ignores it. Check the installed version before suggesting it.
Heavy item components: Keep list items light. Move side effects out.

js-profile-react.md - Profile list rendering
js-measure-fps.md - Measure scroll performance

Requirements and compatibility

Works with: Claude Code, Claude apps, OpenAI Codex, GitHub Copilot, Cursor, Gemini CLI, Kiro, OpenCode, Goose, Amp, Roo Code, JetBrains Junie, Factory Droid, Devin (ex-Windsurf), Mistral Vibe, OpenHands, Letta

“Works with” means the tool reads the open Agent Skills format; a skill written for one tool may use features others lack.

Needs: Needs Node.js

Security

No issues found by our static scan· No issues found

A static scan is not a guarantee. Skills are third-party content: review a skill before you let an agent use it.

Attribution and licence

Published by

Callstack

Publisher

Callstack (Official)

Source

callstackincubator/agent-skills · skills/react-native-best-practices · commit 59e9d17

Licence

MIT License (redistribution allowed)

LICENSE (added by AutoGineer from LICENSE)
ATTRIBUTION.md (written by AutoGineer)

Synced

2026-11-09

AutoGineer is not affiliated with or endorsed by Callstack or Callstack.

Get it from the source

1 of this skill’s files are not mirrored here, so there is no ZIP. Get the complete skill from its source: callstackincubator/agent-skills

From the author

AutoGineer summary

What it does

When to use it

Advantages

Usage examples

Install

Documentation by Callstack

React Native Best Practices

Overview

When to Apply

Security Notes

Priority-Ordered Guidelines

Quick Reference

Optimization Workflow

Review Guardrails

Critical: FPS & Re-renders

Critical: Bundle Size

High: TTI Optimization

High: Native Performance

References

JavaScript/React (js-*)

Native (native-*)

Bundling (bundle-*)

Problem → Skill Mapping

Attribution

Files

references/js-lists-flatlist-flashlist.md

title: Higher-Order Lists impact: CRITICAL tags: lists, flatlist, flashlist, legend-list, scrollview, virtualization

Skill: Higher-Order Lists

Quick Pattern

When to Use

Prerequisites

Version Guardrail

Step-by-Step Instructions

1. Identify the Problem

2. Replace with FlatList

3. Optimize FlatList with getItemLayout

4. Upgrade to FlashList

5. Evaluate Legend List

Code Examples

Mixed Item Types

FlatList Optimizations (if not using FlashList)

Decision Matrix

Common Pitfalls

Related Skills

Requirements and compatibility

Security

Attribution and licence

Related skills

Diagnosing Bugs

Systematic Debugging

Performance Optimization

Debugging And Error Recovery

Animation Performance

Parallel Debugging

Get it from the source

JavaScript/React (`js-*`)

Native (`native-*`)

Bundling (`bundle-*`)