Last night at 23:18, Spanish time, the rewrite of Cuando merged. One pull request, open for 74 days: 339 commits, 1,139 files. Version 3.0.1 was tagged the same night.
Today went on the store side: the What's New text in six store languages, a crash on the camera button (the app never said why it wanted the camera, so iOS killed it on the tap), and permission alerts in nine more languages. Tonight 3.0.1 is ready to submit. It installs over the app you have, under the same store listing, and nothing about it is Flutter any more.
The proposal, in July, estimated eight to twelve agent-days. From the first commit to the merge took 79 days.
Why leave Flutter
The proposal is an issue I opened on July 30, and its case starts by saying what it isn't: "The case isn't primarily 'Swift is nicer than Dart'. It's that four separate things we want are each blocked by Flutter, and one codebase we already own has solved most of the migration cost in advance."
The four things:
- Vector maps. Part three has the whole story. Flutter could draw our vector map on an iPhone and couldn't on a mid-range Android, and raster tiles "don't scale with" a bigger region: "every new region is another pre-rendered tile pyramid."
- The Lock Screen. "Live Activities and Dynamic Island are the obvious ones for a transit app — arrival countdown on the lock screen is the feature."
- Native components. An app that "reads as a platform app rather than a rendered one." Also, "Bundle size drops — no embedded engine." Remember that one.
- Tests. "We have 124 lines of test against 41k lines of app." And: "Most of what we've spent time on in this repo has been catching and fixing things nothing warned us about."
The codebase we already owned was the partner app: the app businesses use on Cuando, written in Swift and compiled for Android with Skip earlier that week. Skip's Fuse mode compiles Swift natively for Android and draws SwiftUI with Jetpack Compose. The partner app was about 30,000 hand-written lines, done in four days, and it had already paid for the expensive parts: talking to our API from Swift on Android, signing in, maps.
Why Skip, and not the other ways to have one codebase:
- React Native: nobody on the team knows React, and I don't like it. Our web is Vue.
- Two native apps: twice the work for a benefit I couldn't name.
- Kotlin Multiplatform: it brings little on Android, where Skip is just as quick, and it's poor on iOS.
- Swift itself: it isn't far from Dart, and SwiftUI isn't far from Flutter. Declarative components feel natural to anyone who's written Vue 3.
- And iOS matters most, because that's where more of our riders are.
The proposal was honest about two things. "No strangler path. Flutter and Skip can't share a binary, so it's all-or-nothing per platform." And "the last 20% is still where estimates stretch." It also settled two questions up front, so they couldn't eat days later: "Offline: we have none, and we're not adding any." And local state gets wiped, not migrated, at the price of "one re-login, and feed seen-markers reset."
Then the estimate. Thirty-five screens, the data layer, translations and tests at six to nine agent-days, about two for the native bridges, half a day for "CI, fastlane, store metadata": 8–12 agent-days to iOS and Android parity. An agent-day is a day of an AI coding agent working, which is how most of Cuando has been built this year. And a size forecast: SwiftUI "runs roughly 1.5x tighter than Flutter widget trees, so the target is ~25–30k Swift."
Day one, and the restart on day three
The first Swift commit landed on Sunday, August 2. By that night there was a draft pull request with about 19,500 hand-written lines, 124 unit tests, and a rule that would hold for the next eleven weeks: "Behaviour is ported, not improved." Where the old app did something odd, like rounding distances down to the nearest ten metres, or counting the first stop's duration twice, the new one did it too. Improvements could wait.
The draft had a second rule: "The Android build is the only build that proves anything." The next day Android proved it, with a map that was quietly raster. That's in part three.
On Tuesday, August 4, the first shell went in the bin. It had been built like the Flutter app: a map, with sheets over it. But Cuando wasn't only a bus app any more. It had a services catalog, and the commit that restarted the port says it in one line: "The catalog does not fit under a map with sheets over it." So the shell became the partner app's, four tabs (City · Market · Messages · More), and every screen was thrown away. The data layer, the map, the translations and 95 unit tests stayed. Four pieces of model logic had been filed among the screens and nearly went with them: "The surviving tests caught all four, which is the argument for the tests in one line."
129 gaps
On August 12 we checked where we were. All 33 of the Flutter app's modules outside the catalog and the chat were read against the Swift source, and every gap found was "re-checked by somebody trying to disprove it." "129 gaps survived. Eleven are large."
The same audit noted that the Swift was already 34,000 lines against Flutter's 41,000, with the catalog and the chat still to come. "The '8–12 agent-days to parity' in #413 is well past." That was day eleven.
The plan file had a phase list, and the audit added a warning over it: "The phase list is not the remaining work, and reading it as though it were is how this file misled for a month." Even the audit got one wrong. It searched for the generated name of an API method, found nothing, and reported a gap for a method that was already wired up. The note that fixed it: "Grep the seam, not the wire."
Some of the 129 were small and telling. Sharing the app: the old one shows a QR code, "which is how this app actually spreads in Torrevieja." A launch screen: there was "no launch image on either platform — and Android cold-starts at ~10 s, all of it blank."
And the target moved. While the port went on, our Flutter developer kept shipping: the services catalog and Messages went out in Flutter 2.3.0 on September 29, and the Dart catalog the port was chasing grew from 12,500 lines to about 20,000.
Some things weren't ported on purpose:
- Ads. "No revenue today, and the only bridge with no Skip package."
- Signing in through a browser. The Flutter app carried two ways of doing it. "We are building neither." The app is installed by people standing at a bus stop, and bouncing them out to a browser and back is "a flow built for a desktop console." Native sign-in only.
- The Decline button on the terms screen. It did nothing: "a control that does nothing, which is the one thing this app's rules forbid."
- Old translations, wholesale. Flutter's Spanish for "Lines" was Pauta, a guideline rather than a bus route. Every screen's strings were reviewed instead.
Overnight, on a shared Mac
Most of the rewrite was written by an agent, often overnight, on a Mac it shared with two others. The working notes it kept for itself say so: "Three agents work here. This one, cuando-partner, and a Flutter screenshots worktree." The disk filled up twice. The first time, it surfaced as a compiler crash.
Its log of one overnight run starts with the rules for working unattended: "Written to disk deliberately: this runs for hours and my context will compact. Re-read this file after any gap." "Never guess at a design decision." When the partner app and the Flutter app disagreed, the partner app won, and Flutter was the reference "only for things partner has no answer to at all. It is the app being replaced, not the target." And the rule that paid for itself most often: "Android is the gate that finds things. iOS looking right proves nothing." The plan file's section on verification adds: "Look at Android, don't just compile it. One launch found a layout bug that had been on every screen for two hours."
Every iOS build also ran Skip's plugin for the Android side, so even a build with nothing changed recompiled 903 files and took 82 seconds. A switch borrowed from the partner app's notes turns that off while you work on iOS: the same build then took 4.7 seconds, and 11.5 with one file edited. The switch has to be exported in the shell, and the commit that found that out adds: "A benchmark that measures once concludes it does not work."
The rhythm, from git: 390 commits across the two pull requests, the first draft's 51 and the 339 that merged, on 33 of those days. The busiest was September 14, with 90.
What the partner app paid for
The partner app's notes were "53k of Skip landmine map, paid for over four days." The consumer app's notes don't repeat them. They record "only what is new or different here." What came across whole:
- The client for our API: connect-swift, vendored and patched for Android. In the proposal's words: "Probably the single hardest thing in partner's first three days."
- The form engine for the catalog: "ported unchanged… compiled here without an edit."
- Analytics through Skip's Firebase package: "the whole reason this was an afternoon rather than a week."
- A test with a scar on it. One confirmation bug "cuando-partner shipped … four times". Its test came across with its fix, "rather than after the next one."
And one bug turned out to be the partner app's too. On iOS, MapKit's camera distance is how far the eye is from the map, looking through a fixed 30° field of view, not how much ground fits on the screen. We fed it the width, so the map sat "1.866× too close, exactly 0.9 zoom levels." Nothing could catch it, because the code that read the zoom back had the same mistake. "cuando-partner has the identical code and the identical bug."
What 3.0 is
Four tabs: City, Market, Messages, More. City is a full-bleed map with a card floating over it, swiped between Nearby, Saved, Lines and What's on. On a tablet the card becomes a side panel. The map is Apple's on iOS and ours, vector, on Android, as part three promised. Timetables, route planning and the news feed work without an account.



The Lock Screen gets a Live Activity that asks "Are you on this bus?", takes Yes or Not me without opening the app, and then shows the next stop. Ride tracking is off until you switch it on, and it needs location set to Always. It deliberately shows only the timetable's numbers: "this app exists because the printed times are wrong, so a number we invented would be the same failure in a nicer font." Android has no Live Activities, but a ride needs a foreground-service notification anyway, so that notification asks the same question. Its comment: "The card that Android forces us to show is the card we wanted."
The Flutter app had no push. 3.0 does, with a rule: "The ask is after a request goes out, never at launch."
It speaks ten languages, two more than before, and every one is at 775 of 775 strings. It keeps the Flutter app's analytics event names to the character, because our dashboards are built on them: "the vocabulary is not ours to choose." Where the old app had a screen the new one doesn't, that event simply stops. And it asks everybody to accept the terms again, because nobody's acceptance carries over, which "will look like a bug in the release notes and is not."
The notes themselves start "Cuando has been completely rebuilt for iPhone and iPad, with a new design." An earlier draft also promised a faster start, faster on older phones, larger text. Today's pull request removed all three: "Every claim was checked against the code and against what 2.x already had. The unmeasured claims are gone…"
The bill
The forecast was 25 to 30 thousand lines of Swift. What merged is 44 thousand lines of code, against the Flutter app's 39 thousand. Plus 30 thousand lines of comments.

That's not quite like for like: push, the Live Activity and the tablet layouts are new. But the comments are the real difference. Two lines in five of the Swift are comments, against one in twelve of the Dart. Most of them say why things are the way they are, for whoever opens the file next. These days that's usually an agent.
The rest of the bill:
- Tests. 124 lines when the proposal was written. 1,960 test functions at the merge.
- Kotlin. Flutter needed 5 lines of Kotlin. 3.0 has about 3,600, a third of it the Android map, because Skip's hook for native Android views takes a Compose function, and those have no Swift spelling.
- Size. "Bundle size drops," said the proposal. The first Android release build was 558 MB, and the commit says it plainly: "558 MB is not a build you can send anybody." With one architecture, and debug symbols meant to be stripped: "206 MB, which is what Skip Fuse costs." Probably less, in fact: in October we learned that stripping silently does nothing unless the build names an NDK, and that build didn't. That same build was the first release build this app ever did, and it "found a shipped bug": every tablet had been locked to portrait, and the check that says so only runs on release builds.
- Startup. About ten seconds of blank screen on an Android cold start, at the August audit.
- A Mac in the pipeline. "Skip cannot produce an Android artifact on Linux, and a macOS runner bills 10× on a private repository." So the Mac builds Android, and CI only signs and uploads it. iOS goes through Xcode Cloud: push a tag and it builds. "Nothing in CI talks to App Store Connect, so there is no API key to mint, store or rotate — which is the whole point."
- Build numbers. The partner app's scheme would have numbered our first build about 609 million. The Flutter app had already shipped build 1,000,000,076, and a store won't take a lower number for the same app: "six hundred million below the floor." The new scheme is a readable timestamp. Last night's build is 1110202129: 2026, October 20, 21:29 UTC. It lasts until the end of 2034.
What the bill doesn't include is speed. On Android, where Flutter drew every frame itself, the Skip app with plain Compose underneath is simply faster than the app it replaces.
Where it is tonight
Both stores still have Flutter 2.3.0. The Swift app has been on TestFlight since August 19 and on Google Play's internal track since October 7, for us. With last night's merge, Flutter's mobile builds and its Xcode project left main: "One Xcode project in this repository, not two." Flutter stays only on the web, until something replaces it there.
The July issue is still open.
The rewrite's notes have a section about who the app is for, written in August, and it reads better now than it did then: "This app talks to somebody standing at a bus stop in a town they arrived in yesterday. There is nobody to ask." And: "We cannot make the buses punctual; we can make what is happening knowable."
- App Review said no first. The October 21 translations of the permission alerts had nine languages and no English, so English iPhones showed the raw key names, like NSCameraUsageDescription, and "App Review's automated check found" them. The fix, on October 26, came with a test that "fails six ways and names each key."
- 3.0 is out on both stores. 3.0.1 to 3.0.6 took 26 days. On November 13 we reckoned about 40% of riders were still on the Flutter app. At the last check, at least 70% of Android installs were on 3.0, and Apple doesn't say exactly, but it's nearly everyone on iPhone.
- Google Play rejected it once, on November 9, for not explaining location use prominently enough. The demo video Play judged was still the Flutter app's, but the Swift app had the same gap: the locate button and the switch that shares your rides raised the system location dialog with nothing in front of them. The same fix gave both platforms a launch screen, so a cold start is no longer blank, and replaced Android's adaptive icon, which was still Skip's template: "four purple arrows."
- "Bundle size drops", revisited. Google Play scored the Android code's optimisation at 14% against a 25% floor. Two rounds of shrinker rules took it to 41% and then 84%. The second took the compiled code from 16 MB to 9.2 MB, with "three breaks on the way, each with a green build." One release build scored 84% and hung at launch. It was caught on an emulator before it was sent. The bundle we upload, with all four Android architectures in it, is still about 254 MB, much as it was in October. Play sends each phone only its own.
- The old app is still the loudest client. On November 5 the Flutter app's departure polling was about a third of all requests to our API. Now the apps prove they're the real apps (App Attest on iPhone, Play Integrity on Android), and once nearly all app traffic does, anonymous calls without that proof will be refused. The old app can't prove it's ours, so that's where its anonymous polling ends.