React Native's 16 Rules Are Not About the APIs. They're About the Context.

I've shipped React Native apps after years of React web development, and the failures I'm most embarrassed about had nothing to do with the APIs I got wrong.

They were decisions that made perfect sense on the web and were silently wrong on mobile. Touch targets sized for mouse clicks. Scroll behavior that felt responsive on desktop and janky on a phone. Network requests written assuming a broadband connection. Navigation patterns that worked on a 1440px screen and were confusing on a 390px one.

None of these were API problems. I knew the APIs. They were context problems — a failure to understand that mobile isn't web, even when you're writing React.

The Category Error Web Developers Make

The React Native Guidelines skill from vercel-labs/agent-skills has 103.3K installs. That's a significant number. It tells you something about how often developers are making the same mistake.

The mistake isn't ignorance of React Native. It's the assumption that the web mental model is a reasonable starting point — that mobile is the web with different screen sizes and a few different APIs to learn.

It isn't. The differences go deeper than the surface.

A mobile user is holding a device. Their finger is imprecise compared to a mouse cursor. They're often doing something else — walking, waiting, half-paying attention. Their connection is variable, not broadband. The OS owns the navigation model in ways the browser doesn't. Animations don't just delight users on mobile — they communicate state in an environment where visual feedback has to substitute for hover states that don't exist.

A React web agent that doesn't know these things will produce mobile code that's technically correct and behaviorally wrong.

What 16 Rules Across 7 Sections Actually Covers

The skill structures its guidelines across seven categories: performance, navigation, user input, accessibility, data handling, platform-specific patterns, and testing.

What's notable is not the categories themselves — these are the obvious dimensions. It's what each category says about mobile specifically.

Performance guidance isn't about minimizing bundle size. It's about minimizing re-renders on devices that have a fraction of the processing power of a developer's laptop. The guidelines flag patterns that are imperceptible on a MacBook and cause dropped frames on a mid-range Android phone — and those are two very different devices from the same user base.

Navigation isn't a routing problem. On mobile, back behavior is often managed by the OS, not your app. Stack navigators need to match platform conventions or users feel disoriented. The expected behavior of the Android back button is different from the iOS swipe gesture, and ignoring that isn't wrong, exactly — it's just noticeably not right.

Touch input isn't click input with a different event name. Touch targets need to be 44×44 points minimum not because a guideline says so, but because below that size, users miss them at a rate that makes the UI feel broken. An agent trained on web patterns will size interactive elements for cursor precision that doesn't exist on touchscreens.

Why Agent Skills Matter More Here Than Anywhere

The gap between "I know React" and "I know React Native" is exactly the kind of gap that agent skills exist to close.

An agent working from general React knowledge will write code that runs. It will compile. It will work in development on a simulator. And it will have a specific category of correctness problems that won't surface until the app is in the hands of actual users on actual devices.

The skill doesn't add platform knowledge that the agent couldn't theoretically acquire — it surfaces it reliably. The agent stops defaulting to web patterns. It reaches for the mobile-first approach by default because the skill makes that the path of least resistance.

103K installs suggests a lot of teams have discovered that their AI coding assistant needed this context before writing their first screen, not after shipping their first bug.

The difference between web and mobile isn't a list of APIs to memorize. It's a mental model shift. The skill is the shortcut to that shift.

---

Part of the AI Skill Daily series — skills worth understanding, one at a time.