I burnt over 2 billion tokens and spent $2,000 to one-shot three different Expo apps with three different AI models, to find out which one is the king of mobile app development.
The models went through the whole process: ideation, development, autonomous testing, validation, debugging, everything in between. All three apps are built with Expo and React Native, and I never touched the code.
By the end of this post you'll know exactly which model to use to one-shot your own apps. Here's a summary of the metrics behind our experiment:
Prefer watching? The full video is here:
The ground rules
The contestants:
- Fable 5 (Claude Code)
- GPT-5.6 Sol (Codex)
- GPT-5.5 (Codex) as a control
Each model was in high effort and got the same exact prompt, generated with the spec-driven development skill. Same starter template, same tools, same rules.
Now, if you're wondering how on earth I got AI to one-shot entire apps with no bugs and good code quality: loops and verifications. The spec told every model that each implementation task must satisfy a standing bar before it's committed. One of those bars: validate every single feature on the iOS simulator before moving on.
Spoiler alert: that simulator validation ended up being the thing that cost the most tokens. More on that at the end.
App 1: the AI calorie tracker
First test: build an AI calorie tracker, with Cal AI (which is built with React Native, by the way) as the design inspiration. On the left we have GPT 5.5, 5.6 Sol in the middle, and Fable 5 on the right.
They were all close in terms of output. I liked that GPT 5.5 showed a 94% confidence score, which the other two didn't. I didn't love its tags though. If I had to pick one, I'd go with Fable 5, but 5.6 was a very close second.
On the UI overall: Fable 5 nailed the consistency. The shadows, the borders, everything looks clean and connected. The GPT models felt more disconnected. GPT 5.5 shipped a leftover "explore" page straight from the Expo starter template. Boilerplate code, still in the app, no idea why it's still there.
Credit where it's due: 5.6 had the best attention to detail on the home screen. It showed exactly how much of the daily budget you used and how many meals you'd had. Neither Fable 5 nor the real Cal AI does that.
App 1 metrics
| Fable 5 | GPT-5.6 Sol | GPT-5.5 | |
|---|---|---|---|
| cost | $276.95 | $170.16 | $157.23 |
| active time | 3h 45m | 5h 17m | 5h 20m |
| cost per hour | $74/h | $32/h | $29/h |
| messages | 1,061 | 1,724 | 1,512 |
| lines of code | 3.7k | 4.3k | 4.7k |
| code health (0-100) | 88 | 79 | 79 |
Fable 5 is the most expensive and the fastest. $74 per hour versus $32 and $29 for the GPT models. Lines of code are relatively similar on this app, but Fable 5 still takes the win.
Code quality is where it gets interesting. Fable 5 wins here too, and even though 5.5 and 5.6 tie on the health score, 5.5's tech debt is worse. That's a recurring pattern you'll see across all three apps. I used a code quality scoring skill for these audits, and all the code plus the codebase skills are in the repo.
And if you're wondering what I used for the backend: an Expo API route. 80 lines of backend. That's all you need for Expo apps sometimes. It uses the OpenAI Agents SDK and takes a POST request to scan the images. Here are the Expo API routes docs if you haven't tried them.
App 2: the ChatGPT clone
Second test: clone ChatGPT. Same backend idea (Expo API route + OpenAI Agents SDK), and this time the design reference was the actual ChatGPT app, because I think it's pretty good in terms of design.
First question: does the AI actually work?
5.5 does not work. No reply. The other two work, and streaming works too.
On the UI, it's also clear Fable 5 did a better job. It used native buttons at the top and a native sidebar, which the other 2 models did not use.
App 2 metrics
| Fable 5 | GPT-5.6 Sol | GPT-5.5 | |
|---|---|---|---|
| cost | $160.82 | $125.50 | $128.29 |
| active time | 2h 0m | 3h 24m | 4h 26m |
| messages | 396 | 1,175 | 1,311 |
| lines of code | 2.0k | 3.5k | 3.6k |
| code health (0-100) | 85 | 78 | 77 |
Same story, sharper. Fable 5 was the fastest and wrote almost half the lines of code in half the time, at the same or better quality. Very interesting. And it gets even more interesting in app 3.
By the way, if you want a fully built and battle tested chat app, look no further than Evan Bacon's chat template.
App 3: a full SwiftUI-to-Expo rewrite
This is the one I was most nervous about. Twilight is a sleep tracker built with SwiftUI. I wanted to see: can a model one-shot a full codebase rewrite from SwiftUI to Expo and React Native? Including live activities.
The live activity test: Fable 5 got it exactly right, just how it's supposed to look. 5.6 took extra space, which I ideally wouldn't want, but it got it right. 5.5's was dim for some reason. Honestly, they all did quite a good job here, each with its own style.
Then the app itself, and this is where I was genuinely amazed.
I expected a rough approximation. What I got looks like the same app. The moving average chart, the sleep score, sleep debt and credit, even the amethyst theme in settings: all basically identical to the SwiftUI original. Same charts, same colors, same everything.
The logs screen uses the real native slider, the real bottom sheet, etc. Expo talks to the same native layer SwiftUI does. So if you've been avoiding a rewrite because you're scared of losing the native feel, here's proof that it doesn't get lost.
In the end I actually also noticed a bug in the Swift app that Fable 5 fixed in the Expo app. You know, I was going to make a video converting this SwiftUI app to Expo. But there's nothing left to do. It one-shot the whole thing.
App 3 metrics
This is a whole other story.
| Fable 5 | GPT-5.6 Sol | GPT-5.5 | |
|---|---|---|---|
| cost | $558.83 | $254.50 | $160.65 |
| active time | 3h 25m | 13h 34m | 5h 48m |
| cost per hour | $163/h | $19/h | $28/h |
| messages | 773 | 2,439 | 1,539 |
| lines of code | 10.7k | 15.3k | 14.0k |
| code health (0-100) | 88 | 86 | 76 |
Fable 5 finished in three and a half hours, but at $163 per hour. Over $550 to build this one app.
And 5.6 took thirteen and a half hours. I don't know exactly why, but my guess is it got stuck in some loop validating something, probably the live activity. It would not stop until the problem was solved. Remember that, it matters for the verdict.
Quality-wise, Fable 5 wins again, but 5.6 is very close this time (88 vs 86), and that's the craziest metric here given the price gap. 5.5 on the other hand shipped visible slop, including building its own fake tab bar instead of just using the actual native liquid glass one. And once again, its tech debt is the worst of the three.
Where did 2 billion tokens actually go
A big part of it: Argent and the MCP servers. Argent is the tool the models used to validate their work on the simulator every single time they implemented a feature. Every screenshot taken, every tap performed, all of that metadata gets sent to the context window. Multiply that by 17 tasks per app, per model, per fix loop.
That's exactly why it's important to have subagents do the validating and testing: they burn those tokens in their own context instead of polluting the main context window.
Full interactive breakdown of every metric in this post: the dashboard.
The verdict: which model for what
Yes, Fable 5 is the best for almost all cases. But that's not the full story.
GPT-5.6 is a grinder. You give it a problem and it will do anything in its ability to solve it, including running for 13 and a half hours straight. It will not stop until the problem is solved. That makes it an amazing tool for well-defined problems and automation.
Fable 5 is a senior coworker. It just feels smarter. And because it's smarter, it writes less code and takes less time, at higher quality. You saw it in every table above: fewest messages, fewest lines, fastest, best code quality score, three for three.
So here's how I'd split it:
- you're an entrepreneur building apps, validating ideas, wanting a thought partner: Fable 5.
- you're a builder automating things, including computer use: 5.6 is amazing at that.
- quick technical tasks, "write me a script", "build me this simple feature": 5.6.
- something bigger, like a whole PR: Fable 5, mainly because the code quality is much better, as we saw.
I personally use both, for different things. (I could have used computer use instead of Argent for the validation, by the way. Comparing validation tools might be a future experiment I can dive into.)
What's next
Do you agree? Disagree? Should Kimi join the next comparison? Tell me in the comments on the video.
I was looking forward to making a tutorial on converting a SwiftUI app to Expo, but it seems we don't need that anymore. AI can just one-shot it, if you have the right tools.
For the tools themselves (the MCP servers, the skills, the setup that made all of this possible), check out this blog post or YouTube video on how to build mobile apps with AI.
Here are all the useful links from this experiment:
- All the code, prompts, and codebase skills: github.com/rami-maalouf/fable-5-vs-gpt-5-6
- All the metrics and charts: the dashboard
- Spec-driven development skill: SKILL.md
- Code quality audit skill: code-quality-scoring
- Expo API routes docs: docs.expo.dev
- OpenAI Agents SDK (JS): openai-agents-js
- Argent: argent.swmansion.com
- Twilight, the sleep tracker: App Store
