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
Use Xcode Instruments’ Swift Concurrency template to profile and optimize async code. Leverage Swift Tasks, Swift Actors, Time Profiler, and Hangs to find contention, queue growth, and CPU hotspots. Test at scale to surface issues that don’t appear in small datasets.
QuickTime’s device capture yields square, bezel-less videos. This post shows using RocketSim 16.0 to record a USB‑connected iPhone with bezels, audio, and backgrounds, producing App Store Connect‑ready exports. Includes a post‑editor, app metadata overlay, and design comparison tools.
Let AI agents control Xcode’s Simulator with RocketSim’s CLI and bundled Agent Skill. Compact --agent output and the rs/1 protocol cut tokens (~63%), speed runs (~19%), and prevent wrong taps. Install via RocketSim Settings. Improved accessibility tree; sandboxed and enterprise-ready.
Tasks created inside @MainActor often inherit main-thread isolation, then immediately await other work—adding unexpected suspension points, thread hopping and UI lag. Profile with Instruments. Fix by starting Task { @concurrent in ... } and update UI via await MainActor.run.
Explains Swift 6.2 (SE‑472) immediate tasks: Task.immediate and Task.immediateDetached start on the caller’s executor and run until the first real suspension. Covers calling async from sync actor code, requesting @MainActor, group.addImmediateTask, and warns about UI‑blocking overhang/serialization. Use sparingly.
Use Xcode Instruments Time Profiler with AI agents to iteratively optimize app code. Add a CLI for reproducible benchmarks, run Time Profiler + os_signpost, export signpost intervals and a deep call‑tree copy, filter libs, and let the agent plan fixes—up to 25× faster
Optimize iOS network requests by continuously inspecting Simulator traffic via RocketSim’s always‑on Network Monitor (swizzled URLSession). Export lean, structured logs and use built‑in prompts so AI agents detect redundant calls, overfetching, failures, and caching wins.
RocketSim 15 brings a VoiceOver Navigator to test accessibility in the Simulator via keyboard and rotor controls, a live post‑editor for screenshots/videos plus 120 FPS capture, Liquid Glass tint testing, and a dedicated Network Monitor/Speed Control—speeding up iOS dev workflows without a device.
Speed up Xcode builds with an open-source Agent Skill. An orchestrator benchmarks 3 clean/3 incremental builds, runs 40+ checks across build settings, project config, code, and Swift packages, then proposes/applies fixes. Note: Xcode 26’s opt‑in compilation caching may slow first clean builds but yields big incremental gains (e.g. 70s→9s).
Agentic coding’s ‘one more prompt’ risks scope creep and a 13k‑line PR. Remedy: many small, single‑purpose PRs with strict reviews; spin up dedicated agent contexts; use planning mode to diff main vs a reference branch, port the smallest next change, and defer non‑essentials.
Agentic dev across many projects boosts speed but hurts focus. Limit to 1–2 efforts and run a Plan–Build–Review–Compound loop. Raise quality with Agent Skills (SwiftUI/Concurrency/Core Data/Testing), MCPs, and thorough tests. Capture learnings in AGENTS.md.
9-step checklist for choosing Agent Skills: start from the task; use skills.sh signals (installs, repo, security audits) to filter; vet author/opinions; inspect SKILL.md and reference files for lean, single‑responsibility context; ensure maintenance; test one per domain to avoid conflicts/token waste; review over time.
Use the Model Context Protocol (MCP) to connect AI agents to analytics (Amplitude MCP) and your codebase for data‑driven product decisions. Prompts can rank impact, audit tracking, and—paired with Agent Skills—refine upsells. If no MCP exists, wrap the provider’s API. Prioritize what matters.
RocketSim 15 adds a VoiceOver overlay and keyboard navigator to test accessibility in Xcode’s Simulator, plus 120 FPS recordings. New Networking & Build Insights flag duplicate/slow calls, caching wins, and generate AI-ready prompts. Caveat: higher FPS can slow conversion; social compression may reduce quality.
Antoine van der Lee introduces a new Swift Testing Agent Skill for AI development. The skill converts Swift Testing articles into comprehensive agent knowledge covering fundamentals, async testing, expectations, parameterized tests, parallelization, and best practices. It guides agents away from common mistakes like unnecessary serialization or @MainActor usage that kills performance. The author used it to refactor RocketSim's test suite, making tests faster and more stable through better parallelization and flaky test detection.
Open SwiftUI Agent Skill that steers AI tools to write/refactor SwiftUI views correctly: avoid 1‑param onChange, AsyncImage downsampling/caching, layout sans GeometryReader, list identity/perf, ScrollViewReader, type‑safe sheets, state mgmt, and hot‑path optimizations. Reduces tech debt.
Lessons from a month of AI‑assisted iOS dev: speed with agents balloons tech debt. Add guardrails (AGENTS/Agent Skills, Cursor), run SwiftLint, keep builds clean, remove dead code. Be your own user. Validate OAuth/LLM deps and platform policies early.
Practical lessons from coding with AI agents: use plan mode and persistent context (projects/skills), pick reasoning models, split work into small PRs, add hooks/rules, SwiftLint, and CI/tests (xcodebuild), and review diffs. Keep AGENTS evolving—agents amplify discipline.
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.