The Future of Mobile Development: Native, React Native, Expo and AI in 2026-2028

For most of the past decade, one of the biggest questions in mobile engineering was simple:

Native or cross-platform?

In 2026, that question is becoming less useful.

The more important question is becoming:

What architecture lets a small number of engineers, working with AI agents, build and operate the best mobile product?

That distinction matters because artificial intelligence is beginning to change one of the fundamental economic assumptions behind cross-platform development: that writing an application twice is approximately twice as expensive.

It is not true yet that AI makes two native applications cost the same as one shared application. But the gap is narrowing rapidly.

And one of the most important mobile engineering stories of 2026 demonstrates just how significant that change could become.

Shopify's surprising return to native

On September 10, 2026, Shopify announced something that would have sounded unlikely only a couple of years earlier.

It is moving its mobile applications from React Native back to Swift and Kotlin.

This is particularly significant because Shopify was not a reluctant React Native adopter. It went all-in on React Native in 2020 and became one of the framework's most influential corporate supporters.

Shopify says React Native worked.

The reason for leaving is not that React Native failed.

The economics changed.

Shopify found that modern coding agents could implement a feature on Android using the iOS implementation as a reference, do the reverse, help engineers work outside their primary platform, generate tests, and assist in keeping the two applications synchronized.

The company rebuilt its Shop application in Swift and Kotlin with AI assistance and took the project from proof of concept to a released native application in approximately 12 weeks. Its Android release build time fell approximately 75%, and Shopify demonstrated the native Android application running at 120 FPS on a Pixel device. (Shopify)

Shopify is now migrating its much larger merchant application, containing more than 300 screens as well as widgets, Apple Watch functionality, Siri Shortcuts, and other platform integrations.

This is an important development.

But interpreting it as "React Native is dead" would be a serious mistake.

The more interesting conclusion is that AI is changing the equation that determines when native development makes economic sense.

One point worth emphasizing: this announcement happened only a few days ago, and it is potentially a major inflection point rather than ordinary framework news. Shopify explicitly says React Native succeeded for them, but AI changed the economics enough to reverse their 2020 strategy. That makes the next 6 to 12 months particularly interesting. If other large mobile organizations follow, we may be seeing the beginning of a genuine AI-driven native resurgence rather than a one-company architectural decision.

React Native is simultaneously getting much better

The irony is that Shopify's announcement comes during one of the strongest technical periods React Native has had.

The old React Native architecture is effectively gone.

React Native 0.82 became the first release that operated entirely on the New Architecture. The old bridge architecture can no longer be enabled in current releases.

React Native 0.86 arrived in June 2026 with improved Android edge-to-edge support, DevTools improvements, and, importantly, no user-facing breaking changes.

React Native 0.87 is currently active, while the project continues its relatively aggressive release cadence.

This matters because React Native's historical weaknesses were not simply performance problems. They included difficult upgrades, native dependency compatibility, architectural transitions, and the complexity of operating between JavaScript and the native platforms.

The ecosystem is gradually reducing those costs.

React Native is also becoming less dependent on one company. React and React Native have moved into the React Foundation under the Linux Foundation, with founding board representation including Amazon, Expo, Meta, Microsoft, Software Mansion, and others. (Engineering at Meta)

So the technology itself is not disappearing.

If anything, it is maturing.

Expo may be the bigger story

The evolution of Expo is arguably even more important.

Several years ago, developers frequently thought of Expo as the easy way to start a React Native application before eventually "ejecting" when the project became complicated.

That mental model is obsolete.

Expo is increasingly becoming an application platform around React Native rather than simply a collection of convenient libraries.

Expo SDK 55 removed support for React Native's Legacy Architecture completely. Expo has also expanded brownfield support, allowing React Native and Expo functionality to be embedded inside existing native applications. Its isolated brownfield model can package React Native functionality as an Android AAR or iOS XCFramework that native teams can consume without even requiring Node.js in their development environment.

Expo SDK 57 subsequently moved to React Native 0.86 and demonstrated something particularly important for enterprise adoption: easier, non-breaking upgrades.

Expo is also integrating directly with AI development workflows through MCP servers, agent skills, and tooling that allows coding agents to interact with Expo CLI and EAS services.

This points toward a future where Expo's value proposition is not simply:

Write one application instead of two.

It becomes:

Give humans and agents a standardized mobile platform on which they can build, test, deploy, update, and operate applications.

That is a substantially more defensible position.

AI changes both sides of the native versus cross-platform debate

There is an interesting contradiction developing.

AI makes native development more attractive.

But AI also makes React Native and Expo development more productive.

Suppose a feature traditionally required five days of iOS work and five days of Android work.

A shared React Native implementation might have reduced that to six days.

That is a compelling economic argument.

Now imagine coding agents reduce the native implementation to two days of human-guided work per platform.

Suddenly native costs four days while React Native perhaps costs three.

The absolute difference becomes much smaller.

At that point, companies may decide that direct access to SwiftUI, Jetpack Compose, and platform APIs is worth the additional cost.

But there is another side to the equation.

An AI agent working inside a well-structured TypeScript, React Native, and Expo monorepo has an enormous advantage: shared context.

One component system.

One navigation architecture.

One networking layer.

One analytics implementation.

One testing strategy.

One repository.

One set of business rules.

One implementation for the agent to understand.

Therefore AI does not automatically eliminate the economic advantages of cross-platform development. It reduces one particular disadvantage of native development: duplicated implementation effort.

Those are not the same thing.

Apple and Google are designing mobile development around agents

The direction of the platform vendors provides another important signal.

Apple now describes Xcode 27 in terms of coding models and agents. Developers can use coding agents directly within Xcode and choose between models.

Apple is simultaneously making AI a first-class application capability. Its Foundation Models framework exposes native Swift APIs for language models and can work with Apple's own models or external providers. Its 2026 framework includes multimodal input, tool use, and an Evaluations framework for testing AI behavior. (Apple Developer)

Google is moving in the same direction.

Android Studio's 2026 tooling explicitly describes the transition from AI-assisted development to agentic development. Agents can plan architecture, generate code, create tests, and investigate bugs. Android Studio also supports different model providers and Google's local Gemma models.

Android itself is becoming agent-addressable. Google's experimental AppFunctions API allows applications to expose functionality to agents, including an architecture described as Android MCP. (Android Developers Blog)

This means AI is changing mobile development at two separate layers.

First, AI is building the application.

Second, AI is becoming part of the application.

That second change may ultimately be larger.

Prediction 1: Native development will make a genuine comeback

Over the next two years, I expect more large companies to reconsider native development.

Not because React Native suddenly became bad.

Because the cost calculation has changed.

Companies with large engineering organizations, sophisticated internal AI infrastructure, and applications requiring deep platform integration have the most to gain.

Banking, social media, video, creative tools, productivity applications, and highly interactive consumer products are particularly likely candidates.

For these organizations, AI can absorb some of the duplication between Swift and Kotlin while the company retains direct access to the latest platform APIs and performance characteristics.

Shopify is probably an early example rather than an isolated one.

But this will primarily affect the upper end of the market.

Prediction 2: Expo will grow despite the native resurgence

At the same time, I expect Expo adoption to increase.

That may sound contradictory.

It isn't.

Most companies are not Shopify.

A startup with four engineers does not have Shopify's internal AI infrastructure, migration tooling, mobile platform organization, or testing systems.

For those teams, maintaining two applications remains operationally expensive even if an AI agent can generate most of the initial code.

Generation is not maintenance.

Two codebases still mean two dependency graphs, two sets of platform behavior, two CI pipelines, two debugging environments, and potentially two sets of production problems.

For startups, SaaS companies, internal applications, and ordinary consumer applications, React Native plus Expo will remain extremely attractive.

My expectation is therefore a bifurcation rather than a winner.

Small and medium teams will increasingly standardize around highly integrated cross-platform platforms such as Expo.

Large organizations with demanding mobile products will have a stronger economic case for native development.

The uncomfortable middle ground of heavily customized React Native applications with enormous amounts of bespoke native infrastructure may become less attractive.

Prediction 3: Brownfield architectures will become much more common

The industry also does not have to choose entirely between native and React Native.

Expo's investment in brownfield development is significant for exactly this reason.

A company might have a native application shell while building selected product areas in React Native.

Another might maintain a React Native application while implementing performance-sensitive experiences natively.

AI makes these boundaries easier to manage because agents can increasingly reason across TypeScript, Swift, and Kotlin simultaneously.

By 2028, "What framework does your app use?" may have a less interesting answer.

The answer could simply be:

"Whatever is appropriate for that part of the application."

Prediction 4: Mobile engineers will write substantially less code

This is the prediction I have the highest confidence in.

By 2028, manually producing application code will represent a much smaller percentage of a senior mobile engineer's work.

Agents will increasingly handle:

• implementation
• tests
• refactoring
• dependency upgrades
• migration work
• analytics instrumentation
• accessibility checks
• documentation
• CI configuration
• bug investigation
• platform translation
• routine pull-request work

Shopify's Helix system demonstrates where this is heading.

Importantly, Shopify found that simply asking an LLM to rewrite an application produced unmaintainable code. Instead, Helix breaks migrations into small checkpoints, tests each stage, performs visual comparisons, uses adversarial code reviews, and requires human approval before continuing.

That is probably much closer to the future of professional software engineering than "vibe coding."

The important engineering skill becomes designing a system in which agents can reliably produce correct software.

Prediction 5: Senior mobile engineers become more valuable, while pure implementation roles become less valuable

AI does not remove the need for mobile expertise.

It changes where that expertise is applied.

Shopify explicitly reported that native expertise remained important because generated code could work while still containing architectural problems, duplication, or performance issues.

That distinction will become increasingly important in hiring.

A developer whose primary value is:

"I know the syntax for building this screen"

is becoming easier to replace or augment.

A developer who understands:

• mobile architecture
• iOS and Android platform behavior
• React Native internals
• performance
• networking
• security
• observability
• accessibility
• release engineering
• CI/CD
• app-store deployment
• native modules
• testing
• product architecture
• AI-agent orchestration

becomes considerably harder to replace.

The career path is therefore moving from mobile coder toward mobile systems engineer.

Prediction 6: Junior mobile development will become harder to enter

There is a less positive consequence.

The traditional junior developer career ladder depended heavily on relatively predictable implementation tasks.

Build this screen.

Connect this API.

Fix this layout.

Add this analytics event.

Write these tests.

Those are precisely the tasks coding agents are becoming good at.

LinkedIn's 2026 analysis of the US software engineering market already reports tightening entry pathways, with a smaller proportion of computer science graduates entering software engineering while overall engineering hiring has slowed.

This does not mean junior developers disappear.

But expectations will rise.

A junior engineer capable of using agents, understanding generated code, testing it, and reasoning about an entire application may outperform someone who has simply memorized a framework API.

The industry may consequently hire fewer junior engineers while expecting considerably more from each one.

That creates a longer-term problem: today's juniors are supposed to become tomorrow's senior engineers.

The industry has not yet solved that problem.

Prediction 7: React Native developers will need native knowledge again

For several years, one attraction of React Native was that developers could become productive mobile engineers while knowing relatively little Swift or Kotlin.

I expect that advantage to weaken.

The strongest React Native engineers in 2028 will probably understand React Native, Expo, Swift/SwiftUI, and Kotlin/Jetpack Compose.

They will not necessarily write all four every day.

AI makes learning adjacent stacks considerably easier, while companies gain value from engineers who can move between layers.

Interestingly, Shopify observed exactly this during its migration: engineers familiar with declarative React Native development were able to become productive with SwiftUI and Jetpack Compose more easily than expected.

Therefore I would not advise a React Native engineer to abandon React Native.

I would advise them to expand downward into the native platforms and upward into AI-assisted engineering.

That combination should be unusually valuable.

Prediction 8: AI capability becomes part of the definition of a mobile engineer

There will probably be a point where listing "AI-assisted development" on a CV sounds as unnecessary as listing Git.

The differentiator will not be whether someone uses Claude, GPT, Gemini, or another coding model.

Almost everyone will.

The differentiator will be whether an engineer knows how to construct a development environment in which agents operate reliably.

That includes repository instructions, architecture boundaries, automated tests, deterministic builds, simulator automation, observability, evaluation systems, MCP/tool integrations, structured specifications, and review gates.

The best engineers will not necessarily type code faster.

They will create better feedback loops for machines that type code extremely fast.

What happens to React Native?

I do not expect React Native to disappear over the next two years.

I expect almost the opposite.

React Native will become more technically mature while simultaneously losing some workloads that historically chose it purely to avoid writing code twice.

That sounds paradoxical, but technological markets frequently work this way.

React Native's future strength will come from React, TypeScript, its enormous ecosystem, Expo, brownfield adoption, and the ability to share application architecture across platforms.

Its weakest argument will increasingly be:

"We don't want to build the feature twice."

AI is attacking that argument directly.

Its stronger argument will become:

"We want one coherent product platform."

That is a much more durable proposition.

What happens to native?

SwiftUI and Jetpack Compose are likely to benefit substantially from AI.

Declarative UI frameworks are particularly suitable for language models because implementations are structured, patterns repeat frequently, and the desired result can increasingly be validated visually.

Agents can also translate concepts between React Native, SwiftUI, and Compose.

Native therefore becomes accessible to engineers who previously would not have considered themselves iOS or Android specialists.

That expands the potential native engineering workforce without requiring every developer to become an expert in both ecosystems.

The result will not be the death of cross-platform development.

It will be the end of the assumption that native automatically requires twice the engineering effort.

What I expect the market to look like in 2028

By 2028, I expect mobile development to settle into roughly three architectural categories.

Native-first products will use Swift/SwiftUI and Kotlin/Compose, particularly where performance, platform integration, and product quality justify direct platform access. AI agents will perform substantial amounts of parallel implementation between platforms.

Expo/React Native products will dominate teams where development velocity, shared product architecture, TypeScript talent, and operational simplicity matter more than extracting every platform advantage.

Hybrid or brownfield products will mix both, increasingly without treating that as an architectural failure.

Across all three categories, AI agents will participate in development, testing, debugging, migration, and release engineering.

The framework debate therefore becomes less important than it appears.

The mobile developer of 2028

The most valuable mobile engineer of the next few years probably will not identify exclusively as an "iOS developer," "Android developer," or "React Native developer."

They will understand the mobile platform as a system.

They may use React Native and Expo for most product development.

They will understand enough Swift and Kotlin to cross the native boundary when necessary.

They will understand CI/CD, observability, performance, security, and release engineering.

They will know how mobile applications integrate with backend and AI systems.

And crucially, they will know how to delegate implementation to coding agents without delegating engineering judgment.

The change AI brings to mobile development is therefore bigger than simply making developers faster.

For a decade, cross-platform frameworks tried to solve the problem of having two mobile platforms by sharing code.

AI introduces another possibility:

perhaps the code itself becomes cheap enough that sharing every line of it is no longer the primary optimization.

If that happens, native development wins back some territory.

But shared architecture, shared knowledge, shared infrastructure, and shared product logic remain valuable. That leaves a substantial role for React Native and an increasingly important one for Expo.

The likely future is therefore not native versus React Native.

It is native plus React Native plus Expo, orchestrated increasingly by AI, with far fewer humans required to produce significantly more software.

For mobile developers, the safest career strategy is not betting everything on one framework.

It is becoming the engineer who understands how all of these pieces fit together.