The Ultimate Claude Code Tutorial for Mobile Apps — FULL COURSE (Extended Deep Dive)

🎯 What You'll Build

"If you want to build and launch a real mobile application using AI, this tutorial is for you. We are not building some random demo application — we are building a modern AI trip planner that you can run on your actual phone, share with your friends, and even use as a real product." 0:00

The instructor's credibility anchor: "I built and deployed my own mobile app to the App Store in only 14 days — a calorie tracker called BulkyAI — and got my first customer 5 days after launch. That's the proof." 0:30

Feature	What it does
Authentication	Google + Apple sign-in via Clerk (email disabled; you can add more providers)
4 Native Tabs	Home, AI Assistant, Trips, Profile — with iOS liquid glass effect
AI Trip Generation	Location, dates, budget, travelers, interests, pace → OpenAI generates a full trip in the background
Day-by-day itinerary	Places, activities, budget breakdown, hotel suggestions, and an interactive map
AI Assistant	Chat to modify trips ("make it more relaxed", "add local food", "lower budget") or general travel questions
Trips tab	Every generated trip, viewable and deletable
Profile	Account details, logout, delete account (full DB cleanup)
Rate App button	App Store review prompt
Legal pages	Landing page + privacy policy + terms + support (deployed on Cloudflare)

The delete-account feature is NOT optional: "if you want to deploy to the App Store, this is a feature you have to have. Otherwise Apple will reject your application." The same goes for privacy policy, terms of service, and a support page — all built later in the course. 2:40

This is NOT a vibe-coding tutorial: "we are not going to randomly ask AI 'build me a mobile app and don't make any mistakes.' Those prompts almost never work." Instead: a structured, repeatable workflow — the same one that shipped BulkyAI in 2 weeks. 3:42

🧰 The Tech Stack

"We're using some of the best tools out there." All of them have free tiers — you don't need to pay anything to follow along. 4:46

Tool	Role	Key note
React Native + Expo	Mobile framework	"Genuinely one of the best ways to get started" — the exact stack BulkyAI used
Clerk	Authentication	"Pretty easy to integrate, production-ready" — Google/Apple/email SSO
Neon	Postgres database	Cloud-hosted, no server management
Drizzle	ORM	Chosen over Prisma ("Drizzle is just going to be my option")
Inngest	Background jobs	Trip generation + experiments (A/B model routing)
Sentry	Error tracking & monitoring	Real-user errors → email alerts → fix before others hit it
ImageKit	Image optimization	Compresses/optimizes cover images for speed
CodeRabbit	AI code review	Scans codebase, flags issues + exact fixes
Unsplash	Place images	Real city photos by location (Tokyo → Tokyo, not a beach)
OpenAI	Trip generation model	Cheapest "mini" model used for V1 (Gemini free alternative)
NativeWind	Styling	"Tailwind for React Native" — v4 stable over v5 pre-release

The only prerequisite: Node.js (nodejs.org). That's it. Everything else is set up inside the workflow. 6:35

Budget reality check: "feel free to spend at least $20/month on one of these tools (Claude/Cursor/Codex/Windsurf/Gemini)." Worst case: Codex is ~$8. "If you're smoking, stop smoking to afford one of these." The free plan "is just for exploration, not enough to build this kind of app." 9:17

🔄 The Structured Workflow

"Before we write a single line of code, first we plan and describe our entire project to AI." This is the core loop that repeats for every feature. 11:26

Plan — define idea, goals, features, pages, user flow, tech stack. "Spend the first day on the plan. If you don't know what you're building, how would AI know?"
Design — use a structured prompt to generate the UI: screens, layouts, visual style, and a design system.
Break into features — one screen at a time (auth → home → assistant → trips → profile).
Implement — build one feature with Claude Code.
Test manually — you check it yourself first (run the app, click everything).
AI code review — run CodeRabbit to catch security/correctness issues you and Claude both missed.
Fix → loop — if there are issues, go through the fix loop until clean.
Commit — save progress via a feature branch → PR → merge to main.

The #1 beginner mistake: "they just want to immediately jump into coding. Dude, you don't have a plan. First decide everything — tech stack, features, design. Only then can AI not guess anything." 48:30

📝 Phase 0 — Planning (Plan Mode)

Claude Code has modes: plan mode (plan a feature or project), edit automatically (edit files without asking), and ask before edits (permission before every action — "the one to start with, then switch to edit automatically once you understand it"). 17:50

Always track with Git: "be careful — Claude can sometimes delete files. You always want to keep track of every file with Git." 18:20

The Plan-Mode Prompt (project-agnostic)

"You are my senior technical co-founder and product architect. I'm about to build a new software project and I want us to be in complete alignment before writing any single line of code. The job of the AI is not to write code initially, but to interview us about the entire project."

The goal: "AI doesn't guess any feature, but instead asks me all kinds of questions." Example questions it asked: which AI model generates trips? separate Node backend or Expo Router API routes? poll DB vs push notification? what does a generated trip contain? place photos or text-only? real map? ORM choice? generation limits? platform scope (iOS only)? ImageKit role? inputs on the form? what does a returning user see? 24:30

Key decisions the interview surfaced: Expo Router API routes (no separate backend) · poll DB for trip-ready status · day-by-day itinerary + budget breakdown + places + hotel suggestions · LLM text-only (no place photos for V1) · Apple Maps (no API key, iOS only) · Drizzle ORM · free V1 · ImageKit for profile photos + trip cover images. 25:20

A beautiful follow-up from Claude: after he chose "LLM text-only", Claude noticed — "you listed ImageKit for image optimization, but text-only means no place photos to optimize in V1." This kind of cross-checking is exactly why the interview matters. 29:20

Never auto-accept the plan: "it's very important not to say yes before reading the entire plan. Take 5-10 minutes, read it, and decide — there will definitely be something you don't like." In his case: the plan suggested EAS hosting for Inngest endpoints, but he wanted the Inngest dev server first ("we don't want to deploy to EAS hosting at the start"). He referenced "R1" (risk 1) and asked to change that one point. 38:10

Output → plan.md: once approved, "Claude generates a list of to-dos, everything in different phases." He stops it and asks Claude to "put it under a plan.md file with every phase as a list of to-dos. As we complete features, we mark them completed." This file becomes the living source of truth for the whole project. 40:30

🔑 Environment Variables

"What I'd like to do is create the .env file from the start — put all the environment variables so AI can implement everything instead of waiting for us." He provides a .env.example file in the source code. 41:20

Variable	Source	Count
Clerk	Clerk dashboard → API keys	3 (publishable, secret, webhook signing)
Database	Neon dashboard → Connect	1 (URL, no quotes)
OpenAI	platform.openai.com → API keys	1 (or Gemini for free)
Unsplash	unsplash.com/developers → new app	2 (access + secret)
Inngest	Inngest dashboard → keys	2 (signing + event; dev needs none)
ImageKit	ImageKit dashboard → developer options	3 (URL endpoint, public, private)
Sentry	Sentry dashboard → auth token	1

Security: add .env to .gitignore "so we don't push our secrets to GitHub." And always copy the value without quotes from Neon ("only get the value, don't include the quotes"). 41:45

🌿 The Git + PR Workflow

"For every single feature, instead of committing directly, we create a separate branch. Implement it, ask AI to review it, add commits until fixed, then push to main via a pull request. This is the workflow you'd follow in a real company." 45:20

Create a feature branch (e.g. authentication, auth-db-sync, create-trip)
Stage everything + get an AI-generated commit message
Publish the branch → create the pull request
CodeRabbit reviews the PR (scans every changed file — one PR was 43 files, another 12,000 lines)
Fix valid suggestions (skip the ones you disagree with) → commit under the same branch
Merge the PR → switch to master → sync latest changes

The very first commit is an exception — "we don't really need a separate branch for the initial commit; just push it to main." 45:00

One task at a time for fixes: "copy every single CodeRabbit prompt and paste under one instance? Not great. Always better to give one task at a time — open a new instance per issue, fix them in parallel." 39:00

🎨 UI Design with GPT Image

Design happens before code. He uses GPT Image (any image model works: Gemini, etc.) with prompts he provides as links. "You design every screen one by one, then you give the design system — typography, color palette, style, components, and the goal of the app." 49:30

Generating a prompt from your plan: "generate me a prompt for UI design image generation for my app based on the plan.md file" — reference local files with @filename. Then paste the resulting prompt into GPT and add "aspect ratio 16:9" for horizontal images. 51:30

The 9-variation trick (used constantly): take a screenshot of a screen → "generate me a grid of nine images of different UI for this screen" → pick one you like → "upscale this one" → put it in your design/ folder. He used it for the home screen, trip detail, and even logos ("generate a grid of nine logos… actually a world icon… upscale this without text, transparent background"). 56:10

Background images: "generate me this background image so I can use it — no text, no logos." Then later "make the background transparent so I can use it in my application." Saved as PNGs (e.g. auth-screen-background.png, world.png, trip-loading-screen). 52:10

Design system image too: "generate an image of the design system for this application — colors, font family, components." This becomes the reference Claude compares against while building. 53:20

📄 agents.md vs claude.md

Two plain-markdown instruction files auto-loaded into the AI's context at session start. 71:20

File	Who reads it	Purpose
`claude.md`	Claude Code only	Claude-specific instructions
`agents.md`	All AI coding tools (Cursor, Copilot, Codex, Gemini CLI, Claude)	Agent-agnostic project instructions

His recommendation: build agents.md (agent-agnostic), and in claude.md put a single reference: "read the agents.md file for initial instructions." 72:20

What goes inside: tech stack (Postgres/Neon, Drizzle ORM, ImageKit, Clerk, Inngest, Sentry), conventions (use className not inline styles), and hard rules — e.g. "always use native tabs, never JavaScript tabs" and "never run the application by yourself, I'm already running it in a separate terminal." Don't know what to put? Ask Claude: "depending on my project, what should I have in agents.md?" 73:20

🔐 Auth Screen (Clerk)

Before coding, the app is bootstrapped with npx create-expo-app@latest . (SDK 56 at recording time), then npm run reset-project to delete the template ("No, just delete" when it offers to move files to an example folder). 13:50

Clerk Skills

"Skills are installable packages that give AI coding agents specialized knowledge about Clerk — once installed, our agent can help add authentication, manage orgs, sync users, and more." Install via the Clerk docs → "Claude skills" → copy the command, or paste the markdown and say "install the skills needed for this project." Claude skipped 17 of ~20 as not applying to this project. 56:50

Expo Dev Client vs Expo Go

Expo Go is for testing only: "if you're building a real application, Expo Go is not enough — some native modules don't work with it." Install the Expo Dev Client and run with npx expo run ios (or android). This is what BulkyAI used. 59:30

NativeWind + Sentry setup

Paste NativeWind docs → "read the entire documentation step by step and implement it correctly, then double-check." For Sentry: create a project, run the Sentry wizard CLI (or copy the docs → "set up Sentry in my project"), and add the auth token from Sentry → Organization tokens. 64:20

The "copy the docs to your LLM" pattern (repeated all course): "on every single documentation, we have this button — copy all the instructions and paste it to our LLM." Used for NativeWind, Sentry, Inngest, and Clerk. "As of 2026, you don't read docs — you copy-paste them to the LLM." 66:10

Clerk Dashboard

Create application "triply tutorial" → disable email, enable Google + Apple (free plan = 3 providers) → grab env vars from the Expo quick-start → tell Claude "I have the environment variables for Clerk, implement Google and Apple auth, make sure to read the skills since they're the official documentation." Test: sign in with Google → redirected to home screen with first name + email → verify the user appears in the Clerk dashboard. 80:20

Both providers work via the same useSSO hook — "everything is coming from Clerk Skills. If Apple fails, screenshot it, paste to Claude, and say 'Google works but Apple doesn't — fix it.'" 84:20

🔁 The Verify Loop

The single most important pattern in the course. Every screen is built by putting Claude into a self-comparing loop. 62:10

"Put yourself into the loop: take a screenshot from the simulator, compare it to the design, and go through this until it is identical."

Implement the feature / UI design
Tell Claude to take a screenshot from the simulator
Compare it to the reference design image
If not identical → Claude gives itself feedback and rebuilds (repeat)
When ~80-90% identical (never 100% — it's AI), jump into code and tweak manually

Real example (auth screen): first try looked off → "it keeps getting better — the screen rendered but button backgrounds and layout are missing" → then "this is wrapping to three lines, make it only two" → finally "very, very similar." Then manual tweaks: remove the email button and the tagline text. 78:00

Manual tweak example (home screen): Claude couldn't push the world image to the right-hand side — "this is where you jump into code and fix it manually" (edited index.tsx, changed the value to 58). "AI gets it 80-90% — then you finish it." 102:30

📡 Webhooks & User Sync

The critical concept for AI/vibe coders: "a user signs up via Clerk and is stored in the Clerk dashboard — but we also have a database. How do we save the user there too? The solution is webhooks." 92:00

"Webhooks are automated messages sent when something happens. In this case: when a user is created, updated, or deleted."

Clerk dashboard → Configure → Developers → Webhooks → Add endpoint
URL = ngrok domain + /api/webhooks/clerk
Subscribe to user.created, user.updated, user.deleted
Copy the signing secret → paste into .env (clerk_webhook_signing_secret)
Inngest runs a "sync-user" background job that upserts the user into Neon

The full flow: user signs up with Clerk → Clerk sends an event to our API route → we verify it → Inngest runs a background job → mutation upserts the user into the database. Test: delete the user in Clerk, re-sign up, and watch the user appear in the Neon users table. 93:30

Verify end-to-end: "delete this user, sign up from scratch. Clerk fires user.created, Inngest saves it to the database." The delete test: delete the user in Clerk → new run appears in Inngest → user gone from Neon. 106:50

🔌 ngrok + Context7

Two utilities that make the webhook workflow possible. 95:50

Tool	What it does	Why you need it
ngrok	Gives a production-ready public URL for your local API	Webhooks need a real URL, not localhost — Clerk can't reach your laptop otherwise. Free plan = 1 URL.
Context7 (by Upstash)	Feeds up-to-date documentation to your LLM	"One of the best tools out there" — always-fresh docs for any tool. Append "use Context7" to a prompt.

Context7 setup is itself AI-driven: "I want you to set up Context7 by Upstash in my laptop for every single project." Just ask, and it sets it up. Then end prompts with "use Context7" to pull live docs for the tool you're using. 96:30

⚙️ Inngest Background Jobs

The trip generation runs async — the mobile app polls the DB for status while Inngest generates the trip in the background. 107:10

Development mode first: "we're using the dev server for now — I don't think about the production key until I'm ready to ship." Start it with npm run inngest (or the command Claude gives). In production you need two keys (signing + event), but "in development you don't need a key." 99:50

The Inngest dev server UI shows every function and run with full detail — "the entire breakdown of what's happening, what data you're feeding, and how long it takes." You can see user.created and user.deleted runs in real time. 107:30

🧭 Native Tabs (Liquid Glass)

"Native tabs are the feature that gives us the iOS liquid glass effect." Four tabs: Home, Assistant, Trips, Profile. 115:00

Implementation: copy the entire native-tabs page from Expo docs → paste to Claude → "implement native tabs in my application: four tabs — home, assistant, trips, profile. First build the UI, not functionality. For the design, look at this image and use world.png. Put yourself into that previous loop." 118:20

The home screen follow-ups: "make world.png a bit larger, sticky to the right-hand side of the blue box, and add extra spacing at the bottom so native tabs don't overlap the popular destinations." (Then the manual index.tsx fix when Claude couldn't push it right.) 121:00

🗺️ Trip Generation

The core feature. The "get started" form collects place, dates, budget (budget-friendly/comfort/luxury), travelers, interests, and pace. Then OpenAI generates the trip in the background. 124:00

Unsplash for real place images: "you type Tokyo, Japan — you want to see an image of Tokyo, not New York or a beach." Get an access key + secret key from unsplash.com/developers, then the trip's cover image is the actual city photo. 125:30

ImageKit for optimization: three env vars (URL endpoint, public key, private key — set a password the first time you reveal the private key). A 5MB image gets compressed/optimized so "your application feels incredibly fast." The media library shows a triply/covers folder auto-created by Claude. 128:20

Unsplash attribution: "if you're using Unsplash images for free, give attribution — that's what they ask." The trip detail screen shows an attribution line. 139:30

The trip detail UI wasn't right at first: "definitely not what I'd like — the UI doesn't match our referenced images." He re-ran the verify loop with the reference design until "almost identical" — including the floating AI button, the map, and the itinerary. 135:20

The 5-day bug: "we said 5 days, but the itinerary only shows day one." Fix: "make sure OpenAI outputs the same duration as the user input." After the follow-up, "day by day, in total 5 days." 140:10

🐛 Sentry Deep Dive

Why Sentry? "When your users face errors, 99% of the time they'll just delete the app and leave a one-star review — 'app doesn't work' — and you have no idea which feature." Sentry is "your app's watchtower." 159:40

Feature	What it does
Error catching	Automatically catches errors and reports crashes
Sentry Logs	"Console.log, but structured" — searchable, persisted in the cloud (vs console.log which dies when the app closes)
Session Replays	A video recording of what your user saw when the error happened
Traces	Performance: throughput + latency, bottlenecks
AI Agent Monitoring	Tracks token usage, latency, tool usage, error rates of your AI calls — "fully connected to your logs, errors, traces"
Alerts	Real-time — email by default, or Slack/Discord for teams

The checkout example (his favorite): 50k users, e-commerce, 500 daily checkouts, some fail. With console.log you get nothing. With Sentry: "show me all logs related to payment that are errors, city X, last 24 hours." You stop guessing, start knowing. 163:50

Logger methods (6): debug, error, fatal, info, trace, warning. Error under catch, info under if ("let you know everything is done"). 167:20

Session replay config: one line — mobileReplayIntegration in the root layout. He set maskAllImages: false and maskAllText: false so images/text show in the dashboard. 170:20

AI agent monitoring in action: "when to visit Istanbul?" → Sentry dashboard → Explorer → LLM calls → see cost, tokens, model, input, output. "A really good dashboard to analyze how your users use the assistant — general questions or travel-related?" 178:20

💬 Assistant + Streaming

Build the assistant screen with the same verify loop ("attach the design, put yourself into the loop, screenshot → compare → until identical"). First try nearly nailed it — "just a small issue: extra spacing. Delete it." 172:40

Streaming instead of spinner: "instead of a loading spinner, I want the messages chunk by chunk — streamed." Implemented with a ReadableStream and stream: true. Then: "reset the input as soon as we send the message." 174:20

Persist messages to DB: "everything works, the only missing thing is storing messages in the database — save them, and the delete button should clear them for the current user (with a confirmation first)." Claude created a separate assistant_messages table (distinct from chat_messages used for trip refinement). 180:40

🧪 Inngest Experiments

"A situation every developer hits: your code works, but you want to try a different version — a new payment provider, a faster query, or a different AI model." 185:30

"If I swap it for everyone and it's worse — slower, more expensive, breaks more — all my users feel the pain at once."

group.experiment lets you run two versions of the same code simultaneously and decide per-request. "Use the old way 90% of the time, the new way 10%." His example: GPT-4o mini at 90%, GPT-4o at 10% (smarter but more expensive). 187:30

Benefit	Why
Low risk	Bad version hits 10% of users, not 100%
Real data for free	Inngest already tracks duration, failure rate, cost per run
Decide on facts	Metrics in the dashboard, not guesses
Easy to dial up	Just change two values — 10/90 → 50/50

Implementation prompt: "Inngest has the experiments feature, docs below. Use GPT-4o mini at 90% and GPT-4o at 10%. Read the documentation and implement correctly without breaking anything." 190:50

👤 Profile & Account Deletion

Profile screen shows account details, logout, delete account, and a rate-app button. Built from two attached design images (before/after scroll) with the verify loop. 192:00

Delete account = full cleanup: "when the user presses that, first ask a confirmation; if confirmed, delete the user from both Clerk and the database. The DB deletion is handled by webhooks — make sure to delete all user data: trips, chat messages, etc." 193:00

Bypass mode (mentioned late): "annoying that you give access every single time — there's a bypass mode where Claude edits automatically without asking." 192:20

⚖️ Legal Pages + Cloudflare

Privacy policy, terms of service, and support page are "not optional — you have to have them to deploy to the App Store." 193:50

Mockups with shots.so

"For beautiful mockup images, visit shots.so — free tier is enough." Select a template (iPhone 17), white/transparent background, upload your simulator screenshots, export. Then put them in a legal/ folder. 195:00

Building the landing page

Prompt: "we've built the mobile app — now the landing page. I'll attach UI-inspiration.png. Clone it, build the landing screen. Deploy the legal folder to Cloudflare Workers for free — use only HTML and CSS, no external tech. Keep it simple, yet working." 198:50

Image compression tip: "these images are 5MB — you don't want that. Ask Claude: 'use FFmpeg and compress this image — install FFmpeg if I don't have it.'" He uses FFmpeg on nearly every image in BulkyAI to avoid shipping large files. 200:00

Privacy + Terms prompts

Project-agnostic prompts (provided as links) generate the full legal text. "Claude can't put your legal entity, contact address, or minimum age — you'll see placeholders to update." 203:20

Deploy to Cloudflare Workers

Wrangler CLI: "go ahead and deploy the legal folder to Cloudflare. I've already authenticated using the Wrangler tool." If not authenticated, ask Claude "how can I authenticate with Wrangler?" It's free. Result: a live production URL with privacy, terms, and support pages. 205:40

🍎 App Store Tips

Throughout the course, the instructor drops App Store requirements you must know before deploying. 2:40

Delete account is mandatory — Apple rejects apps without it.
Privacy policy + terms of service + support page are mandatory — build them (Cloudflare is free).
Rate limiting — add a daily cap (e.g. 20 generations/user/day) so you don't blow your OpenAI budget.
Unsplash attribution — required when using free images.
Permission prompts — e.g. gallery access ("Allow Triply to access your photos so you can set a custom cover image") — declare it in app.json.

🚑 Errors Encountered & Fixes

The course is honest about things breaking. Here's the complete troubleshooting log — a goldmine for anyone following along. 0:00

Error	Cause	Fix
Dev build failed on first `npx expo run ios`	Sentry not yet set up	Set up Sentry first
"Couldn't start your trip — unauthorized"	Missing Clerk secret key	Add Clerk secret key to .env, restart app
Trip generation failed	Missing OpenAI API key	Create key on platform.openai.com, add to .env, restart
Inngest dev server error on first visit	Stale cache	Restart Expo with `npx expo start --clear`
Only 1 day in a 5-day itinerary	OpenAI returning 1-day plan	"Make the output match the user's duration"
World image not sticking to the right	Claude hit a layout wall	Manual fix in `index.tsx` (set value to 58)
Two trips after one generation	One run failed (missing key)	Delete the failed record — won't recur after fix
Chat messages not in DB	Claude used a different table	Check `assistant_messages` (separate from `chat_messages`)

The universal error-handling prompt: "I get this error when running X. What is wrong? Let me know AND fix the issue." Always ask why first — "next time you get this error, you'll know why it's happening." 67:50

🏁 The Final Challenge

The one feature left unbuilt — deliberately. 207:40

"There is one feature we haven't implemented. It's been more than 3 hours — by everything you've learned, you should be able to implement it pretty quickly. I've attached the Refine AI UI design."

The challenge: the "Refine AI" screen — the AI button inside the trip detail that lets a user ask modifications to the current trip ("make it more relaxed, add local food, lower budget"). Workflow: build it → CodeRabbit review → commit → done. If you don't like the attached design, "take a screenshot, ask GPT for a grid of nine, pick your version." 207:40

💡 Key Takeaways

Plan first, code second. The #1 beginner mistake is jumping into coding without a plan. Spend a full day on the plan — AI can't guess what you haven't decided.
Interview your AI. Plan mode with "you are my senior technical co-founder" makes the AI ask questions instead of guessing features.
The verify loop is everything. Screenshot → compare to design → rebuild → repeat until ~80-90% identical, then finish manually.
Copy-paste docs to the LLM. "As of 2026, you don't read docs — you copy them to the LLM." Used for NativeWind, Sentry, Inngest, Clerk.
Skills give the AI domain knowledge. Clerk skills, Context7, and agents.md all pre-load knowledge so Claude doesn't hallucinate APIs.
AI code review catches what Claude missed. CodeRabbit found issues Claude couldn't see by default — "a different senior engineer with a security mindset."
Feature branches + PRs, even solo. This is the "real company" workflow, and it's what makes the 2-week launch possible.
Webhooks are non-negotiable. The Clerk → Neon user sync is the concept "you must know" as an AI/vibe coder.
Observability from day one. Sentry logs, traces, replays, and AI-agent monitoring turn "users deleting the app" into actionable data.
Ship with experiments. Inngest's 90/10 model routing lets you test a new AI model on 10% of users risk-free.
App Store compliance is a feature, not an afterthought. Delete account, legal pages, attribution, rate limits — all built-in, not bolted on.
Know the fundamentals, use AI for speed. "Learn how to use AI while still knowing the fundamentals" — you still need to jump into code to finish the last 20%.

📍 Full Timestamp Index

0:00 Project preview

6:20 Planning + tools setup

49:38 UI design & auth screen

1:37:28 Webhooks & background jobs

1:56:01 Native tabs, home screen, trip generation

2:40:31 Sentry, assistant, trips screen

3:07:02 Profile screen & legal pages