I shipped an iPhone app entirely with AI in 30 days — what actually worked

The moment I knew the App Store would actually let it in, I was sitting on my kitchen floor at 11pm, refreshing App Store Connect for the eighth time. The email finally landed: Your app is now available on the App Store.

I shouted. My wife asked what happened. I tried to explain. It came out as: I made an iPhone app. I do not know how to make iPhone apps.

A few weeks later, a 12-year-old in one of my Saturday cohorts asked the same thing: "Wait — you made this?" And I realised the most valuable thing wasn't the app. It was the receipts: a real, shipped, on-the-App-Store project built by someone who, four weeks earlier, had never opened Xcode.

Here's what actually happened.

The app

[PLACEHOLDER: One-sentence description of the app — what it is and who it's for. Example: "A small daily-habit tracker called PocketCue that nudges you with one question each morning."]

I built it because [PLACEHOLDER: short reason — e.g. "I wanted something simpler than the habit apps I'd tried" / "my own kids needed it" / "I wanted a real artifact to show my adult students"].

You can find it on the App Store here: [PLACEHOLDER: App Store URL once published].

My starting point

I want to set the baseline honestly, because it matters for whether this story is useful to anyone else:

• Last time I wrote production code: many years ago, in a different language, in a different life.
• iOS experience: zero. I'd never opened Xcode. I didn't know what SwiftUI was. I genuinely thought "TestFlight" was a feature on actual aeroplanes.
• Daily tools at the start: a teaching laptop, an Anthropic account, a hand-me-down iPhone, and a fresh Apple Developer Program subscription (USD 99/year, the only real upfront cost).

If you can teach, write a clear email, and read English, your starting baseline is close to mine.

The stack

The whole thing ran on a small, surprisingly modern stack:

• Claude Code as the primary builder. This was the engine. It wrote the Swift, debugged the Swift, ran the Swift, and made me feel like the architect rather than the labourer.
• Xcode as the harness Claude Code drove. I opened it almost only to hit ⌘R.
• SwiftUI as the UI framework. I learned what it was in week one, by reading what Claude Code had written for me.
• [PLACEHOLDER: Backend or storage choice — e.g. "Supabase for auth + sync" / "SwiftData for local-only storage" / "No backend; everything's on-device"].
• TestFlight for beta testing.
• App Store Connect for the submission gauntlet.

Total monthly cost of the stack while building: roughly USD 20 (Anthropic Pro) + the one-time Apple developer fee.

The 30-day timeline

It was actually more like 28 days end-to-end, but "30 days" reads better. Here's how it broke down.

Week 1 — From idea to "wait, this works on a real phone"

The first day was a single prompt to Claude Code: "Build me a SwiftUI iOS app that does X. Pick the simplest possible architecture. Use only Apple frameworks unless we have to." It wrote a scaffold. Xcode complained about signing. Claude Code walked me through the signing dance. By the end of day two, I had a "Hello, world" version running on my own phone via cable.

By the end of week one, the core flow worked. Ugly, but worked. I texted screenshots to one friend who said "you made that?" in a tone that I think was meant as a compliment.

Week 2 — Real features

This is where the slope steepened. Adding the third feature broke the second. Adding the fourth broke both. Claude Code was unfazed; I was constantly. The lesson of this week was commit small, run often. Every working state got a git commit. Every bug got described to Claude Code in full sentences instead of one-word panic.

[PLACEHOLDER: One specific feature I'm proud of from this week — e.g. "the streak-counter animation" / "the notification-permission flow that doesn't feel scammy"].

Week 3 — Design and polish

The week I learned that "shipped" and "good" are different things. The app worked. The app was ugly. Claude Code helped me build a coherent visual system — typography, spacing, colours, a single accent — by describing the feel I wanted ("calmer than Notion, warmer than Apple's defaults"). It produced screens I'd never have arrived at on my own.

This week was also where I got the App Store screenshots, the icon, the privacy policy text, and the support page set up. All boring. All necessary. Claude Code drafted most of them; I edited.

Week 4 — Ship

Submitted to App Store review on day 24. First rejection on day 25 ([PLACEHOLDER: brief reason — e.g. "they wanted a clearer privacy disclosure" / "they wanted me to add a 'delete account' option"]). Fixed it the same evening. Resubmitted. Approved on day 28. Live on day 28.

5 things that actually worked

The honest list of patterns I'd recommend to anyone doing this:

1. Commit after every working change. This sounds like engineering hygiene, but it's actually survival. When Claude Code makes a change that breaks three things, the answer "go back to the last commit and try again" is the difference between calm and panic. Make this your only rule.
2. Describe in full sentences, not keywords. "Bug" is useless. "When I tap the streak button on day two, the count resets to one instead of two" is gold. The quality of your prompt is the quality of your fix.
3. Let it pick the boring stuff. Architecture, file structure, naming, error handling, accessibility scaffolding. Claude Code's defaults here are usually good. Don't override unless you know why.
4. Run on a real phone from day one. The simulator lies about things — gestures, scroll feel, keyboard behaviour. Cable, real device, every day.
5. Treat App Store review as part of the build. Read the App Store Review Guidelines before you submit. Most rejections are predictable. Mine was.

3 things I'd do differently next time

The honest list of things that cost me time:

1. I designed too late. I treated design as a "polish week" rather than a constraint from day one. Result: I rebuilt several screens because they didn't fit the visual system I eventually settled on. Next time, I'll pick the typography + colour + spacing system in week one, not week three.
2. I overbuilt the data model. I planned for features I never shipped. Claude Code happily produced complex schemas that turned out to be dead weight. Next time, I'll resist the urge to "make it future-proof" and just build for what's in the next two weeks.
3. I didn't have a real beta tester until week three. TestFlight was sitting right there. Next time, I'll get one person who isn't me using the build by day five. The bugs they find in twenty minutes are the bugs that would have eaten my whole week three.

What this means for what we teach

The reason I'm writing this isn't bragging rights. It's that the experience changed how I teach.

Before this app, I'd tell adult cohorts and ambitious teens that yes, you can build real things with AI — but I was teaching the abstract version. Now I can teach the concrete version. I've felt the panic of a broken build at 2am. I've debugged a SwiftUI ChartView I didn't understand. I've stared at an App Store rejection email and figured out what they actually wanted. Every lesson I teach is now grounded in something I've actually done.

If you're an adult learner wondering whether vibe coding can take you past "toy projects" — yes, it can. If you're a parent of a teenager wondering whether the skill compounds — yes, it does. The same Claude Code that built my iPhone app is the tool every cohort uses to ship their first web app.

If you want to see the Pathwise programs that teach this, or read the vibe coding primer that explains the philosophy, or just want the next cohort dates — they're all one click away.

The hardest part of shipping an iPhone app with AI wasn't the AI. It was deciding the app deserved to exist.

— Mr. Brown

---

PS — placeholders in this post ([PLACEHOLDER: …]) are the spots only the founder can fill: actual app name + description, the specific stack choices, one concrete pride-of-week-two feature, the real rejection reason. Replace before publish, or remove these notes if the post is being kept as a generic-but-honest founder reflection.