Why we generate Flutter, not React Native

F

Leanfinit generates Flutter apps, not React or React Native. Tomas explains the engineering reasons, the trade-offs we accept and how other builders differ.

Tomas·6 min read

Leanfinit generates every app in Flutter, Google's UI toolkit written in Dart, because one Flutter codebase draws the same interface on iOS, Android and the web, and that consistency matters more when no human developer is checking each screen. Most other AI builders generate JavaScript web code, much of it React, and Bolt and Replit reach phones through Expo and React Native. Here is why I chose differently, and what it costs us.

01

What the others generate

As of November 2026:

Lovable builds web apps only. New apps since May 2026 use TanStack Start; older ones use React and Vite. Its docs say it does not generate React Native projects and suggest a PWA or a Capacitor wrapper for phones (Lovable FAQ).
Bolt builds JavaScript web apps and switches to an Expo project when your first prompt asks for a mobile app (Bolt and Expo).
Replit Agent uses Expo and React Native for mobile apps (Replit mobile docs).
Base44 generates React with Vite, and its store apps run the published web app inside a web view (Base44 docs).
v0 generates Next.js, React and TypeScript web apps (v0 FAQ).

That is a reasonable default for a web-first product. React has the largest ecosystem in front-end development, and a generated React app runs anywhere a browser does. But our starting point was different: the apps we build for are phone apps first. A training log, a medication schedule, a shift tracker. They are used standing up, one-handed, often with poor signal.

02

One codebase, one renderer

React Native maps your components onto each platform's native widgets. That is its strength: a React Native button is a real iOS or Android button. It is also the source of the most common class of bugs in cross-platform apps: the same code looks or behaves slightly differently on each platform, and the differences show up in the details — text wrapping, spacing, keyboard behavior, scrolling.

Flutter takes the other route. It ships its own rendering engine and draws every pixel itself. A Flutter screen looks the same on an iPhone, a budget Android phone and in a browser, because the same engine draws it in all three places.

For a team of developers, this is a trade-off you can argue either way. For generated code, it settled the question for me. When a model writes an app, nobody is going to open three simulators and compare each screen by hand. If the platform guarantees that what renders in one place renders the same everywhere, a whole category of "it works on my phone" problems disappears before the app is built.

03

Dart is a good target for generated code

Dart is a statically typed language with sound null safety. In practice, that means a large share of mistakes a model can make — a missing field, a value that can be null where the code assumes it can't, a function called with the wrong type — fail at compile time instead of at runtime in someone's hand.

That matters for us more than for most teams. A compiler error is something an automated pipeline can catch and fix before the user ever sees the app. A runtime error in a dynamically typed codebase is something the user finds, usually at the worst moment. Flutter's tooling (flutter analyze, the formatter, widget tests) gives the same strict, predictable feedback on every project, which is exactly what you want when the author of the code is a model.

Dart also compiles ahead of time to native machine code on iOS and Android, so a Flutter build for a phone doesn't need a JavaScript bridge.

04

Offline and on-device fit the model

Leanfinit apps keep their data on the device, with no backend by default. I wrote about the reasons in No backend by design. Flutter makes that architecture straightforward: local storage, state and the UI all live in one Dart process, and the app doesn't assume a server is there to render pages or hold state.

Many web-first stacks are the opposite. TanStack Start and Next.js are built around server rendering; Base44 and Lovable lean on hosted backends for auth and data. That is the right design for multi-user web apps. It is the wrong default for a personal tool that should keep working in a basement gym with no signal.

05

The trade-offs we accept

Web bundle size. A Flutter web app downloads its rendering engine on first load, so the first visit is heavier than a typical React page. For an app someone opens daily and adds to their home screen, we think that is the right trade. For a marketing page, it would not be.
Web is not the native web. Because Flutter draws its own UI, a Flutter web app behaves less like a document: text selection, browser find and search-engine indexing work differently than on a React site. Leanfinit apps are tools, not content sites, so this rarely matters, but it is a real difference.
A smaller ecosystem. pub.dev is large, but npm is larger. When an app needs a niche integration, there is more likely to be a ready-made React package for it. We keep generated apps on well-known, maintained packages and avoid long dependency lists.
Fewer people know Dart. If you export your code and hand it to a developer, they need to know Flutter. The pool of Flutter developers is large and growing, but it is smaller than the pool of React developers.
06

What this means if you export your code

Leanfinit lets you export your app's code. What you get is a Flutter project, and with no backend by default there is no hosted backend to migrate. I cover what to check in any export in What you get when you export code from an AI app builder, and how to continue from there in Using a generated app as the start of your own Flutter project.

If you are comparing builders mainly by where the app ends up — browser, home screen or store — Mobile-first vs web-first AI builders lays out how each of them reaches a phone.

07

Why this is a long-term choice

Stacks are hard to change once many apps exist on them, so this was not a decision I made for a demo. Flutter gives generated apps three things I wanted from day one: the same interface on every platform, a strict compiler that catches the model's mistakes early, and an architecture that works on the device without a server. The costs are real, and we design around them.

You can try it on your own idea at studio.leanfinit.com.