Originally published at Substack.
When I first started thinking about building an AI mobile app developer, it felt like a no-brainer. Having seen AI web builders raise massive rounds, ship almost perfect demos, and ride the hypewave clocking millions in revenue, it makes sense to assume mobile is next.
Just describe the app, and boom; you get a working build.
But it didn’t take long for the cracks to show. Most of the tools I tried looked great at first glance: clean UIs, simple workflows, and flashy examples. The hype is hard to ignore. But scratch beneath the surface and ask them to handle native features like camera access, push notifications, or background services and they fall apart. Either the features aren’t supported, or what you get back is a Frankenstein webview pretending to be a mobile app.
It is frustrating. Not because I expect magic, but because the promise feels so close, yet the execution is miles off.
At the core of this mess is a solid misunderstanding of what mobile dev actually involves. Most of these AI driven tools run on top of shallow JS runtime env. They’re thin wrappers that do their best to fake native behavior. Sure, they render interfaces, make API calls, and simulate interactions in a neat little sandbox. But honestly? That’s not how real apps are built or shipped.
App development isn’t just about stitching screens together and wiring up APIs. It has its own unique SDLC. Android runs on Gradle, AAPT, and the Android Runtime, and works best in Android Studio, which comes packed with native debugging tools. iOS, meanwhile, runs on Xcode. And unlike building for the web, you can’t just hit refresh in a browser, you need actual device simulators or physical devices to test properly. These aren’t nice-to-haves; they’re what make the app dev toolchain complete.
Current AI builders try to work around that by creating visual workflows in a JS shell, they are not abstracting the complexity instead sidestepping it. That is why most of them cannot produce real testable artifacts. Ask them for an APK or IPA, and they either fail outright or export a hybrid webview. That is not a mobile app. It is a web page pretending to be one.
It gets worse. The code architecture often mimics web centric React projects, with little regard for modularity something that’s foundational in native mobile development. Mobile devs rely on architecture patterns like MVVM, MVP, and Clean Architecture for a reason.
The consequences of these limitations are massive. Want to test a camera integration? You cannot. Want to verify Stripe payments in a native context? Impossible. Try background services, push notifications, deep links, Bluetooth connectivity, or offline storage. None of these tools provide the infrastructure to test or validate them. They are building UI layers, not applications.
Supporting all of this is hard. You can’t just run VSCode in the browser and hit build. You need infrastructure that can compile and execute mobile code. Even if you spin up AWS instances to build tasks, you’ll spend serious engineering effort optimizing for cost and scalability. And then you hit the next wall: gradle build times. (just Google “Gradle build memes” and you’ll see what I mean.) For context, Signal takes ~20 minutes to build on a 16GB M2 Pro. What kind of user is going to sit through that?
And even if you get through the build, testing is another beast. The simulation needs to be super smooth, which introduces a whole new black hole of latency tuning and performance work.
If your app just needs to fetch and display data, you are better off making a responsive website. The whole point of building native apps is to leverage the device. You build a mobile app when you need access to the camera, GPS, biometric authentication, motion sensors, native gestures, or platform specific performance optimizations. These are not luxuries. They are the core reasons to go mobile. And today’s AI tools fail to support even the most basic of them.
To truly build for mobile a platform needs to understands build tools, interprets logs, signs binaries, handles simulator testing, and works within the boundaries of real devices.
We need execution environments that can compile native code, test it across device profiles, and ship it through proper build pipelines.
Without that, we are just pretending.
We’re building illusions.