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-atomic-state.md

title: Atomic State Management impact: HIGH tags: state, jotai, zustand, re-renders, context

Skill: Atomic State Management

Use atomic state libraries (Jotai, Zustand) to reduce unnecessary re-renders without manual memoization.

Quick Pattern

Before (broad Context value):

const { filter, todos } = useContext(TodoContext);
// Re-renders when the provider value identity changes

After (Zustand - only subscribed state):

const filter = useTodoStore((s) => s.filter);
// Only re-renders when filter changes

When to Use

Global state changes cause widespread re-renders
Using React Context for app state
Components re-render even when their data hasn't changed
Want to avoid manual useMemo/useCallback everywhere
Not ready to adopt React Compiler

Prerequisites

State management library: jotai or zustand

npm install jotai
# or
npm install zustand

Problem Description

Context is not inherently slow, but a broad provider value makes every consumer of that context eligible to re-render when the value identity changes. Atomic stores help when profiling shows unrelated subscribers rendering after global state updates.

Step-by-Step Instructions

Using Jotai

1. Define Atoms

import { atom } from 'jotai';

// Each atom is an independent piece of state
const filterAtom = atom('all');
const todosAtom = atom([]);

// Derived atom (computed value)
const filteredTodosAtom = atom((get) => {
  const filter = get(filterAtom);
  const todos = get(todosAtom);
  
  if (filter === 'active') return todos.filter(t => !t.completed);
  if (filter === 'completed') return todos.filter(t => t.completed);
  return todos;
});

2. Use Atoms in Components

import { useAtom, useAtomValue, useSetAtom } from 'jotai';

// Only re-renders when filterAtom changes
const FilterMenu = () => {
  const [filter, setFilter] = useAtom(filterAtom);
  
  return (
    <View>
      {['all', 'active', 'completed'].map((f) => (
        <Pressable key={f} onPress={() => setFilter(f)}>
          <Text style={filter === f ? styles.active : null}>{f}</Text>
        </Pressable>
      ))}
    </View>
  );
};

// Only re-renders when todosAtom changes
const TodoItem = ({ id }) => {
  const setTodos = useSetAtom(todosAtom);  // Only setter, no re-render on read
  
  const toggleTodo = () => {
    setTodos((prev) => 
      prev.map((t) => t.id === id ? { ...t, completed: !t.completed } : t)
    );
  };
  
  return <Pressable onPress={toggleTodo}>...</Pressable>;
};

Using Zustand

1. Create Store

import { create } from 'zustand';

const useTodoStore = create((set, get) => ({
  filter: 'all',
  todos: [],
  
  setFilter: (filter) => set({ filter }),
  
  toggleTodo: (id) => set((state) => ({
    todos: state.todos.map((t) =>
      t.id === id ? { ...t, completed: !t.completed } : t
    ),
  })),
  
  // Selector for derived state
  getFilteredTodos: () => {
    const { filter, todos } = get();
    if (filter === 'active') return todos.filter(t => !t.completed);
    if (filter === 'completed') return todos.filter(t => t.completed);
    return todos;
  },
}));

2. Use Selectors

// Only re-renders when filter changes
const FilterMenu = () => {
  const filter = useTodoStore((state) => state.filter);
  const setFilter = useTodoStore((state) => state.setFilter);
  
  return (
    <View>
      {['all', 'active', 'completed'].map((f) => (
        <Pressable key={f} onPress={() => setFilter(f)}>
          <Text>{f}</Text>
        </Pressable>
      ))}
    </View>
  );
};

// Only re-renders when todos change
const TodoList = () => {
  const todos = useTodoStore((state) => state.todos);
  return todos.map((todo) => <TodoItem key={todo.id} {...todo} />);
};

Comparison

Feature	Context	Jotai	Zustand
Re-render scope	Consumers of changed provider value	Atom subscribers	Selector subscribers
Derived state	Manual	Built-in atoms	Selectors
DevTools	React DevTools	Jotai DevTools	Zustand DevTools
Bundle size	0 KB	Small dependency	Small dependency
Learning curve	Low	Medium	Low

When to Use Which

Do not migrate global state solely for fewer re-renders if React Compiler or narrower subscriptions solve the measured issue. Atomic state helps when broad Context/store updates cause unrelated subscribers to render.

Jotai: Fine-grained state, many small atoms, derived/async atoms
Zustand: Simpler mental model, single store, familiar Redux-like pattern
React Compiler: If available, may eliminate need for these libraries

Common Pitfalls

Over-atomizing: Don't create an atom for every variable. Group related state.
Missing selectors in Zustand: Always use selectors to prevent unnecessary re-renders.
Derived state without memoization: Use derived atoms (Jotai) or memoized selectors.

js-bottomsheet.md - Avoid context-driven bottom sheet subtree re-renders
js-react-compiler.md - Automatic memoization alternative
js-profile-react.md - Verify re-render reduction

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-08

AutoGineer is not affiliated with or endorsed by 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-atomic-state.md

title: Atomic State Management impact: HIGH tags: state, jotai, zustand, re-renders, context

Skill: Atomic State Management

Quick Pattern

When to Use

Prerequisites

Problem Description

Step-by-Step Instructions

Using Jotai

1. Define Atoms

2. Use Atoms in Components

Using Zustand

1. Create Store

2. Use Selectors

Comparison

When to Use Which

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-*`)