Every week, I share iOS tips on how to create polished, intuitive apps—backed by insights from shipping seven apps and working at GoPro, Apple, and Microsoft. My desk setup: https://blog.supereasyapps.com/181-ios-developer-and-productivity-tools-plus-standing-desk-setup/
Problem: a macOS app ran under Rosetta on Apple silicon. Approach: with Codex, locate Intel-only targets and update Xcode settings to build arm64/Universal and update dependencies. Verify the binary runs natively. Caveats: third-party binaries, Homebrew paths, codesigning. Takeaway: ship native before Rosetta ends.
Introduces AppCreator, a downloadable skill that pairs with OpenAI Codex to help you create your first iOS or macOS app. Focuses on AI-assisted setup and scaffolding rather than specific frameworks or APIs. Takeaway: download the tool to quickly bootstrap an Apple platform app as a beginner.
Overview of Codex Plugins unifying Skills, Apps, and MCP in one place. Points to an “app creator” Skill and shows how these plugins can simplify building and integrating features. Takeaway: faster path to AI‑powered app capabilities by wiring skills/apps through MCP.
A brief on defining your app’s visual style before starting UI design. Emphasizes researching and curating visual references to establish a consistent look and feel, enabling clearer decisions and faster implementation later. Conceptual planning step; no specific iOS APIs or code involved.
Overview of a workflow for building apps faster using Codex and GPT‑5.4. The video focuses on leveraging AI assistants for code generation and rapid iteration to accelerate app creation. Takeaway for iOS developers: AI can boost prototyping speed, but always review, validate, and test generated code.
High-level overview of GPT-5.4 and its implications for developers. Covers the “official unification” release, what it changes, and potential effects on app-building workflows and product features. Takeaway for iOS devs: reassess AI/ChatGPT integration strategy and tooling as GPT-5.4 rolls out.
Walkthrough of building a weapon system and enemy-creation workflow for a shoot ’em up (Red Interceptor) using SpriteKit alongside the creator’s Codex 5.3 setup. Emphasizes organizing game logic and a repeatable process for defining weapons and enemies within SpriteKit. Practical guidance for iOS game developers refining their SpriteKit production workflow.
A brief showcase of building a small game in a weekend using Codex 5.3 for code generation. Emphasizes rapid prototyping and iteration with AI-assisted coding and minimal boilerplate. Caveat: review and optimize AI-generated code for quality and performance. Takeaway: AI tools can accelerate iOS side projects and game prototypes.
Live demo of building a top‑down shoot ’em up (Raptor: Call of Shadows) using GPT‑5.3‑Codex‑Spark to generate and iterate on code. Showcases an AI‑assisted workflow for rapid prototyping and refinement via prompting. Takeaway for iOS devs: LLMs can speed exploration, but require iterative validation and fixes.
Join a game jam leveraging GPT-5.3-Codex-Spark with Cerebras hardware to build a game using Codex. Focus is on AI-assisted coding and rapid prototyping. Takeaway for iOS developers: explore LLM-supported workflows for game creation and consider infrastructure/hardware needs when integrating such models.
Reacts to the GPT-5.3‑Codex‑Spark release and its implications for AI coding tools. Emphasizes major latency reductions (“no more waiting”) and how faster LLM responses could improve code generation, autocomplete, and debugging workflows. Takeaway for iOS devs: expect snappier AI assistants in IDEs and CI, enabling quicker iterations.
Overview of OpenAI’s GPT-5.3-Codex-Spark, a Cerebras-powered real-time coding model optimized for speed over deep reasoning. Emphasizes ultra-fast responses for coding workflows with a trade-off in depth. Takeaway for iOS devs: great for rapid code assistance, less ideal for complex, reasoning-heavy tasks.
Overview of the newly launched GPT-5.3-Codex model. The creator reports it’s notably faster than GPT-5.2 and shares five key takeaways. For iOS developers building AI features, the speed gains could reduce latency and improve UX—consider evaluating this model for your workflows.
First look at Codex App for app development, focusing on interacting with and controlling AI agents. Highlights a unified “one control” to steer agent behavior and workflows. Conceptual overview—no specific iOS APIs or code. Takeaway: consider agent-driven tooling to speed up iOS development tasks.
Demo of GPT-5.2 Codex building a new app feature with minimal prompts. Over about an hour, it often one-shots feature requests. Targeted at Mac/iOS developers, it showcases an AI-assisted coding workflow for rapid feature implementation and prototyping, highlighting how LLMs can accelerate development.
A risky refactor on an experimental branch mangles Git history in a Mac app project. The creator uses GPT-5.2 Codex to diagnose issues and recover the repo, with guidance on branch strategy, conflict resolution, and history cleanup. Demonstrates how AI can assist version-control recovery and prevent data loss for Apple developers.
Demonstrates a real macOS development workflow in Xcode using GPT-5.2 Codex to fix and extend a transcription app built with the Whisper SDK. Focuses on integrating the SDK, iterating on features, and using AI assistance to debug and enhance speech recognition on macOS.
Getting-started guide to Thomas’s Codex Skill Manager. Shows setup and basic use, compatible with Codex, Claude Code, Open Code, and GitHub Copilot. Focus is on organizing and reusing skills to streamline AI‑assisted coding workflows.
Intro to Codex Agent Skills: package scripts and prompts into reusable capabilities so agents can perform repeatable tasks. Covers creating and organizing skills, configuring inputs, and invoking them in workflows. Takeaway: modularize agent behavior for reliable, maintainable AI features in apps.
Explains why many apps fail pre-launch: vague product definition and unclear App Store listing. Shares a 5-step App Store checklist to clarify the idea, tighten messaging, and polish listing assets before submission, improving review readiness and conversion—practical guidance for first-time iOS launches.
Explains how to replace a rejected build in App Store Connect. In the Build view, use the small button to remove or swap the build attached to your submission, then upload or select a new build and resubmit. Useful for resubmitting without creating a new app version after a rejection.
What to do when AI-generated (Codex) code breaks your iOS app. The video covers diagnosing what failed, isolating the AI’s changes, reverting or fixing them, and adding safeguards like tests and code review to prevent regressions. Takeaway: treat AI output as untrusted—validate thoroughly and use disciplined debugging and recovery practices.
Walkthrough of a practical App Store launch workflow used while an app is in review: preparing metadata/screenshots, product page and marketing, coordinating timing, and handling submission in App Store Connect. Offers a repeatable checklist to ship new apps with fewer last‑minute scrambles.
Live walkthrough of using Codex within Xcode to diagnose and fix real bugs in a vanilla iOS project. No special setup—see an in-IDE workflow applying AI-assisted suggestions and iterative edits to resolve issues. Takeaway: a practical approach to speeding up Xcode debugging using an AI coding assistant.
Intro to automating iOS CI/CD with Xcode Cloud and TestFlight. Shows enabling Xcode Cloud in Xcode, creating workflows to build and run tests on commits, configuring triggers and artifacts, and distributing builds to TestFlight for beta testing—streamlining builds, testing, and distribution from Xcode.
Behind-the-scenes look at using Codex 5.2 to rapidly prototype and ship an app in a day. Emphasizes AI-assisted coding: prompting, iterating, and assembling features quickly. Takeaway for iOS devs: leverage LLM tooling to accelerate scaffolding and experimentation, reducing time from idea to working build.
Live coding session demonstrating a practical workflow with Codex 5.2 to build a developer tool. Shows prompting, iterative code generation, refactoring and testing loops, and how to supervise AI output. Takeaway for iOS devs: use AI assistants effectively by constraining tasks, reviewing diffs, and validating code incrementally.
Explains why AI agents can write Swift but fail to build and run iOS apps. Introduces an MCP tool that lets an agent drive Xcode build/run steps via command line, addressing project and environment hurdles. Walks through setup and workflow, with cautions about configuration. Takeaway: enable LLMs to actually build and run your app.
Explains why AI code from Codex can break builds and how to prevent it: keep a known‑good baseline, apply suggestions in small steps, read and fix compiler errors early, revert quickly, and prefer small, testable changes. Aimed at newcomers struggling with early failures; key takeaway is to control AI output to keep builds green.
Live session improving a spider‑detection ML app. Compares GPT‑5.2 Codex output with a production approach, touching on dataset refinement, threshold/label tweaks, evaluation of precision/recall, and edge‑case handling. Takeaway: iterative, metrics‑driven tuning and better data outperform one‑shot AI‑generated code.
Walkthrough of using Codex GPT 5.2 alongside Xcode to cut time lost to build errors. The author shares 3 workflows to diagnose and fix iOS/macOS compiler/build issues and keep builds green, plus what the agent needs to operate effectively within your Xcode workflow.
Walkthrough of a practical ML workflow to build a dangerous spider detector, using Codex to assist coding. Covers dataset preparation, labeling, training/iteration, evaluation, and managing false positives. Takeaway: how to structure and iterate an image-recognition pipeline useful for AI-powered app features.
The creator asks Codex 5.1 Max to upgrade a macOS timer app, showing prompts, generated code, build fixes, and where AI sped up refactors versus produced errors or missed context. It highlights validation and debugging steps and practical workflow tips. Takeaway: AI can accelerate Mac app work but still needs human oversight and corrections.
Demonstrates GPT 5.1 Codex Max diagnosing and fixing a stubborn Swift bug the author couldn’t solve. Shows AI-driven code analysis to pinpoint the issue and propose a patch via prompt-driven debugging. Takeaway: LLMs can accelerate Swift bug fixing, but developers should review and test AI-suggested changes.
Side-by-side comparison of GPT-5.1 Pro, GPT-5.1 Codex Max (High), Gemini 3, and Grok 4.1 on identical coding tasks to evaluate code quality and reliability. Offers takeaways on strengths/weaknesses to help choose an AI coding assistant. No iOS-specific APIs covered.
Demonstrates brewing a clean, sweet single-cup Hario V60 using the Brew Coffee iPhone app, Brew Coffee. Focuses on step-by-step, in-app guidance to achieve consistent pour-over results.
A personal account of reaching 10K steps every day for a year, crediting daily use of the StepUp Retro Pedometer app. This appears to be an end-user testimonial with no iOS development techniques, APIs, or code shown. Takeaway: consistent, simple tracking can motivate habits—no technical guidance provided.
This video is a brewing guide for Hario V60 coffee and promotes using an app to improve consistency. It does not discuss iOS development concepts, code, or APIs, and offers no technical takeaways for iOS developers.
Two Apple insiders react to WWDC 2025, recapping headline changes in iOS 26 and discussing the “Liquid Glass” design direction. High-level takeaways and implications for iOS developers; no code—useful for understanding platform shifts and upcoming UI trends.
Sneak peek of a coffee brewing app introducing new Hario V60 recipes and discussing how apps can help improve V60 technique (inspired by James Hoffmann). The video appears product-focused; no iOS-specific implementation, APIs, or architecture are described.
Preview of upcoming Brew Coffee updates built with SwiftUI and UIKit. Highlights how the app combines both frameworks to evolve UI and features, with notes on interop and migration in a production app. Takeaway: practical ideas for iterating an app that mixes SwiftUI with existing UIKit code.
Live 45‑minute build creating a budget widget UI with SwiftUI and Swift Charts. Covers setting up Chart in SwiftUI, binding budget data, configuring chart components, and styling/layout for compact spaces to visualize spending at a glance. Takeaway: a quick jumpstart to chart‑driven UIs for simple finance summaries.
Tutorial on localizing SwiftUI iPhone apps and iOS widgets using Xcode 16 String Catalogs. Covers organizing localized strings, adding languages, and applying them in SwiftUI with Xcode’s built-in translation workflow. Takeaway: adopt String Catalogs to streamline localization across app and widgets.
An Apple engineer walks through building a simple sleep-tracking app in SwiftUI. You’ll compose views, handle state, and wire basic navigation to add and review entries using common SwiftUI patterns. A hands-on intro to building a small app UI with SwiftUI components and state management.
Overview of Xcode 16.3 release notes highlighting what’s new across the IDE, toolchain, and SDKs for iOS developers. Summarizes updates, fixes, and improvements to help decide when to upgrade. Note: Xcode 16.3 requires macOS 15.2+ to install.
Learn to create a Swift Package that wraps Objective‑C code with Swift Package Manager: organize .m/.h sources, expose public headers via an include/ folder, configure targets/products in Package.swift, and integrate in Xcode. Caveat: no bridging headers—use module-style headers. Ideal for modularizing legacy Obj‑C across apps.
Live coding session building Brew Coffee, a pour‑over iOS app, with SwiftUI. Follow end‑to‑end app construction: creating screens, layout, and interactions while iterating quickly. Focus is on practical SwiftUI workflows in Xcode to prototype and ship a small app.
Introduces Apple’s Swiftly 1.0: a lightweight way to install the latest Swift toolchain without needing Xcode. Explains setting up Swift outside Xcode-centric workflows to run/build Swift from the command line, and when this is useful. Notes tradeoffs versus Xcode’s bundled toolchains and IDE features.
Walkthrough of building complex SwiftUI animations in the Brew Coffee app, revised to handle a variable number of stages. Focuses on structuring animation logic so sequences aren’t limited to a fixed count, leveraging SwiftUI’s animation system. Takeaway: design adaptable, stage-driven animations that scale with dynamic steps.
Reminder: there’s only one day left to apply for an exclusive in‑person Apple Park invite to WWDC25. The video urges developers to submit before the deadline. This is a scheduling/update announcement with no technical or coding content.
Tackles debugging SwiftUI animation glitches and layout jumps. Shows practical steps to reproduce and isolate issues, audit state updates, position animation logic correctly, and stabilize layout transitions—so views animate smoothly without unexpected jumps. Key takeaway: structure state and updates predictably to avoid glitches.
Tutorial on configuring a green screen in Meld Studio using the Chroma Key effect. Focuses on dialing in the key by adjusting Threshold and Tolerance to cleanly remove the green background. Practical, tool-based walkthrough with no coding—suitable for basic compositing setup.
Live hackathon building Brew Coffee, a pour‑over companion iOS app, using SwiftUI and Swift. Shows iterative construction of screens and app logic with SwiftUI views. Practical look at assembling a real app UI and workflow. Takeaway: hands‑on SwiftUI app building.
Intro to SwiftUI layout spacing: use the padding modifier to add inner space (.padding(), per-edge, custom amounts, EdgeInsets) and control gaps via stack spacing (VStack/HStack). Demonstrates how padding works with backgrounds/frames. Takeaway: use padding for internal space, stack spacing for gaps.
A week-long review of using ChatGPT Pro alongside Xcode. Assesses how AI assistance impacts coding speed, boilerplate, and troubleshooting, where it falls short due to inaccuracies, and the level of oversight required. Offers a grounded verdict on whether the hype matches its value for iOS developers.
Demonstrates using the new ChatGPT app integration on macOS with Xcode to directly edit and iterate on code. Shows how prompts can modify files to speed up implementation and refactoring. Takeaway: combine ChatGPT with Xcode for faster workflows, but always review AI changes, run builds/tests, and consider privacy/security.
Compares Apple’s new Mac Studio options—M3 Ultra vs M4 Max—to determine which is the better buy. Weighs performance vs price and who each model suits. Takeaway for iOS developers: pick based on build/test workload needs and budget rather than specs alone.
Beginner tutorial on debugging Swift code in Xcode 16. Walks through identifying a stubborn bug and using Xcode’s debugger to reproduce, inspect state, and fix issues. Covers core workflow and tips to speed diagnosis. Ideal for newcomers needing a step-by-step bug-fix process.
Explores whether GPT‑4.5 can generate a working macOS app in ~30 minutes by prompting it to produce code and iterating quickly to compile and run. Highlights what AI can automate vs. where human guidance is needed. Takeaway: AI can speed up scaffolding, but developers must review, fix, and refine.
Tutorial builds a Swift app that identifies spiders using OpenAI’s image recognition. It shows making REST calls with URLSession to send image data, managing API keys, parsing JSON responses, and displaying species info. Notes typical caveats like latency, costs, and accuracy limits of cloud AI. Takeaway: integrate AI image recognition into your iOS apps quickly.
Beginner-friendly walkthrough to build a simple motivational iOS widget with SwiftUI from scratch. You’ll set up a widget target in Xcode, design the SwiftUI view, provide quote text, preview, and add it to the Home Screen—an easy first step into widget development for new iOS developers.
A 3.5-hour beginner course guiding you through building your first iPhone app with SwiftUI. Learn to start a project in Xcode and compose interfaces using SwiftUI fundamentals. Ideal for newcomers seeking a practical, step-by-step introduction to iOS app development.
Announcement for an upcoming beginner course, “iPhone Apps 101,” focused on building iPhone apps with SwiftUI. The video shares that the course and sample code will be available, but provides no technical details. Expect a beginner-friendly SwiftUI intro and downloadable code.
Kickoff video for a beginner SwiftUI course focused on building iPhone apps. It introduces the learning roadmap for SwiftUI app development and points to downloadable code resources. Aimed at newcomers starting their first iOS app.
Intro to iPhone Apps 101 using SwiftUI and Xcode 16. This welcome lesson introduces the course, the tools you’ll use, and where to get the code/resources. Takeaway: get set up with SwiftUI in Xcode 16 and start building iPhone apps.