Zum Inhalt springen

React Native zu Flutter: Wie wir Loggd migriert haben

Warum React Native mit Expo für unser eigenes Design-System nicht gereicht hat und wie wir rund 50.000 Zeilen mit Claude Code und Codex nach Flutter migriert haben. Mit unseren Prompts, Kosten und Token-Zahlen.

Tobias16 Min. Lesezeit

Am deutlichsten hat man es auf dem eigenen Profil gemerkt. Wer in Loggd viel geloggt hatte, dessen Profil lief sichtbar unrund, selbst auf einem High-End-Android-Gerät wie dem S26 Pro. Auch ein Tipp auf einen Link kam mit kleinen Rucklern. Im Schnitt lief die App mit etwa 45 statt 60 Bildern pro Sekunde, und dadurch wirkte alles ein bisschen billig.

Gebaut war Loggd damals mit React Native und Expo, bevor wir zu Flutter migriert sind. Mit React Native entstehen iOS- und Android-App aus einer Codebasis, und genau das brauchen wir. An den Apps arbeitet größtenteils eine Person, und eine native Web-Version soll noch dazukommen. Zwei getrennte native Apps können wir uns schlicht nicht leisten.

Trotzdem haben wir die App einmal komplett neu in Flutter geschrieben. In diesem Beitrag erzähle ich, warum wir das gemacht haben, wie wir rund 50.000 Zeilen Code mit Claude Code und Codex umgezogen haben, ohne eine zusammengevibecodete App zu bekommen, und was das gekostet hat.

Warum wir mit React Native angefangen haben

Mit React im Web und mit Flutter hatten wir schon gearbeitet, mit React Native noch nie. Den Ausschlag gab, dass wir als Team mit Web-Technologien vertrauter sind. Wir hatten gehofft, die spätere Web-Version schnell auf derselben Basis zu bauen: gleiches React, gleiche Libraries, dazu nur die Plattformunterschiede und ein neues responsive Design.

Entschieden haben wir das rein nach Recherche. Überall war die Rede, die Performance von React Native sei inzwischen fast gleichauf mit Flutter, und darüber müsse man sich keinen Kopf mehr machen. Das stimmt sogar, wie wir selbst gemerkt haben. Nur eben leider nicht für jede App.

Wo React Native für uns an Grenzen kam

Hält sich eine App an das native Design-System, also an Cupertino auf iOS und Material auf Android, läuft sie mit React Native super. Native Komponenten, ein paar einfache Animationen, fertig. Die Developer Experience mit Expo ist dabei genial.

Loggd sieht aber auf keiner Plattform nach Cupertino oder Material aus. Wir haben jede Komponente selbst gebaut, für ein komplett eigenes Theme mit Gradient Borders, Drop Shadows, Blur Views und aufwendig animierten Layouts. Da stößt React Native an Grenzen. Auf Android haben wir das deutlich früher gespürt als auf iOS.

Am schlimmsten waren Screens, die viele Komponenten auf einmal rendern. Etwa beim Stöbern durch Filme, Serien und Spiele aus unserer gemeinsamen Datenbasis. Oder das eigene Profil nach vielen Logs. Nach 60 FPS hat sich die App selten angefühlt.

Ich will nicht abstreiten, dass das zum Teil auch ein Skill Issue war. Man hätte sicher immer weiter optimieren können. Irgendwann haben wir uns aber gefragt, ob sich das noch lohnt. Wir sind ständig in Limitierungen gelaufen, haben Workarounds gebaut, native Libraries dazugeholt und die Performance dauernd beobachtet. Allein die Blur Views auf beiden Plattformen zum Laufen zu bringen, hat uns über die Zeit vermutlich mehrere Tage gekostet. In der Zeit hätten wir auch Features bauen können.

Warum wir uns für Flutter entschieden haben

Also haben wir gewechselt. Flutter ist im Prinzip ein Canvas in einer nativen App. Statt die nativen Komponenten der Plattform zu nutzen, zeichnet Flutter alles selbst, mit einer eigenen Rendering-Engine, die auf flüssige 60 FPS ausgelegt ist (Flutter-Doku zur Performance). React Native gibt euch einen Baukasten mit fertigen Teilen, Flutter eine leere Leinwand.

Für unser eigenes Design ist die Leinwand genau richtig. Gradient Borders zeichnen wir mit einem eigenen Canvas-Painter. Blur und Animationen sind von Haus aus dabei, ein Blur besteht dabei z.b. aus zwei Zeilen Code. Aufwendigere Animationen laufen effizient über Lottie. Performance-Tuning im Nachhinein brauchen wir dafür kaum, nur eine gut durchdachte Struktur.

Fremd war mir Flutter nicht. Schon vor dem KI-Boom habe ich professionell Apps entwickelt und privat ein paar mittelgroße Hobbyprojekte in Flutter gebaut. Die wurden für die Migration noch wichtig.

Warum „Migriere die App zu Flutter“ nicht reicht

Mit Agentic Coding fällt so eine Entscheidung leichter als noch vor ein paar Jahren. Claude Code einfach „Migriere die App zu Flutter“ zu sagen, reicht trotzdem nicht. Jedenfalls nicht, wenn am Ende keine zusammengevibecodete Slop-App stehen soll. Vier Dinge mussten wir vorher klären:

  1. Die Abhängigkeiten passen nicht eins zu eins. Expo Updates, TanStack Router und Query, Expo Analytics, RevenueCat, der File Picker: Alles, was nativ arbeitet, funktioniert in Flutter anders oder existiert dort so gar nicht. Für jedes Paket brauchten wir vor dem Start eine Alternative.

  2. Die KI braucht eine feste Struktur. Jeder Freiraum erzeugt Inkonsistenzen, und der Code wird unübersichtlich und schwer zu warten. Also lassen wir ihr so wenig Spielraum wie möglich.

  3. Die Architekturen ticken anders. Die Expo-App war um TanStack Query mit Offline-Funktionalität herum gebaut. Flutter funktioniert am besten mit View, ViewModel, Repository und Service. Das muss sauber aufeinander passen.

  4. Rund 50.000 Zeilen sind zu viel für eine Session. Damit der Kontext sauber bleibt, mussten wir die Migration in kleine Happen teilen, die möglichst genau zu den TypeScript-Quelldateien passen.

Daraus sind vier Schritte geworden: drei zur Vorbereitung und die Migration selbst als Schleife.

Schaubild: Drei Schritte Vorbereitung vor der Migration von React Native zu Flutter. Schritt 1: Vier alte Flutter-Hobbyprojekte, je ein Opus-Agent analysiert eins, Fable führt zusammen, von Hand geprüft, Ergebnis ist der FLUTTER_ARCHITECTURE_GUIDE. Schritt 2: Die React-Native-App mit rund 50.000 Zeilen, Opus plant und Fable prüft, das Design-System aus styles.css und Tailwind wird zur DESIGN.md, Ergebnis sind steps, README.md und DESIGN.md. Schritt 3: Ein Bootstrap-Prompt für Theming, Routing und CI/CD, von Hand geprüft, Ergebnis ist das Flutter-Gerüst. Alles fließt in Schritt 4, die Migrationsschleife mit einer HANDOVER.md pro Session.

Wie wir die Migration vorbereitet haben

1. Die alten Flutter-Projekte auswerten

Nach ein paar Jahren Flutter-Pause waren meine Hobbyprojekte eine gute Grundlage. Ich habe sie alle in einen Ordner gepackt und Claude Code mit dem Modell Fable darauf angesetzt. Fable ist das stärkste und teuerste der Claude-Modelle, die wir genutzt haben, Opus und Sonnet sind die günstigeren Stufen darunter.

Fable klingt also teuer. Viel Usage kosten aber meistens die vielen Output-Tokens. Deshalb plant Fable nur und führt zusammen, während günstigere Opus-Agenten die einzelnen Codebasen analysieren. Bei vier Projekten fassen also vier Opus-Agenten je eins in einem Dokument zusammen. Fable nimmt die vier Dokumente, trifft Entscheidungen und sucht aktuelle Alternativen für Abhängigkeiten, die inzwischen veraltet sind:

You are a orchestrator agent. This folder contains complete and professionally per hand developed flutter applications. These are a few years old, but the general structure should be the same for today.

Your task is to determine folder structures, architectual patterns, libraries & tools used, code style and general best practices. Generate a document describing the how to implement a scaling, professional, performant flutter app with amazing development experience.

For this spawn Opus Agents for each projekt, giving this prompt so they return a handover of this project. Take all the handovers, analyze, optimize, modernize them and output the resulting document.

Das Ergebnis habe ich danach von Hand durchgearbeitet und angepasst, bis ich zufrieden war. Habt ihr selbst keine Erfahrung mit Flutter und keine eigenen Projekte? Dann würde ich die erst sammeln, bevor ihr so etwas startet und hofft, dass die KI das schon regelt.

2. Die React-Native-App analysieren lassen

Für ein LLM gibt es keinen besseren Kontext als existierenden Code. Er ist strukturiert und eindeutig, da gibt es nichts zu interpretieren. Deshalb klappt so eine Migration überhaupt so gut.

Um Tokens zu sparen und es den Migrationsagenten später leichter zu machen, haben wir noch einmal in Planung und Discovery investiert. Eine Opus-Session koordiniert, und am Ende prüft ein Fable-Agent den Plan auf Widersprüche. Die Planung geht die App einmal komplett durch, bildet die genutzten Pakete auf Flutter ab und legt eine Art Inhaltsverzeichnis an, das direkt auf die relevanten React-Native-Dateien zeigt. Dafür teilt sie die App in Features, legt die Reihenfolge fest, sagt, was parallel laufen kann, und schreibt für jeden Schritt einen eigenen Plan:

Create a plan to migrate this whole expo/react native repository to flutter. You must analyze the features/routing/repository and create steps with absolute references to this original repository on what to implement in what order, so the migration can happen in multiple steps so everything goes clean (e.g. backend + auth first, then explore page and so on).

The goal should be a document describing the general plan and multiple documents for each step, so i can give it to the actual implementation sessions/agents later. All the features currently implemented, should be existing in the future. Don't create details on how to implement it in flutter, just references to source files, what the features does, requirements and so on. The agents figure out the implementation by there own.

If you are unsure about something, ask as many questions as needed to create the plan. Write the actual plans with its context with this opus session as some sort of cordinator. If you need to gather general information using opus or sonnet agents for simple things. At the end, use a fable agents which validates the plan and looks out for problems/inconsistensies or other things like this.

For the dependencies this project uses, find alternatives and ask the developer for verification. Note the decisions in the plans this dependency is needed.

Ein Thema für sich war das Design-System. In der React-Native-App steckte es in einer styles.css und in Tailwind mit eigenen Komponenten. Flutter braucht dasselbe Wissen, um seine Komponenten damit zu themen. Google hat dafür eine Spezifikation vorgeschlagen, die DESIGN.md (Spezifikation auf GitHub). Sie hält alle Farben, Abstände, Schriftgrößen und Tokens fest und beschreibt, wann was gilt. Unser Design-System lag zum Glück schon mit Beschreibungen in Figma und war nach Tailwind importiert. Daraus wurde mit einem Prompt die DESIGN.md:

For the @src/styles.css create a DESIGN.md spec file describing the design and decisions made in this project which form the look of loggd. 

You can finde the spec for the DESIGN.md file here: https://raw.githubusercontent.com/google-labs-code/design.md/refs/heads/main/docs/spec.md
  
Also find facts in the repository how we style things (e.g. button, inputs heights, gaps, text sizes, borders, radiuses and so on) to see what is actually used and at what positions

Nach diesem Schritt lagen im Repository ein steps-Ordner mit den Plänen, eine README.md, ein FLUTTER_ARCHITECTURE_GUIDE und eine CONVENTIONS.md. Während der Migration kam noch eine HANDOVER.md dazu. Über sie geben die Agenten den Stand von einer Session an die nächste weiter, wie ein Übergabezettel beim Schichtwechsel.

3. Das Grundgerüst aufsetzen

Mit dieser Vorbereitung war der dritte Schritt ziemlich simpel. Ein einziger Prompt bootstrapt das Repository: Theming, allgemeine Widgets, das erste Routing, einen Feature-Prototyp, der den Data Layer zeigt, Splash Screen und andere native Konfigurationen, App Flavors und die CI/CD-Pipeline.

Use .migration/FLUTTER_ARCHITECTURE_GUIDE.md and .migration/README.md to bootstrap the repository and use the DESIGN.md spec to boostrap the design system. Create a feature slice demonstrating the data/service/repository layer, setup dependency injection, general widgets, initial routing, splash screen and native configs from the other app, app flavors and a codemagic ci/cd pipeline.

Danach haben wir von Hand geprüft und nachgebessert, bis die Struktur so war, wie wir sie haben wollten. Auf diesem Gerüst baut jede spätere Session auf.

Die Migration läuft als Schleife

Schritt vier, die Migration selbst, lief als kontrollierte Schleife, Feature für Feature, bis alles aus der alten App übernommen war. Jede Session startet mit demselben Prompt. Wir lassen den Agenten laufen, bis er Fragen stellt oder fertig ist. Wer mag, hängt noch Kontext zum aktuellen Feature an:

/orchestration Overall Goal: Migrate the react native and expo codebase to this flutter project. Use .migration/README.md as your guide, since it describes and routes to the old implementation.

Don't just implement what the migration guide says. This has now knowledge of the current repository state, so don't just trust it. Rather use it as guide to design the migration / feature implementation for flutter following its and this repository defined best practices for caching, api layer, repositories and so on. Always look at the memory if you need more context, or ask developer if context is missing and decisions are needed. Never assume. If something is not trivial (e.g. a js/expo package needs a new replacement tool, verify by asking before deciding by your own).

Since this is a multi step implementation, in the migration folder read and edit a handover file and keep it up to date. This holds the state of the migration, so what is done, what is on hold and why, what still needs done, progress of the migration and so on. Keep it compact and meaningful and audit after every step finishes. The goal is that the next session for the next step can use this handover as context to flawlessly continue with the migration. So do one step at a time based on the current progress.

Verify the evidence before you call it done. Never test your own on a simulator. 

Hinter /orchestration steckt ein Skill, der die Arbeit auf Modelle verteilt. Gestartet wird er mit Opus. Opus schätzt für jede Aufgabe ab, welches Modell sie am günstigsten erledigen kann. Sonnet analysiert ein Feature und implementiert nach Plan. Den Plan entwirft Fable, und schwierige oder sicherheitsrelevante Aufgaben setzt Fable unter Umständen auch selbst um. So verbrennen wir keine Tokens teurer Modelle für billige Aufgaben.

Dazu kommt Codex von OpenAI, und das erklärt auch die Tabelle weiter unten. Wir haben hybrid gearbeitet: Im Prinzip habe ich mit Claude geplant, mit Codex implementiert und das Audit danach wieder mit Claude laufen lassen. So kontrolliert kein Werkzeug sich selbst.

Schaubild der Migrationsschleife: Session starten und HANDOVER.md lesen, mit Claude planen (Opus, Fable), mit Codex oder Sonnet implementieren, selbst testen, polishen. Sind wir nicht zufrieden, geht es zurück ins Polishing. Sind wir zufrieden, folgt ein Audit mit Fable gegen Slop, dann wird die HANDOVER.md aktualisiert und die nächste Session beginnt, bis alles in die Flutter-App migriert ist. Planung und Audit laufen mit Claude, die Umsetzung mit Codex, damit kein Werkzeug sich selbst kontrolliert.

Nach dem Implementieren sind wir dran. Wir testen, polishen von Hand oder mit weiteren Prompts und geben erst grünes Licht, wenn wir zufrieden sind. Business-Logik, Data Layer und Funktionalität haben nach meiner Schätzung in 95 % der Fälle auf Anhieb sauber funktioniert. React-Code mit Tailwind ist für die Agenten ein hervorragender Kontext. Die UI verhält sich in beiden Welten aber ganz anders, und dort gab's häufig kleine Probleme: Layout, Schriftgrößen, Abstände, Animationen.

Bei vielen Polishing-Prompts neigen Agenten zu Slop: zu komplexe Implementierungen, unnötige Dateien, überflüssige Doc-Kommentare. Schleppen wir es in den nächsten Schritt mit, bläht die App aber Feature für Feature auf. Deshalb läuft nach dem grünen Licht ein Audit-Skill mit dem stärksten Modell, Fable, also wieder mit Claude. Er ist auf unseren Coding-Stil zugeschnitten, den wir in der Vorbereitung ebenfalls extrahiert haben, und wird um sprachspezifische Audit-Skills ergänzt. Im Grunde ein Linter für LLMs.

Ist das Feature auditiert, aktualisiert die Schleife die HANDOVER.md. Die nächste Session startet mit demselben Prompt, und alles beginnt von vorn.

Das Wichtigste daran ist, dass wir jeden Schritt selbst prüfen. Man könnte die Schleife sicher auch ein paar Nächte allein laufen lassen. Das klingt schneller, ist es aber nicht. Am Ende müssten wir die ganze App am Stück polishen und testen. Und die technical deps würden mit jedem Schritt wachsen, weil spätere Sessions auf Fundamenten bauen, die schon Fehler haben.

Was der Wechsel von React Native zu Flutter gebracht hat

Systematisch gemessen haben wir nicht. Die Zahlen sind Stichproben, die wir beim Entwickeln genommen haben, keine Benchmarks. Den Unterschied merkt man trotzdem sofort.

React Native mit ExpoFlutter
Codezeilenrund 50.000ähnlich viele
App-Größe80 MB60 MB
Bildrateim Schnitt etwa 45 FPSkonstant 60 FPS
Startzeitetwa 1 sunter 200 ms

Stichproben aus der Entwicklung, unter anderem auf einem S26 Pro, keine systematische Messung. Die Flutter-App hat dabei mehr Features als die alte.

Kacheln: Vorher und nachher, React Native gegen Flutter. App-Größe von 80 MB auf 60 MB, Bildrate von im Schnitt etwa 45 FPS auf konstant 60 FPS, Startzeit von etwa 1 s auf unter 200 ms, Codezeilen rund 50.000 vorher und ähnlich viele nachher. Stichproben aus der Entwicklung, unter anderem auf einem S26 Pro, keine Benchmarks.

Die App ist um ein Viertel kleiner geworden, obwohl sie mehr kann. Am meisten bringt aber etwas, das in keiner Tabelle steht: Die Mikroruckler sind weg. Dadurch fühlt sich die App um ein Vielfaches flüssiger an, obwohl es auf Blatt Papier keine riesigen Unterschiede zu sehen gibt. Seitdem haben wir viel mehr Animationen, Seitenübergänge, Glaseffekte, Gradients und Blurs eingebaut, ohne einen einzigen Workaround. Flutter hat jede Design-Entscheidung mitgemacht, die wir bisher getroffen haben.

Was die Migration gekostet hat

Gedauert hat die Migration ein paar Wochen. In der Zeit hatten wir zwei Abos: Claude im Max-Plan für 180 Euro im Monat und Codex von OpenAI im Pro-Plan für 229 Euro im Monat. Rund 400 Euro im Monat und ein paar Wochen Arbeit für den Umzug in eine komplett neue Sprache, das ist für uns ein guter Deal. So verteilt sich die Nutzung während der Migration auf die einzelnen Modelle. Weil wir über Abos und nicht über die API gearbeitet haben, gibt es keine Kosten pro Modell. K steht für Tausend, M für Millionen und B für Milliarden Tokens.

ModellAufrufeInputOutputCache WriteCache Read
claude-opus-512.99726,0K6,6M35,1M1,9B
claude-sonnet-516.37132,7K1,6M39,2M2,0B
claude-fable-5-149329,3K201,7K4,8M61,6M
claude-fable-534569051,9K3,0M7,5M
gpt-5.6-sol21.14451,2M7,6M02,6B
gpt-6-astra4.92418,6M1,3M0485,7M
gpt-5.6-terra6.43124,6M2,6M0624,6M
gpt-5.6-luna1896,8K4,8K0617,0K
codex-auto-review3.38827,4M311,3K0150,6M
unknown4968,5K2,2K019,5K
Gesamt66.118~123,0M~20,3M~82,0M~7,8B

Token-Nutzung über die gesamte Migration, aus Claude Code und Codex.

Auffällig ist, wie stark die Cache Reads dominieren: rund 7,8 Milliarden gegenüber etwa 20 Millionen Output-Tokens, also fast 400-mal so viele. Die Agenten lesen vorhandenen Kontext viel öfter, als sie neuen Text schreiben. Zum Glück ist das der günstige Teil.

Was ich vor so einer Migration rate

Testet ein Framework mit eurem eigenen Anwendungsfall, bevor ihr euch festlegt. Recherche allein reicht nicht. Die Erfahrungen anderer sagen wenig darüber, wie sich ein Framework mit eurem Design-System und euren Animationen verhält. Da sind wir reingelaufen.

Verlasst euch bei einer Migration auch nicht darauf, dass das LLM eurer Wahl das schon irgendwie hinbekommt. Lasst Planung, Umsetzung und Audit nicht vom selben Werkzeug machen, und schaut euch an, was eure Agenten eigentlich alles lesen. Unser Test-Runner hat z.b. still und leise ein ganzes Abo gekostet, weil dieser alle korrekten Tests (> 4000 Stück) jedes mal ausgegeben und somit den Kontext geflutet hat.

Sonst stehen am Ende ein paar Milliarden verschwendete Tokens und eine schlampige App, die bald wieder migriert werden muss, weil die Codebasis nicht mit der Idee mitwächst.

Was als Nächstes kommt

Bleibt die Web-Version, wegen der wir uns damals überhaupt für React Native entschieden hatten. Die bauen wir jetzt als eigenes Projekt in React. Im Web sieht Loggd ohnehin anders aus, weil eine Website anders aufgebaut ist als eine App. Als Kontext nutzen wir die Flutter-App und den React-Code der alten App. So bekommen beide Plattformen sauberen Code und native Performance.

Was wir sonst als Nächstes bauen, steht auf unserer Roadmap. Welche Features heute schon drinstecken, zeigen wir im Beitrag darüber, was Loggd anders macht. Wie Filme und Spiele in Loggd zusammenfinden, erzählen wir bei den Empfehlungen über Mediengrenzen.

Wie sich ein Profil mit vielen Logs heute anfühlt, könnt ihr unter loggd.me selbst ausprobieren. Fragen zur Migration, zu Flutter oder zu unserem Setup mit Claude Code und Codex beantworten wir gerne auf Discord.