Developing iOS apps since 2009. Former Staff iOS Engineer at WeTransfer, Amsterdam. - Blogging weekly at avanderlee.com - Former Staff iOS Engineer at wetransfer.com, leading the development of the iOS apps with millions of monthly active users. - Tweeting daily about Swift, iOS, and Xcode at twitter.com/twannl - Curating articles for the SwiftLee Weekly Newsletter - Courses via courses.avanderlee.com
AGENTS.md doesn’t scale across projects. Agent Skills package reusable domain knowledge via SKILL.md + references. Install/sync with openskills to auto-wire skills into AGENTS. Example: a Swift Concurrency skill with decision trees and project checks (Swift 6, actor isolation). Works in Cursor/Codex for consistent AI help.
AI-generated app icons are often flat, unlayered, and not production-ready. Rebuild them with Xcode’s Icon Composer: apply Liquid Glass, layers/groups/shadows, and follow current iOS icon guidelines. AI is useful for inspiration; human-led composition delivers premium icons.
Antoine reflects on his first full indie year: launching a Swift Concurrency (async/await) course, rapid RocketSim for Teams growth, and adopting AI agents with SwiftLint/SwiftFormat to speed development. With blog reads down, he’s shifting to YouTube/newsletters. 2026: more AI, multi‑app plans.
Antoine van der Lee kicks off a YouTube series documenting the full journey of turning an app idea into 10K MRR. Expect real-world decisions and trade-offs: validating and killing ideas, building proofs of concept, audience research, and deciding when to monetize—sharing lessons as they happen.
Antoine recaps 9 months of his Swift Concurrency course: 73 lessons, updated for Swift 6.2’s approachable concurrency. Text-first lessons stay current via a GitHub feedback loop. Team adoption is growing. He’s running a country-based pricing survey.
Explains iOS lifecycle (foreground, background, suspended, purged) and why force‑quitting apps hurts battery by turning warm resumes into cold launches. Trust iOS to manage memory. Developers: track Energy Impact in Xcode Debug Navigator/Organizer, use Instruments, and optimize cold starts with caching/background tasks.
Seven essential Xcode setup changes: enable Approachable Concurrency (MainActor), review Upcoming Features, switch to Swift 6, remove unused targets, tune build settings (incremental/O0, WMO), add an App Group early, and structure folders/SPMs—to prevent bugs and tech debt.
SwiftLee’s Black Friday: 50% off the Swift Concurrency Course (updated for Swift 6.2, 73+ lessons) and RocketSim Pro. RocketSim adds 30+ Simulator tools—URLSession inspector, network throttling, UserDefaults editor, push permission reset, camera testing. Discounts Nov 24–30.
Swift 6.2’s Approachable Concurrency is an Xcode build setting that eases async/await: progressive disclosure and @MainActor‑by‑default. Migrate flags individually; in SwiftPM use .enableUpcomingFeature. Note: nonisolated async run on the caller’s actor unless @concurrent.
Introduces NotificationCenter’s MainActorMessage and AsyncMessage for concurrency-safe, strongly typed notifications (iOS 26+). Shows migrating addObserver/post, defining custom messages with Subject, main-actor synchronous delivery vs async arbitrary isolation, and threading changes.
RocketSim streams your Mac (or Continuity Camera) to Xcode’s iOS Simulator so you can test camera flows without a device. Uses your existing AVCaptureSession—no code changes. Works for barcodes/Vision. Install, grant permissions, add RocketSimConnect, and run.
Speed up Xcode builds by measuring first: Build Timeline and Build Timing Summary (xcodebuild -showBuildTimingSummary). Gate slow Run Script phases by CONFIGURATION, enable Swift type-check warnings (-warn-long-*), tune build settings, try Eager Linking/parallel scripts, audit SwiftPM plugins. Faster incremental builds.
SwiftUI bodies often bloat as features grow. Instead of hiding code in extensions, extract dedicated Views, build reusable ViewModifiers for common styling, and add generic View extensions to compose sections. Rule of thumb: extract when a UI piece has a clear purpose and reuse potential.
Use Swift’s migration tooling to adopt upcoming features via Xcode’s 'Upcoming feature' Migrate builds with fix‑its. Enabling nonisolated(nonsending) by default can push work to the main thread—add @concurrent to keep prior behavior. Avoid manual migration.
Highlights 5 common Swift Concurrency mistakes when moving to Swift 6: treating async for-loops as normal, assuming async runs off the main thread, ignoring Task cancellation, risky manual migrations, and spawning tasks in onAppear—leading to UI hangs, dup calls, battery drain.
Many iOS devs misuse Xcode’s Derived Data. Learn what it stores, open it fast via Settings → Locations, and delete only a project’s folder (not all). Mine Logs/Build for metrics (XCLogParser, RocketSim), compare incremental vs clean builds, and inspect Build/Products .app to prune bloat and speed up teams.
Real-world ASO for RocketSim: choose relevant keywords, rewrite subtitle, and reorder first screenshots to scan & hook users. Measure impact in App Store Connect via daily averages; focus on App Store Browse, track conversion (not just impressions), and note featuring can skew data.
Diagnostics is an open‑source library adding an in‑app issue reporter that attaches an HTML report with OS/app info, device/storage details, and full session logs with JS filtering. Smart Insights via SmartInsightsProvider detect patterns (e.g., update available, low storage) to speed up support and debugging.
Hands-on guide to SwiftUI Toggle: bind to a Bool, use custom labels or hide them, and add accessibilityLabel when labels are hidden. Explains .toggleStyle(.switch/.button/.checkbox/.automatic), grouping in Form/Section, and creating computed Binding(get:set:) (e.g., UserDefaults; prefer @AppStorage).
Explains SwiftUI’s @ViewBuilder: why body uses it, how it resolves some View with conditionals, and how to apply it in initializers, properties, and methods. Implements a generic VHStack switching VStack/HStack via horizontalSizeClass. Notes if-conditions can affect performance/animations.
Guide to Swift computed properties: read-only vs get/set, exposing model data safely, using in extensions, overriding in UIKit (prefersStatusBarHidden, setNeedsStatusBarAppearanceUpdate), and get throws/async. When to prefer methods and store heavy results to avoid repeated work.
Property Wrappers in Swift extract common logic into reusable wrapper objects, reducing boilerplate code. Introduced in Swift 5, they use @propertyWrapper with wrappedValue property. Examples include UserDefaults handling, projected values for Combine publishers, and debugging wrappers. Key features: custom initializers, optional handling, enclosing instance access, and function parameter usage. However, they face compatibility issues with Swift Concurrency's Sendable requirements in strict mode, making macros a potential alternative for new projects.
Intro to async/await and structured concurrency in Swift: replace completion handlers and Result with linear try/await flows. Shows calling async from sync via Task initializer and @MainActor, Xcode refactors, and bridging with withChecked(Throwing)Continuation. Notes Swift 6/6.2 migration impact.
Explains Swift global actors that provide actor isolation across functions, properties, and types. Shows @MainActor and a custom @globalActor (ImageProcessing with static shared) to serialize work. Advises private init to prevent extra executors. Takeaway: isolate domains safely.
Combine + Swift Concurrency can crash under Swift 6.2: NotificationCenter publishers run on the poster’s thread and sink closures lack actor checks. Posting from a detached Task to a @MainActor observer fails. Prefer AsyncSequence notifications or start a Task in sink.
Clarifies Threads vs Tasks in Swift Concurrency: Tasks are scheduled on a cooperative thread pool, have no fixed thread; await suspends and yields. Swift caps threads to ~core count to prevent thread explosion and improve performance vs GCD. Demo with Task, Task.sleep, Thread.current.
Introduces the Synchronization framework’s Mutex
Flagship course to master Swift Concurrency and migrate to Swift 6’s strict checks. Learn async/await, tasks, Sendable, actors, priority inheritance, threading vs tasks, and how compiler checks prevent data races. Includes step-by-step migration habits, Swift 6.2 updates, and a migration build.