Building a Production-Ready Mobile App from Scratch with Codex and GPT-6 Astra: A Complete Workflow

AI coding tools can now help developers turn an idea into a real, App Store-ready mobile application. In this comprehensive tutorial, YouTuber Brock demonstrates how to use OpenAI's Codex powered by the GPT-6 Astra model to build an Instagram-like social app from scratch — covering every step from planning and design to development, testing, and App Store submission. He emphasizes that this workflow isn't the kind of casual "vibe coding" where you just tell an AI to build you an app. It's a repeatable methodology that can actually pass Apple's review process.

Planning Before Coding: The Critical Step Most Beginners Skip

The first step in this workflow isn't writing code — it's planning. Brock points out that many beginners, too excited to wait, jump straight into coding. The AI then starts guessing project details, and things quickly fall apart.

The right approach is to give the AI enough context upfront — defining your idea, goals, features, screens, user flows, and tech stack. He shares a "reverse interview" planning prompt: the AI asks you questions in batches (typically four at a time), drilling into every detail of your project until it has full context, then generates a plan.md document.

For the tech stack, this project uses Expo as the mobile framework (which the author calls "the best way to start a mobile app"), Clerk for authentication, Convex for the backend and database, NativeWind (Tailwind CSS for mobile) for styling, and Expo's Native Tabs component to get iOS's "liquid glass" effect out of the box — no custom styling required. All tools offer free tiers with no credit card needed.

When answering the AI's questions, Brock repeatedly drives home one product philosophy: V1 should be a minimal viable product (MVP). Cut complex features like push notifications and payments, get the core working first, then layer on more — a path he validated when building his own calorie-tracking app.

Expo is an open-source framework built on React Native that lets developers build iOS and Android apps simultaneously with JavaScript/TypeScript, with real-time device preview via the Expo Go client — no native build environment required. Convex is a Backend-as-a-Service (BaaS) platform whose key differentiator is built-in reactive queries: once a client subscribes to data, the server pushes updates automatically whenever data changes. This is the underlying mechanism behind the "real-time out of the box" experience mentioned throughout the article, eliminating the need to set up WebSocket connections or polling logic yourself. Clerk focuses on authentication, providing pre-built login UI components and OAuth integrations — developers simply copy environment variables to enable Google, Apple, and other third-party logins, dramatically reducing the complexity of building an auth system from scratch. NativeWind ports Tailwind CSS's utility-class approach to React Native, letting developers familiar with web development write mobile styles using familiar className syntax. All four tools share one key trait: free tiers that make them ideal for MVP-stage validation without any upfront investment.

UI Design: Generate Mockups First, Then Replicate Them

The design phase uses a clever "image-to-image" workflow. First, use a prompt to have ChatGPT or Gemini generate a "prompt for generating UI designs" based on plan.md. Then paste that prompt into a new conversation and use GPT's newly released image model (referred to in the tutorial as image 2.5) to generate complete screen designs and a design system.

The design system image is especially important — it contains all components, color palettes, and typography. The AI agent can reference it directly when implementing screens, making execution far more accurate than searching through scattered references.

The key to implementation is the loop workflow: have Codex take a simulator screenshot, compare it against the design mockup, and keep iterating until the two nearly match before moving to the next screen. This loop is used throughout the entire development process.

Brock is refreshingly pragmatic about AI: "Most people want perfect results on the first try, and when they don't get them, they give up and say AI doesn't work. But it's still AI — you need to follow up a few times and give it references to get satisfying results." He also admits AI has limits: "The bigger the project gets, the harder it struggles" — which is why having basic coding knowledge still matters. But for building an MVP, it genuinely delivers.

Backend and Real-Time Features: Convex's Out-of-the-Box Capabilities

Authentication is handled through Clerk — just copy the publishable key from your environment variables and let Codex follow the documentation to complete the integration. Notably, Codex (running the GPT-6 Astra model) can operate the computer itself, clicking through the simulator to test and verify functionality, achieving a high degree of automation.

The backend runs on Convex, whose standout feature is real-time functionality out of the box. Whether it's likes, comments, or direct messages, changes on one end immediately reflect on the other — no refresh needed. Brock demonstrated this on a real device: send a message on the phone, and the simulator receives it instantly; likes and follows sync in milliseconds.

For model selection, Codex offers reasoning effort levels from medium and high to extra high and ultra. The author's recommendation: use medium or high for less critical features, and reserve extra high or ultra for core functionality that needs precise implementation — keeping in mind that higher effort means longer wait times. He personally prefers Codex over Claude and Cursor, citing better pricing and the strong performance of the GPT-6 model.

The "Hidden Barriers" Before Launch: Compliance and Quality Checks

This section contains what Brock considers the most valuable — and most expensive-to-learn-the-hard-way — insights in the entire tutorial.

Apple's review process has several hard requirements, none of which can be skipped:

• Account deletion functionality: Required whenever you store user data
• Sign in with Apple: Mandatory if you offer any other third-party login (e.g., Google)
• Privacy policy and terms of service: Must be deployed to a real, accessible URL
• Support URL: Required when submitting through App Store Connect

Brock reveals that getting rejected on the first few submissions is normal for most people — but his app passed on the first try, precisely because this workflow covered every detail.

He also demonstrates using AI to generate a privacy policy, terms of service, and a landing page, then using shots.so to create polished device mockup images, and finally deploying everything online with Cloudflare Pages and the wrangler CLI in a single command.

For code quality, he brings in CodeRabbit for AI-powered code review — using Git branches and pull requests to let the AI scan the entire codebase and surface security vulnerabilities and style issues that are easy to miss with the naked eye.

Some background on Apple's requirements is worth understanding: the account deletion requirement became mandatory in June 2022, driven by Apple's commitment to user data sovereignty — users have the right to demand complete deletion of all their data from a platform. The Sign in with Apple requirement stems from a policy Apple established when it launched the feature in 2019: any app that integrates third-party logins (Google, Facebook, etc.) must equally offer Apple Sign-In as an option, preventing Apple users from being forced to tie their accounts to third-party platforms. The privacy policy URL requirement reflects compliance pressure from GDPR, CCPA, and similar privacy regulations, which Apple has incorporated into its review standards to limit platform liability. Missing any one of these triggers an outright rejection — not just a warning — which is why the author calls them "hidden barriers": the rules are scattered across documentation, and newcomers often need to be rejected once or twice before systematically tracking them all down.

Engineering Details: Skills, AGENTS.md, and Error Monitoring

To avoid manually typing long "enter loop mode" prompts every session, Brock created reusable Skill files stored in .agents/skills and .claude/skills directories that are automatically loaded at the start of each session.

He also thoroughly explains the purpose of AGENTS.md and CLAUDE.md — these serve as a "README" written for the AI agent, storing project conventions and architectural rules (e.g., "always use Native Tabs"). Loaded into context automatically at session start, they effectively prevent the AI from backtracking on established decisions.

The final piece is error tracking and monitoring via Sentry. Brock articulates a real pain point: when a bug appears after launch, users won't bother contacting you — they'll just delete the app and leave a one-star review. Sentry automatically sends email alerts when errors occur and provides structured logs, session replay recordings, and performance tracking. Unlike console.log output, which lives only on the user's device and disappears when the app closes, Sentry's logs are stored in the cloud, searchable, and linked to errors and replays. He even integrates Sentry's user feedback component, allowing users to submit feedback directly within the app.

AGENTS.md and CLAUDE.md are essentially persistent system prompts for AI agents. Most AI coding tools clear their context window at the end of a session, meaning the next time you start a new session, the AI has no knowledge of your project's architecture and is prone to making decisions that contradict established conventions. These files sit in the repository root and are automatically read by the tool at the start of every session, effectively prepending your project documentation before every prompt. This mechanism is especially important for long-term projects: as the codebase grows, it becomes increasingly difficult for AI to infer architectural intent from code alone, and explicitly stated conventions (e.g., "use Native Tabs for routing, don't introduce React Navigation") effectively prevent AI from introducing inconsistent patterns during refactoring or feature additions. Sentry, as an error monitoring platform, delivers its core value by transforming production errors from "users silently leaving" into "developers proactively knowing." The Session Replay feature records the sequence of user actions leading up to an error, reducing the cost of reproducing a bug from hours to minutes.

Conclusion

The value of this tutorial isn't in replicating the exact same app — the author repeatedly notes that because AI output varies each time, the final UI and code will differ. The real takeaway is understanding the complete workflow: from planning and UI design to feature implementation, compliance, testing, and App Store submission. For developers and entrepreneurs looking to rapidly validate product ideas with AI, this is a rare end-to-end roadmap from concept to launch. Following the author's pace, the entire process from zero to App Store submission takes approximately 14 days.