Native Apps Are Affordable Again

Scott Brady

By

Software engineer in Seattle and DIY builder who builds the CutOnce construction calculator.

  • ai
  • mobile
  • architecture
  • cutonce

In November 2025 I had to pick a stack for CutOnce, a construction calculator for iPhone, iPad and Android. I am one developer. The standard advice for one developer who wants to be on two platforms is to write the app once: React Native, Flutter, or a web view in a native wrapper, which is the Electron approach applied to phones.

I went the other way. CutOnce is two native apps: Swift and SwiftUI on iOS, Kotlin and Jetpack Compose on Android. They share no code.

A few years ago I would have made a different choice. What changed my mind is that I was no longer the one writing most of the code.

Why cross-platform won

The case for Electron and its mobile cousins was never that they produce better apps. Their own users complain about memory, startup time, and controls that feel slightly off. The case was about the people building the app.

Two native apps meant every feature got built twice, in two languages, against two UI toolkits, usually by two teams. Every bug got fixed twice, or fixed once and forgotten on the other platform. The two apps drifted. Engineers who knew both platforms well were rare and expensive.

One shared codebase made all of that go away. You paid for it with a runtime between your code and the device, and you accepted an app that was a little slower and a little less at home on each platform. For most teams that was a good trade, because engineering time was the scarce resource and users mostly tolerated the result.

That whole argument rests on one assumption: writing and maintaining the same thing twice is expensive.

What AI changes

Translating a working feature from Swift to Kotlin is close to an ideal task for a coding agent. The requirements are not vague, because the other implementation is the spec. The agent can read the Swift, read the Swift tests, write the Kotlin, and run the same cases until they pass. It does not get bored on the second platform, and thanks to its training AI is already a specialist in both.

This is how CutOnce was built. The iOS app came first. By the time I started the Android port in April 2026 it was about 45,000 lines of Swift with nearly 3,900 tests. The Android app was written by agents working from that codebase, feature by feature, with the iOS behavior as the reference.

Since then the two have moved together. The project’s definition of done, which every agent reads before starting work, opens with this:

Both platforms. Calculator fixes and features ship on iOS and Android, with regression tests on each.

That rule would be a heavy tax on a human team. For an agent it is a few more minutes of work.

Tests replace shared code

Sharing code was only ever a means. What you want is two apps that give the same answer. A shared codebase gets you that by construction. Without one, you need another mechanism.

CutOnce has over 12,000 automated tests. Of those, 1,714 are shared test vectors: a concrete input and a known expected result, run identically on iOS and Android. If the Kotlin stair calculator and the Swift stair calculator ever disagree about a 63 inch total rise, a build fails. The count is generated from the test runs on every build, and it is published on the How we verify accuracy page along with the breakdown per calculator.

This matters for a calculator more than for most apps. Someone is going to cut lumber based on the number on the screen. Imperial math in both apps uses exact integer arithmetic in 64ths of an inch, Int64 in Swift and Long in Kotlin, so the two implementations produce identical values, with no floating point rounding to diverge on.

The same approach scaled to a third codebase. The free calculators on the CutOnce website are TypeScript ports of the app’s code, and the site build re-runs the app’s own test cases against each port and fails on a mismatch. I wrote up which test file backs each page in Which App Tests Stand Behind Each Free Web Calculator.

Three implementations of the same math sounds like a maintenance problem. In practice the test vectors are the shared artifact, and the implementations are cheap to produce and cheap to check against them. Agents also need those tests for their own sake. An agent with a precise, executable definition of correct can work unattended. One without it produces plausible code that nobody has verified.

What users get

Once the second codebase is affordable, there is no reason left to ship a slower, less native app. You get the native benefits and keep them:

  • Speed. There is no JavaScript runtime to boot and no web view to lay out. A calculator gets opened for ten seconds on a jobsite, so launch time is most of the experience. I have no before and after numbers for CutOnce because there was never a cross-platform version, but Shopify does, and they are below.
  • Platform conventions. The iOS app is SwiftUI and behaves like an iOS app. The Android app is Compose with Material 3 and behaves like an Android app. Neither is a compromise design that is slightly wrong on both.
  • Direct access to the platform. CutOnce draws its PDF plans with CoreGraphics on iOS and the Android Canvas APIs on Android. New OS features are available the day they ship, without waiting for a framework to wrap them.
  • Fewer moving parts. No bridge, no plugin ecosystem to keep compatible with each OS release, and one less layer to debug through when something goes wrong.

Shopify reached the same conclusion

Ten months after I made this call, Shopify announced that native is now the future of mobile at Shopify. They are moving their apps off React Native to Swift and Kotlin, and the Shop app went from proof of concept to the app stores in 12 weeks.

Their reasoning is the same argument at a much larger scale: “We are making this change because agents have reduced the advantages of sharing implementation.” In their prototypes, agents “could implement a feature on Android using the iOS version as a reference,” which is exactly how CutOnce for Android got built.

They are also careful not to rewrite history, and I agree with them on this: “Native is the right choice for Shopify now, but React Native was the right choice for Shopify in 2020.” The frameworks are as good as they ever were. The duplicated work just got way cheaper.

Two follow-up posts fill in the details. The first describes Reflex, the architecture their agents build against, and its guiding principle is “share the test, not the code.” The Swift and Kotlin apps stay separate, and one shared test suite enforces that they behave the same. That is the CutOnce arrangement, arrived at independently by a team with far more people.

The second covers rebuilding the main Shopify app: about 30 engineers, 12 weeks, agents writing most of the code. It also puts numbers on what users get from native:

Metric React Native Native
Android launch time (P50) 1.71 s 0.87 s
Android binary size 80.4 MB 47.6 MB
iOS peak memory 730 MB 190 MB

Shopify’s React Native app was built by people who maintained major parts of the React Native ecosystem, so it was about as fast as a React Native app gets. Going native still cut its Android launch time in half.

Others are following

Coinbase appears to be making the same move. Adam Wolf, whose team there is driving the migration, posted that they are “taking Coinbase’s consumer trading app fully native, migrating off React Native and rebuilding in Swift and Kotlin.” Coinbase has not published an engineering post about it yet. This is the same company that announced its successful transition to React Native in 2021.

Discord is leaving both Electron and React Native. Their CTO said in November 2026 that the desktop client is being rebuilt in Rust, and that mobile will keep native interfaces while sharing app code with desktop through Rust. Discord’s case is different from mine in two ways. They are still sharing code, just below the UI in a compiled language instead of above it in a web runtime. And they have not credited AI for the decision. I include them because they are the largest Electron app I know of to decide that the runtime is no longer worth what it costs users.

The cost is not zero

Shopify includes this lesson: “Native still means building and maintaining software on two platforms, that cost has not disappeared.” That matches my experience.

Reviewing changes on two platforms takes my attention even when writing them does not. The platforms differ in ways that are not translation problems: state restoration, dependency injection, how async state reaches the UI. CutOnce keeps a parity matrix that records which tests exist on both sides and which are deliberately platform specific, and that file needs upkeep. Visual QA has to happen on real devices for each platform.

None of that works without the test suite. If you have two native codebases and thin tests, AI will help you produce drift faster. The investment moves from shared code to shared verification.

The new default

Architecture decisions encode assumptions about what is expensive. For decades, engineer hours were expensive and users absorbed the cost of saving them. If agents write most of the code, the expensive things are different: knowing what correct means, and being able to check it automatically.

If I were starting a mobile app today I would make the same choice without much deliberation. Build native on each platform, put the effort into tests that pin the implementations to each other, and let the agents do the part that used to make this impractical.

← All posts