Nick Saraev delivers a 4-hour comprehensive course on building real, production-ready mobile apps using nothing but Claude Code and natural language prompts. The course takes you from absolute zero — no prior mobile development experience required — all the way to App Store and Play Store submission.
Three complete apps are built during the course, each progressively more complex: a habit tracker (local storage only), an AI-powered tracker (Supabase database + authentication + API integration), and a Pomodoro timer (full production deployment with everything combined). The progression follows a deliberate learning ladder: local storage → database → auth → APIs → deployment.
Nick runs a $300K/month business built almost entirely on Claude Code, lending significant credibility to his approach. The core thesis: with the right tools and workflow, anyone can build and ship mobile apps that compete with — and often surpass — what professional developers produce.
Nick opens the course not with theory but with a live demonstration. He pulls out his iPhone and shows a fully functional habit tracker app running natively. Then he flips to his development machine and shows the exact same app running locally through Expo Go — a perfect mirror of what's on the phone.
What the Demo App Includes
Onboarding flow — A polished welcome screen sequence that introduces the user to the app's purpose and guides them through initial setup
Habit creation — Full form with name input, frequency selector (daily, weekly, custom), and a beautiful color picker for visual organization
Tracking interface — A list view of all habits with tap-to-complete interactions, showing today's progress at a glance
Progress visualization — Visual progress bars and completion indicators showing streaks and weekly/monthly stats
Smooth animations — Native-feeling transitions and micro-interactions that make it feel like a professional, polished product
Key point: The entire demo app was built in less than 5 minutes using Claude Code with prompt templates. Nick emphasizes this upfront to set expectations — this isn't about spending weeks learning frameworks.
The strategic purpose of this demo is powerful: by showing the finished product first, Nick establishes the quality bar and motivates learners. You see exactly what you'll build, and it looks genuinely impressive — not a toy "hello world" app but something that could credibly appear on the App Store.
Before writing a single line of code (or prompt), Nick lays out the fundamental architecture of any mobile application. This conceptual grounding is essential — even when Claude Code generates the code, understanding what you're building helps you direct Claude effectively.
What Every Mobile App Needs
A database — Somewhere to store user data, whether local (on-device) or remote (cloud server). Without persistence, your app forgets everything when closed.
Read/write access — The ability for the app to retrieve stored data and save new data. This is the CRUD (Create, Read, Update, Delete) foundation.
Modification capabilities — Users must be able to change their data: edit a habit name, update a timer setting, delete an entry.
A meaningful UI — An interface that makes the database interactions intuitive, beautiful, and accessible. The UI is the user's window into the data layer.
Optional: Authentication — User accounts, sign-up/login flows, session management. Needed when data is user-specific and cloud-stored.
Optional: API integration — Connecting to third-party services (AI models, payment processors, analytics, push notifications).
Optional: AI features — Using language models or other AI services to add intelligent capabilities to the app.
The Course Progression Ladder
Nick introduces a deliberately structured learning path that adds complexity incrementally across three apps:
1
🟢 App 1: Habit Tracker
Local only. No API, no database server, no authentication. Data stored on-device with AsyncStorage. Focus: UI, navigation, Claude Code workflow.
2
🟡 App 2: AI Tracker
Adds Supabase database, authentication (email/password + social), and API integration for AI features. Focus: cloud backend, auth flow, state management.
3
🔴 App 3: Pomodoro Timer
Combines everything. Full backend, auth, session history, statistics, and production deployment. Focus: speed, patterns, App Store submission.
Framework Choice: React Native + Expo
Nick explains why React Native with Expo is the optimal choice for AI-assisted mobile development in 2026:
Zero-config setup — No Xcode, no Android Studio, no complex build chains. Expo abstracts all of it away.
Cross-platform — One codebase runs on both iOS and Android. Write once, deploy twice.
Hot reload on real devices — Change code, see the result on your phone in seconds via Expo Go app.
Simplified App Store submission — EAS (Expo Application Services) automates the build, signing, and submission process that used to take days of painful configuration.
Claude Code compatibility — React Native + Expo has excellent representation in Claude's training data, meaning Claude generates high-quality, idiomatic code for this stack.
JavaScript/TypeScript ecosystem — Massive package ecosystem, tons of community resources, and a language that Claude handles exceptionally well.
Why not Flutter, SwiftUI, or Kotlin? Nick addresses this directly: while those are excellent frameworks, Expo's zero-config approach and Claude's strong React Native knowledge make it the clear winner for AI-assisted development. The goal is shipping apps, not framework mastery.
A thorough walkthrough of every tool you need installed and configured before building your first app. Nick keeps the tooling minimal — no bloated IDEs or complex configurations.
Required Tools
Claude Code
VS Code extension or desktop app. This is your primary development tool — you'll write prompts, not code.
Node.js
JavaScript runtime required by React Native and Expo. Install the LTS version for stability.
Expo Go App
Install on your iOS or Android phone. This is how you preview your app live on a real device during development.
Git + GitHub
Version control for tracking changes and required for deployment pipelines (EAS Build).
Setup Walkthrough
Install Node.js from the official website or via a package manager like nvm (Node Version Manager) for easy version switching
Install Expo CLI globally: npm install -g expo-cli — this gives you the expo command in your terminal
Create a new Expo project: npx create-expo-app my-app — scaffolds a complete React Native project with sensible defaults
Start the development server: npx expo start — generates a QR code in your terminal
Open Expo Go on your phone, scan the QR code, and watch your app appear live on your device
Open the project in VS Code with Claude Code extension, and you're ready to build
Key insight: You develop on your computer, but the app renders live on your phone via Expo Go. Every code change appears on your device within seconds. This tight feedback loop is crucial for rapid iteration with Claude Code — you can see immediately whether Claude's output looks right.
Nick also covers the first code change — modifying the default "Hello World" text to "Hello Nick" 10:33 — to verify the development pipeline is working end-to-end. This simple change confirms: code editor → save → hot reload → phone displays update.
The first full build of the course. Nick constructs a complete, polished habit tracking app from scratch using only Claude Code prompts. No manual coding, no copy-pasting from StackOverflow — just natural language descriptions fed to Claude.
Features Built
Onboarding Flow
Multi-screen welcome sequence introducing the app, explaining benefits, and getting the user started with their first habit.
Habit Creation
Full-featured form: name input, frequency selector (daily/weekly/custom schedule), color picker for visual categorization.
Habit List & Tracking
Main screen showing all habits with today's status. Tap to mark complete. Visual distinction between done/pending.
Progress Visualization
Progress bars, streak counters, and completion percentages giving users motivation and insight into their habits.
Local Data Persistence
AsyncStorage saves all habit data on-device. App remembers everything between sessions without any server.
Navigation System
React Navigation for multi-screen flow: onboarding → home → create habit → habit detail → settings.
The Claude Code Workflow
This section reveals the core methodology that the entire course is built on:
Scaffold with a prompt template — Start with a structured prompt that tells Claude what kind of app you're building, the tech stack, and high-level features. Nick uses pre-made templates that he's refined over hundreds of projects.
Describe the features — Write natural language descriptions of what you want each screen and interaction to do. Be specific about behavior but not about implementation details.
Claude generates components — Claude writes the React Native components, styles, navigation logic, and data management. Complete, runnable code from each prompt.
Test live on phone — Every change is immediately visible on your phone via Expo Go. Verify the output looks and works as expected.
Iterate and refine — Describe changes: "make the buttons bigger", "add a gradient background", "the animation should be smoother". Claude implements each refinement.
Navigation Architecture
Nick demonstrates how React Navigation handles multi-screen apps. Claude generates all routing and screen setup, including:
Stack navigator for linear flows (onboarding sequence)
Tab navigator for main app sections
Modal presentations for create/edit screens
Deep linking support for notifications
Proper back button behavior on both iOS and Android
Styling & Design Quality
One of the most impressive aspects is getting production-quality UI through natural language. Nick shows iterative refinement:
"Make the header larger with a gradient from purple to blue"
"Add subtle shadows to the habit cards"
"The completion animation should have a satisfying bounce effect"
"Use a modern, clean design language similar to Apple Health"
Data Persistence with AsyncStorage
For App 1, all data lives locally on the device using React Native's AsyncStorage 19:29. This is a key-value storage system similar to localStorage in web browsers. Claude handles the save/load logic, error handling, and data serialization automatically.
Lab Notes and Failure Documentation
At 26:03, Nick introduces an important practice: documenting what goes wrong. Not everything Claude generates is perfect on the first try. He keeps "lab notes" of:
Prompts that didn't produce the desired result
Common failure modes and how to work around them
Patterns that consistently produce better output
Edge cases that Claude misses and need manual attention
Advanced Prompt Techniques for UI
At 34:38, Nick dives deeper into prompting strategies specifically for UI generation. Techniques include referencing well-known apps ("make it look like the Todoist create screen"), describing animations precisely, and using design vocabulary (padding, margin, border-radius) when needed for pixel-perfect results.
Key stat: "I was able to build a better app than 90% of what's currently available on the App Store in about an hour using a $20/month subscription." — This is the central value proposition of the entire course.
The complete habit tracker app is built in roughly 1 hour of the course. Nick plays with the finished product at 1:00:05, demonstrating every feature working smoothly on his phone.
With App 1 complete, Nick pauses to establish proper version control. This isn't just good practice — it's a requirement for the deployment pipeline that comes later.
Why Version Control Matters for Mobile Apps
Track changes over time — See exactly what Claude changed in each iteration. Essential for understanding your codebase.
Revert if something breaks — Claude sometimes introduces regressions when fixing one thing. Git lets you roll back instantly.
Share with team members — If you're working with others (or hiring a developer to help), Git is the standard collaboration tool.
Required for EAS deployment — Expo Application Services pulls from your Git repository to build your app. No Git = no automated deployment.
Branching for experiments — Try risky changes on a branch. If they work, merge. If not, delete the branch. Zero risk.
Git Walkthrough
Nick walks through the complete Git workflow at 1:01:09:
git init — Initialize a Git repository in your project folder
git add . — Stage all files for commit
git commit -m "Initial commit: habit tracker app" — Save the snapshot with a descriptive message
Create a new repository on GitHub.com
git remote add origin <url> — Connect local repo to GitHub
git push -u origin main — Push your code to GitHub
Nick also shows how Claude Code can handle Git operations for you — you can say "commit these changes with a descriptive message" or "push to GitHub" and Claude will generate and execute the commands.
The transition from local-only to cloud-backed is the biggest architectural leap in the course. Nick explains why you need a real database and then introduces Supabase as the ideal solution.
Why Local Storage Isn't Enough
Data lives only on one device — Switch phones and everything is gone. No backup, no sync.
No multi-user support — Can't have different users with different data on the same app.
No server-side logic — Can't send notifications, process data in the background, or enforce business rules.
No analytics — Can't understand how users actually use your app without server-side data collection.
Limited scalability — Local storage has size limits and no indexing for complex queries.
Why Supabase
Nick makes a strong case at 1:05:20 for Supabase as the backend of choice:
Generous Free Tier
500MB database, 1GB file storage, 50,000 monthly active users. Enough for most indie apps.
PostgreSQL Core
Real relational database under the hood. Not a toy — it's the same technology powering Instagram, Spotify, and Netflix.
Built-in Authentication
Email/password, social logins (Google, Apple, GitHub), magic links, phone auth — all pre-built and configurable.
Real-time Subscriptions
Data changes push to connected clients automatically. Perfect for collaborative or live-updating features.
Row Level Security (RLS)
Database-level security policies ensuring users can only access their own data. Critical for multi-user apps.
Claude Knows It Well
Supabase has excellent representation in Claude's training data. Claude generates idiomatic Supabase queries, schemas, and auth flows with high accuracy.
Create a new project — choose a name, set database password, select region
Grab the API URL and anon key from project settings
Install the Supabase JS client: npm install @supabase/supabase-js
Configure the client in your app with the URL and key
Tell Claude to design the database schema and write the migration SQL
Run the migration in Supabase's SQL editor
Migration Pattern: Local → Cloud
One of the most practical demonstrations: Claude rewrites the data layer from AsyncStorage to Supabase while keeping the UI completely intact. The user experience doesn't change — but the backend is now cloud-powered. This pattern of "swap the backend, keep the frontend" is a powerful architectural principle.
The second app represents a major step up in complexity. It's not just a UI with local storage anymore — it's a full-stack application with a cloud database, user authentication, and AI-powered features.
Architecture Layers
Supabase database — Persistent cloud storage with relational data model
Authentication — Sign up, log in, user sessions, protected routes
API integration — Connecting to AI services for intelligent features
Complex state management — Managing authenticated user state, loading states, error states, optimistic updates
Planning Before Building
Nick introduces a critical new step at 1:33:35: architectural planning with flow diagrams. Before writing any prompts, he works with Claude to create:
User flow diagrams (what screens exist, how users navigate between them)
Data model diagrams (what tables exist, relationships between them)
Authentication flow (sign up → verify → log in → session → protected routes)
API integration plan (what endpoints to call, when, what data to send/receive)
Insight: For simple apps (like App 1), you can jump straight into building. For complex apps with multiple systems (database + auth + APIs), spending 15-30 minutes planning with Claude saves hours of rework later.
MVP Ideation Pattern
At 2:13:39, Nick demonstrates the MVP ideation process:
Brainstorm with Claude — Describe your app idea in broad terms. Claude helps refine it, suggests features, identifies potential challenges.
Define the feature set — List everything the app could do. Be ambitious.
Prioritize ruthlessly — What's the minimum viable product? What 3-5 features make the app useful?
Build incrementally — Start with the highest-priority features. Add more in subsequent versions.
Authentication Flow
Supabase Auth handles the heavy lifting. Claude generates the complete authentication system including:
Sign-up screen with email/password and input validation
Login screen with error handling and "forgot password" flow
Social logins — Google, Apple ID integration via Supabase
Protected routes — Redirecting unauthenticated users to login
User profiles — Storing and displaying user-specific data
Logout — Clean session teardown
AI Feature Integration
The "AI-powered" aspect of App 2 involves calling an AI API to provide intelligent features. The specifics depend on the app concept brainstormed during the MVP ideation, but the pattern is consistent:
User inputs data → app sends to AI API → receives intelligent response → displays to user
Claude generates the API call code, error handling, loading states, and response parsing
Key consideration: API key management (never hardcode in the app, use environment variables or server-side proxy)
Testing on Real Devices
Nick heavily emphasizes testing on actual phones throughout development — not just browser simulators or emulators. The reasoning:
Touch interactions feel different than mouse clicks
Network conditions on mobile are less reliable
Screen sizes and safe areas vary by device
Performance characteristics differ from desktop browsers
Authentication flows (especially social login) behave differently on real devices
The capstone app combines every technique from the course into a single, production-ready application. The Pomodoro timer isn't just a timer — it's a full productivity app with backend, auth, history, and statistics.
A key observation: App 3 is built significantly faster than App 1 or App 2, despite being more complex. The reasons:
Pattern recognition — You've seen the Supabase setup, auth flow, and navigation patterns twice already
Refined prompts — Your prompt templates are now battle-tested and produce better results
Muscle memory — The Claude Code workflow (prompt → test → iterate) becomes second nature
Reusable components — Auth screens, database configuration, and navigation setup can be copied/adapted from previous apps
Key point: The learning curve compounds — the investment in understanding patterns during Apps 1 and 2 pays massive dividends in App 3. This is the core argument for the progressive complexity approach.
Before any app goes to the App Store, it needs thorough testing. Nick's approach is practical, not academic — he focuses on the tests that actually catch real bugs in AI-generated mobile apps.
Testing Checklist
Real device testing — Every feature must work on a physical phone, not just an emulator. Touch targets, scroll behavior, and performance can all differ.
Database operations end-to-end — Create, read, update, delete. Verify data appears in Supabase dashboard after creating in the app.
Authentication flows — Sign up with a new email. Log out. Log back in. Close the app and reopen — session should persist. Test "forgot password" flow.
Edge cases:
What happens with no internet connection?
What do empty states look like (no habits, no sessions)?
What happens if the user enters very long text?
What if the user rapidly taps a button multiple times?
What happens when the app is backgrounded and resumed?
Performance — App should feel smooth. No jank, no lag, no white screens between navigation transitions.
Both platforms — If targeting both iOS and Android, test on both. Supabase social login behavior can differ.
Pre-Submission Checklist
At 3:00:08, Nick covers what to verify before hitting "Submit":
App icon and splash screen are set and look professional
App name, description, and keywords are finalized
Screenshots are captured for all required device sizes
Privacy policy URL is live (required by both stores)
All test data is cleared — no debug screens or placeholder content
Version number and build number are set correctly
Performance is acceptable on older devices (not just your latest phone)
Nick emphasizes: "Test before deploying — every feature should work on a real phone before you consider submission." Apple's review team will find issues you missed, and rejections cost time.
The moment everything has been building toward: getting your app on the Apple App Store. Nick walks through the entire process from build to submission, demystifying what used to be one of the most painful parts of iOS development.
Prerequisites
Apple Developer Account — $99/year. Required to submit to the App Store. No way around this.
App Store Connect — Apple's portal at appstoreconnect.apple.com for managing your apps, viewing analytics, and responding to reviews.
EAS CLI installed — npm install -g eas-cli — Expo's command-line tool for building and submitting.
Configure eas.json — Define build profiles (development, preview, production) with appropriate settings for each stage.
Run eas build --platform ios — EAS builds your iOS binary in the cloud. No Mac required! The build runs on Expo's servers and produces a signed IPA file.
Wait for build completion — Usually 10-30 minutes. You get a URL to track progress.
Set up App Store Connect 3:52:07 — Create your app listing with name, subtitle, description, keywords, screenshots, app icon, privacy policy, and content rating.
Configure API key 3:55:49 — Create an App Store Connect API key and configure it in EAS for automated submission.
Run eas submit --platform ios — Automatically uploads the build to App Store Connect. No manual uploading through Xcode or Transporter.
Submit for review — In App Store Connect, click "Submit for Review". Apple reviews typically take 24-48 hours.
Submission is confirmed at 3:56:12 — Nick shows the "Waiting for Review" status in App Store Connect.
Key revelation: "Submitting to the App Store used to be incredibly painful. With EAS, it's mostly automated." — The combination of Expo + EAS has reduced what used to be a multi-day, error-prone process to a few terminal commands.
Common Rejection Reasons to Avoid
Missing privacy policy
Broken links or placeholder content
App crashes on launch (test on real devices!)
Login required but no demo account provided for reviewers
Incomplete metadata or misleading screenshots
Using private APIs (unlikely with Expo, but worth checking)