Hey r/iOSProgramming,

Long post — skip to whatever section matters to you.

**Why an affirmation app?**

Honest answer: I needed it.

Life has been quietly hard for a while. Not dramatically - just the accumulating kind. Full-time job, responsibilities, days that end and you struggle to find what actually went right. You do that long enough and it becomes the default mode.

I found affirmations almost by accident. Was skeptical - felt like self-help noise. Tried it for a few weeks anyway and noticed something shift. It didn't make hard things easy. It made them easier to start - which is a different thing.

So I built the thing I was already using. When you build something you actually use, you have real opinions about what the experience should feel like. That matters more than people admit when building solo.

The technical framing: this is not a complex domain. That was intentional. I've been a frontend architect for 13+ years - monorepos, distributed state, CI/CD, the usual. I wanted a side project focused on product thinking and delivery without the complexity overhead I deal with every day. Affirmations look simple. They're actually tricky in UX. The core loop - show meaningful content at the right moment, make it feel personal, help it become a habit - is easy to describe and hard to get right.

**The stack**

React Native with Expo. No backend - local storage for preferences, push notifications for daily reminders, content curation on the client.

Why not SwiftUI? I'm faster in React. That's it. No architectural purity award for choosing the "native" path if it doubles build time as a solo dev.

Expo has gotten genuinely good for this kind of app. Notifications, App Store submission pipeline, OTA updates - the operational layer was nearly invisible. I didn't have to become an iOS infrastructure expert.

**What AI actually did (and didn't)**

**Boilerplate and scaffolding**: Navigation structure, state management patterns, notification scheduling skeleton - AI got me 70-80% there on first pass. I'd describe the architecture in plain language and get back working code that needed review and adjustment, not full rewrites.

**Content structure**: I had a spreadsheet of \~200 affirmations across categories. AI helped categorize them, suggest tagging logic, and draft additional affirmations in specific tones. Hours saved.

**App Store copy**: Writing App Store descriptions is its own skill. AI produced a solid first draft. I rewrote maybe 40% for tone and accuracy, but the structure was already there - which is the hard part.

**Edge case surfacing**: When I described a feature - reminders that adapt to user timezone and don't fire during quiet periods - AI was good at listing edge cases I hadn't considered. Not implementing them. Just surfacing the question list. Genuinely useful.

Where it fell apart was judgment.

I asked AI to suggest the onboarding flow. The suggestions were functional and completely generic. Good UX requires knowing \*why\* someone opens an affirmation app at 7am - what emotional state they're in, what friction kills the habit before it forms. AI doesn't know this. I do - because I thought about it, lived it, and read about behavior design. I scrapped the AI onboarding and built it from scratch. Took longer. It's better.

Same with notification timing. The default suggestion: let users pick a time, remind them daily. Technically correct. Practically mediocre. The better call - three time slots for morning intention, midday reset, evening reflection - came from understanding the use case. AI can help you implement it once you've made that call. It can't make the call.

The notification scheduling code also had a subtle bug - it would occasionally double-schedule if the app was backgrounded at a specific moment. The AI-generated code looked correct. It wasn't. Fixing it meant actual debugging and working through Apple's background task lifecycle docs.

I've seen data that roughly 60% of AI-generated code has design flaws or security gaps, even with the latest models. Not a reason to avoid AI - a reason to treat every suggestion as a hypothesis to verify, not a spec to ship.

AI is fast at execution: syntax, familiar patterns, filling in the expected solution. When the problem needed judgment - when the obvious answer was wrong for this specific case - that was mine to make.

**The admin panel - where scope quietly expanded**

This deserves its own section.

I built a content admin panel early - just to manage affirmations without redeploying. Simple CRUD. But the further I went, the more I wanted.

Full content management. Rich media support - attach audio to a morning affirmation, add a video loop behind the text. The architecture stayed clean because I'd thought through the content schema early enough that it was flexible without retrofitting.

Here's the honest thing: I didn't plan any of this. It emerged from use. Because I was the primary user, I had real opinions. Specific ones. "This affirmation needs a voice reading for days when you can't focus." "This one works better with a slow background video." You only develop opinions like that by using the thing every day.

The admin panel became the most satisfying part of the build. Not because it's complex - it's not. Because it gives me full control over every dimension of the experience: text, audio, video, scheduling, categories. I can iterate on content the same way I iterate on code. Ship, observe, adjust.

I wanted that system. I just didn't know it until I was already building.

**What the shipping timeline actually looked like**

\- Weeks 1-2: Architecture, data model, content pipeline, notification approach  
\- Weeks 3-4: Core screens - home (today's affirmation), categories, favorites, settings  
\- Week 5: Onboarding - took longer than expected. Good onboarding is genuinely hard.  
\- Week 6: Notification system, timezone edge cases  
\- Week 7: Admin panel, media support (audio/video), App Store assets, TestFlight  
\- Week 8: Submission, review cycle, fixes, live

Total: \~8 weeks, 1-2 hours per weekday evening plus weekends. AI probably saved 20-30% on implementation time. The thinking - product decisions, UX calls, real debugging - didn't compress much.

**What I'd do differently**

1. Start with the notification UX earlier. It's the core retention mechanic. I treated it as a feature. It's the foundation - probably the single thing I'd prioritize differently if I started over.
2. User test the onboarding with 3 real people before building it. I had opinions. Real users had different ones. I iterated after launch when I should have done it before.
3. Write the App Store copy before finishing the app. Forces you to articulate the value proposition. If you can't write the copy, the product isn't focused enough yet.
4. Use AI for content generation from day one. I manually wrote the first 80 affirmations before realizing AI could help. Wasted time.
5. Build the admin panel on day one. If you're the primary user, you need control over every layer - content, media, scheduling. I built it in week 7. Should have been week 1.

**Is it worth it?**

Downloads are modest. But that's not what I check first.

My alarm is my morning affirmation now. That's the real outcome. Something I built, something I use every day, something that puts a small piece of goodness at the start of each morning and makes it a bit easier to get up and move. Users who've reviewed it say it feels thoughtful. That matters more than the vanity numbers right now.

The bigger return was the exercise: shipping end-to-end solo, with AI as a tool rather than a crutch, clarified which parts of development are actually hard. It's not the code. It's the decisions.

If any of this is useful - stack, AI workflow, admin panel architecture, App Store process - happy to go deeper.

How I built a Daily Affirmation iOS app solo - what AI actually did vs. what I still had to figure out myself