I Tested EVERY AI App Builder with the SAME Prompt!

Host your own app in seconds: tiiny.host

Four AI app builders, one identical prompt, one attempt each — and only one of them produced an expense splitter you'd actually hand to your friends.

Every AI company insists its model is the best at building apps. If you've spent any time with these tools, you'll know the familiar cycle: you pick one, wait for the code, open the result, and discover something that looks presentable until you tap a button and nothing happens.

The creator of this video got tired of taking vendor claims at face value and set up a fair fight instead.

The rules were simple and strict. Claude, Grok, Gemini and ChatGPT each received exactly the same prompt, word for word. Each got a single shot. No follow-up messages, no "can you fix the button", no second chances. Every builder ran on the most powerful model it currently offers, so nobody could argue the test was skewed by a weaker tier.

The task: a mobile-first web app for splitting expenses on a group trip. The judging criteria: how it looks, whether the maths adds up, and whether the thing actually works as an app.

What follows is a breakdown of how each contender performed, why one of them came out clearly ahead, and how the winning app was put online in seconds using Tiiny Host so anyone could open it on their phone.

The prompt and the ground rules

The prompt asked for a beautiful, mobile-first web app that makes splitting group trip costs simple and pleasant. That's a deliberately practical brief. Expense splitting is a problem almost everyone has had on a holiday or weekend away, the logic is well understood, and it involves enough interactivity (adding people, adding costs, adjusting splits, seeing who owes whom) that a half-working build is easy to spot.

It's not a toy "to-do list" demo, but it's also not so complex that a single prompt is unreasonable.

The one-shot constraint is the most important part of the methodology. In real use, most people iterate — but iteration hides a lot. If you give a model four rounds of corrections, you're really testing your own patience and prompting skill, not the model's first-pass judgement.

By refusing all revisions, the video isolates one question: when you describe what you want once, how close does each tool get? The creator notes the full prompt is available to copy for free, so you can replicate the experiment with your own idea.

Claude: polished and working on the first try

Claude went first. The output was a single HTML app, which is exactly what you want for something you plan to host as a static page. Opening it, the design impressed straight away — the creator says he was "quite happy" with how Claude laid it out, and that the app was easy to understand at a glance.

There was one genuine irritation: the interface flipped between light mode and dark mode on every click. That's a bug, not a feature, and on a one-shot build it's the kind of thing you'd normally fix with a quick follow-up. Under the rules of this test, though, it had to stand as delivered.

The question was whether it undermined the app, and the answer was no. The core functionality worked. Trips and expenses could be entered, all the information showed up where it should, and the numbers checked out.

So Claude set the bar early: a working application with a good-looking interface and correct maths, marred only by a cosmetic glitch. For a single prompt with zero revisions, that's a strong result.

Grok: a blank blue screen, then an ugly interface

Grok received the identical prompt and returned a file that, when opened, displayed nothing but a blue screen. The creator wasn't sure whether this was a rendering error or a flaw in the generated code itself, but either way it's about the worst possible first impression. If you were a non-coder trying this at home, you'd have nothing to interact with and no obvious way to diagnose what went wrong.

Rather than disqualify Grok on the spot — you can't judge a blue rectangle — the creator gave the output a fairer environment. He opened Tiiny Host, pasted in the index file and published it, so the app would load on a real hosting platform rather than locally. That did get the interface to appear.

Unfortunately, appearing didn't help much. His blunt verdict on the Grok UI: "very ugly." Given that the prompt specifically asked for something beautiful and mobile-first, this is a failure on the stated brief even before you look at the functionality.

The combination of an unreliable initial load and a poor interface put Grok firmly at the bottom of the table, and by the end of the video the creator says he wouldn't recommend it at all for this kind of task.

Gemini: correct maths, clumsy controls

Gemini's build was a more interesting case, because it split the scorecard. On the positive side, the app genuinely worked, it looked good aesthetically, and the arithmetic was clearly right. When the creator entered values, the expense calculations came out correctly, which is the one thing an expense splitter absolutely cannot get wrong.

The weakness was in the controls for customising how an expense gets divided. Gemini included options for choosing how to split a cost and for setting the amount per participant, and in principle that's a useful feature — real trips are rarely an even split across everyone.

In practice, though, adjusting those values was fiddly. Trying to set a value to 10, the creator found the input "really hard to control" and had to fight with it. He described the user interface as low quality, while being careful to separate that from the visual design, which he thought was quite nice.

That distinction is worth remembering when you evaluate AI-generated apps yourself. A build can look attractive in a screenshot and still be frustrating in the hand, especially on mobile where imprecise controls are magnified.

Gemini stayed "in the competition" on the strength of working logic and solid looks, but the awkward split controls kept it behind Claude.

ChatGPT: right numbers, broken app

ChatGPT went last, with the same prompt again. The result was arguably the most frustrating of the four, because it got the hard part right and the easy part wrong. The maths behind the expense splitting was correct. But the main flow was broken: it wasn't possible to proceed past the first step and create a trip at all. Deleting items worked; creating them didn't.

That means the central interface — the thing a user would do first — simply didn't function. The creator framed the verdict as two direct questions. Is it a working app? No. Is the maths correct? Yes. For a tool meant to be used, the first answer is the one that matters. An expense splitter that can't create a trip is a calculator with no input.

This is a useful lesson about how to judge these outputs. It's tempting to be impressed that a model "understood" the logic, but a user never sees the logic. They see whether the button works.

ChatGPT's version would have needed at least one revision before anyone could test it properly, which under these rules counts as a fail.

The verdict

Lining them up:

• Claude — attractive interface, correct maths, fully working. One cosmetic bug (light/dark mode flipping on each click). Winner.
• Gemini — correct maths, good aesthetics, functional, but the custom split controls are hard to use. Runner-up.
• ChatGPT — correct maths, but you can't create a trip, so the app doesn't work. Not usable as delivered.
• Grok — blank blue screen on first load, then an ugly interface once hosted. Not recommended.

The creator's reasoning for picking Claude is straightforward: it was the only one of the four that delivered on all three criteria at once. The UI, the underlying calculations, and the actual functionality were all there, and the app was easy to understand without explanation.

The others each failed at least one leg of the test, and in two cases the failure was fundamental enough that a user couldn't meaningfully try the app.

It's also telling that this was a one-shot test. With revisions, Gemini and ChatGPT could very plausibly have been brought up to standard. But if your priority is getting something usable with the least back-and-forth, the first-pass result is exactly what you care about.

Getting the winning app live in seconds

Having a working HTML file on your computer is only half the job. If you want to share it, gather feedback, build a mailing list or generate interest in the idea, it needs to be on the web. This is where the video moves from testing to shipping, using Tiiny Host.

The workflow shown is about as short as hosting gets. You drag the file in — or, if you've already published once, swap in the updated file — and click publish. Within a few seconds the app is live and you have a link to share.

The creator demonstrates updating the file and republishing, and the change goes out almost instantly. Every site also gets its own QR code, which is especially handy for a mobile-first app: scan it with your phone and you're testing the real thing on a real device straight away, which is exactly how the four builds in this video were put online.

The feature the creator leans on most is the built-in analytics. Once the link is shared, you can see how many visitors have come to the site, the bounce rate, how long people stay, where in the world they're viewing from, and what devices they're using.

His comparison is with Netlify and Cloudflare, where analytics and similar tasks often mean stepping outside the app into separate dashboards that can be hard to read or set up. With Tiiny Host, everything is in one place and live within minutes.

Other options mentioned include adding your own custom domain and putting a password on the site — useful if you want to share a prototype with a small group before going public — and the creator describes the pricing as fair.

Takeaways

If you only remember a few things from this experiment, make them these:

1. Test with one shot before you commit. Revisions mask a model's real first-pass ability. Giving each builder the same prompt once, with no corrections, exposed differences that would have been smoothed over by iteration. Claude was the only one that needed no fix to be usable.

2. Judge the whole app, not just the maths. Both Gemini and ChatGPT got the calculations right, yet one had controls that were painful to use and the other couldn't create a trip at all. Correct logic behind a broken interface is still a broken product.

3. Looks and usability are different things. Gemini's build was visually pleasant but hard to operate; Grok's eventually loaded but was, in the creator's words, very ugly. When you evaluate an AI build, actually tap through it on a phone rather than admiring a screenshot.

4. Put it on a real URL fast. Hosting the Grok file was what turned a blue screen into something reviewable, and hosting the Claude app turned a local file into something shareable with analytics. Tools like Tiiny Host make that a drag-and-drop, seconds-long step, complete with QR codes for instant phone testing.

5. Copy the prompt and run your own race. The exact prompt is free to copy, and the creator's channel has full tutorials on building apps like this. Models update constantly, so the results here are a snapshot — the method is what lasts.

The bigger point of the video is that AI has made it possible to turn "I wish this existed" into something you can test, share and use in an afternoon, even with no coding background. The catch is that not every tool gets you there in one step.

Based on this test, Claude is the one to trust for a first-pass app build, Gemini is a credible alternative if you're willing to tidy up the controls, and ChatGPT and Grok both need more hand-holding than a one-shot workflow allows.