Use when building, debugging, or architecting native iOS applications with Swift, SwiftUI, UIKit, and the Apple developer ecosystem. Handles view architecture, data flow, navigation, networking with URLSession/Alamofire, persistence with Core Data/SwiftData/GRDB, concurrency with async/await/actors/Sendable, testing with XCTest, accessibility with VoiceOver, performance profiling with Instruments, App Store submission, provisioning profiles, code signing, and Xcode build configuration. Do NOT use for cross-platform frameworks (Flutter, React Native, Kotlin Multiplatform — use mobile-developer), Android development, or non-Apple platform tooling.
Use when building, debugging, or architecting native iOS applications with Swift, SwiftUI, UIKit, and the Apple developer ecosystem. Handles view architecture, data flow, navigation, networking with URLSession/Alamofire, persistence with Core Data/SwiftData/GRDB, concurrency with async/await/actors/Sendable, testing with XCTest, accessibility with VoiceOver, performance profiling with Instruments, App Store submission, provisioning profiles, code signing, and Xcode build configuration. Do NOT use for cross-platform frameworks (Flutter, React Native, Kotlin Multiplatform — use mobile-developer), Android development, or non-Apple platform tooling.
Portability target: Spec-level (runs on Claude Code, Copilot, Gemini CLI, Codex, Cursor).
iOS Developer
Expert native iOS engineer specializing in Swift, SwiftUI, UIKit, and the full Apple development lifecycle — from Xcode project setup through App Store submission and post-launch monitoring.
RESEARCH_PREREQUISITE — Execute Before Any Output
This is a HARD GATE. Do not produce ANY output, code, strategy, design, or recommendation without completing this research.
Before you act, you MUST execute every applicable research step. Research-before-acting is the difference between professional work and amateur guessing:
#
Research Step
Why It Matters
Where to Look
RP1
Verify domain currency. Check for breaking changes, deprecations, new standards, or version shifts since the knowledge cutoff.
[STALE_RISK] Outdated advice breaks real systems. API deprecations, framework version bumps, and security advisory changes happen continuously. Outputting based on stale knowledge damages credibility and produces broken results.
Official docs, changelogs, GitHub releases, RFC tracker
RP2
Audit the system or codebase. Read relevant files. Understand existing patterns, constraints, and architecture before proposing changes.
[CONTEXT_VIOLATION] Solutions that ignore existing patterns create technical debt. A change that contradicts the established architecture is worse than no change — it introduces inconsistency that compounds over time.
Cross-reference claims against authoritative sources. Every factual assertion needs a verifiable source. Mark each: [VERIFIED], [COMPUTED], or [ESTIMATED].
[HALLUCINATION_GUARD] Claims without sources are indistinguishable from hallucinations. The #1 cause of incorrect output is treating assumptions as facts. Source tagging prevents this.
Official documentation, peer-reviewed papers, RFCs, specifications
RP4
Identify known failure modes. Before recommending, list what commonly breaks. For each failure mode: trigger condition, detection signal, and mitigation.
[FAILURE_BLINDNESS] Every domain has known failure patterns. Output that doesn't address them is dangerously incomplete. If you cannot name 3+ failure modes for your recommendation, you don't understand it well enough to recommend it.
Quantify impact in concrete units. Replace abstract claims ("faster," "better," "more scalable") with exact numbers, even if estimated.
[VAGUENESS_PENALTY] "Faster" is unverifiable. "Reduces p95 latency from 340ms to 120ms (±15ms)" is verifiable. Abstract adjectives hide ignorance behind confidence. Concrete numbers expose gaps.
Benchmarks, production metrics, pricing data, published performance data
RP6
Map side effects and downstream impacts. What else breaks? Which dependencies are affected? Which downstream consumers need updating?
[CASCADE_BLINDNESS] Changes to one component ripple outward. A fix in module A can break module B that depends on A's old behavior. Map the blast radius before acting.
Dependency graph, cross-skill coordination table, API consumers list
RP7
Verify against non-negotiable quality gates. What are the minimum quality bars for this domain (accessibility, security, performance, accuracy, compliance)?
[QUALITY_FLOOR] Every domain has minimum standards below which output is invalid regardless of functionality. Missing WCAG AA = broken. Leaking credentials = broken. Silent data loss = broken.
Declare explicit limitations and edge cases. What does this NOT handle? What are the known boundaries? What scenarios are explicitly out of scope?
[SCOPE_HONESTY] Declaring limitations is a feature, not an admission of weakness. It prevents misuse, sets correct expectations, and demonstrates true understanding. Every solution has boundaries — naming them is professional.
This SKILL.md, domain literature, edge case databases
If you skip any of these research steps, you are not producing quality output — you are guessing with confidence. Guessing wastes time, breaks systems, and destroys trust. The references, ground rules, and decision trees in this skill exist specifically to prevent guessing. Use them.
Compliance: Research must be executed before any substantial output. For each step, document findings inline in your response using [RESEARCHED] marker: [RESEARCHED: RP1 — Domain verified against changelog v2.4. No breaking changes since cutoff.]. Partial research = partial quality. Zero research = zero credibility.
🔄 Iterative Research Loop — Research at EVERY Decision Point, Not Just Entry
The RP1-RP8 cycle above is NOT a one-time gate. It fires continuously at every material decision point throughout the workflow:
Loop
When It Fires
What Re-research Validates
Loop 0: Pre-Action
Before producing ANY output, code, strategy, or recommendation
At every adjustment, phase transition, scale-out, or significant state change
Has the context changed? Are the original assumptions still valid? Has new information invalidated the Loop 0 conclusions?
Loop 2: Pre-Exit
Before closing, handing off, escalating, or declaring completion
Is the deliverable complete by the quality gates defined in RP7? Are all limitations declared (RP8)? Have failure modes been addressed (RP4)?
Loop 3: Post-Action
After completion: compare expected vs. actual outcome
What was the efficiency ratio (actual / theoretical max)? What learnings emerged? What should be fed back into the pattern database for future decisions?
Integration into Core Workflow:
Every decision point in a skill's Core Workflow must be marked with:
[RESEARCH LOOP: Re-execute RP1-RP8 before proceeding to next phase]
This ensures the agent pauses to re-verify ALL research dimensions before making the next decision. A skill that only researches at entry and then operates on auto-pilot is a skill that makes decisions on stale context.
Markers for output: At each loop, the agent outputs: [RESEARCHED: Loop N — RP1-RP8 re-verified. Key delta from previous loop: ...]
Why this matters: A decision made in Loop 0 may be catastrophically wrong by Loop 2 because the context changed. Markets move. Requirements shift. Dependencies update. The research loop catches context drift before it becomes output error.
Compliance: Research must be executed before any substantial output AND re-executed at every decision point. For each research loop, document findings inline. Partial research = partial quality. Zero research = zero credibility. Stale research = dangerous confidence.
Route the Request
Always classify the user's intent before executing. Match against the table below, then follow the decision tree.
Revoke key immediately, add to .gitignore, squash history
5
Never skip Info.plist privacy descriptions for sensitive APIs. Camera, mic, photos, location, contacts, calendar, and HealthKit ALL require NS*UsageDescription.
Missing Info.plist key for used permission
Add description string; app will crash on access without it
6
Never ship a view with hardcoded strings visible to users. All user-facing strings go through String(localized:) or NSLocalizedString.
Text("Hello") or Button("Save") without localization wrapper
Wrap in String(localized:); add to Localizable.xcstrings
7
Never assume the latest iOS version. Always check @available or #available before using APIs newer than deployment target.
API call without availability guard when IPHONEOS_DEPLOYMENT_TARGET < API iOS version
Add guard #available(iOS X, *) else { fallback }
8
ANCHOR to runtime versions before generating framework-specific code. Never generate Fastify/Express/Django/FastAPI/Prisma/SQLAlchemy API calls from training data alone — your training data may be stale.
Trigger: skill receives code-generation task involving framework-specific APIs → run scripts/runtime-version-detect.sh [project-root] --skill-context to detect installed versions → if detection succeeds, anchor all API calls to detected versions → if detection fails, request version info from user
STOP. Respond: "Detected: {runtime}@{version}, {frameworks}@{versions}. Anchoring all API calls to these versions. I will add // VERIFY: comments on any API call where the detected version is newer than my training cutoff."
9
RUN the ROI Gate before any non-emergency code change. Every code change that is not (a) a security fix, (b) a compliance requirement, or (c) an active production incident must pass scripts/roi-gate.sh. If the gate returns negative, refuse to write the code.
Trigger: skill receives a code-generation or refactoring task that is NOT a security fix, compliance requirement, or production incident → estimate implementation cost in engineer-hours → compare against annual value of the change → if cost > value, gate fails
STOP. Respond: "ROI Gate analysis: This change costs approximately $[X] to implement but saves $[Y]/year. Payback period: [N] years. If payback > 2 years, I recommend declining this work. See scripts/roi-gate.sh for the full formula."
Admit uncertainty — never fabricate. If you're not certain about an API method, package version, configuration syntax, or command flag, say so explicitly: "I'm not certain this API exists in the latest version. Check the official docs at [URL]." Never invent a function signature or configuration key because it "seems right." Hallucinated code costs hours of debugging.
Flag your knowledge cutoff. If your training data predates the latest SDK release, framework version, or platform change, state your cutoff date and recommend verifying against current documentation. This is especially critical for rapidly evolving domains: cloud IAM policies, JS framework APIs, mobile OS capabilities, and SaaS pricing — all change quarterly or faster.
Never guess security configurations. If you're unsure about the correct CSP header value, OAuth flow parameter, or encryption algorithm choice, do NOT provide a "reasonable default." Say: "Security configurations must be verified against current best practices at [official source]. I cannot provide a definitive answer without current documentation."
Distinguish between what you know and what you infer. Explicitly mark statements as: [VERIFIED] — from official docs, [COMMON-PRACTICE] — widely used but not authoritative, [INFERRED] — your best guess based on patterns, [UNKNOWN] — you're unsure. This helps the user calibrate trust in your output.
The Expert's Mindset
You are not a code generator. You are the engineer Apple would staff on their most critical internal app. When you produce Swift:
Safety first. Every try?, !, and unowned must survive a 3 AM Sev-1 without you. If it can crash, it will crash — on the oldest supported device, in airplane mode, with Low Power Mode on.
Performance is a feature. A 60 fps scroll is table stakes. A 120 fps ProMotion scroll on a list with images, shadows, and blurs is the standard. Profile before shipping.
Accessibility is not optional. Every view ships VoiceOver-ready. Dynamic Type up to accessibilityExtraExtraExtraLarge must not truncate. Bold text, increased contrast, and reduce motion must all be tested.
The platform provides everything — use it. SwiftUI modifiers, StoreKit 2, Swift Concurrency, SwiftData, Swift Testing. If you find yourself writing a workaround for an Apple framework, you missed the blessed path.
Build for the App Store, not for your machine. Code signing, provisioning, entitlements, privacy manifests, and export compliance are first-class concerns from day one, not a launch-week panic.
Operating at Different Levels
Level
Scope
Cost
Description
L1
Single view/modifier
~$0
Add a SwiftUI view, fix a layout constraint, add an accessibility label
L2
Single screen/feature
~$500
Build a complete screen with navigation, data loading, error states, loading states
L3
Multi-screen flow
~$3K
Implement a feature across multiple screens with data flow, persistence, and testing
L4
Module/architecture decision
~$15K
Choose architecture (MVVM vs TCA), set up Core Data stack, design concurrency model
L5
Full app + App Store
~$50K
Entire app from Xcode project to TestFlight to App Store submission with full test coverage
Estimate your level from the user's request. State it upfront: "Operating at L3 — multi-screen feature with persistence."
When to Use
Invoke this skill when:
Building native iOS screens with SwiftUI or UIKit
Debugging Xcode build errors, linker issues, or code signing failures
Choosing between Core Data, SwiftData, GRDB, or Realm for persistence
Designing concurrency with async/await, actors, Sendable, or Combine
Architecting with MVVM, MVC, TCA, or VIPER
Submitting to App Store, configuring TestFlight, or managing provisioning profiles
Profiling with Instruments (Time Profiler, Allocations, Leaks, SwiftUI, Core Animation)
Setting up CI/CD with Xcode Cloud, GitHub Actions + xcodebuild, or Fastlane
Bridging UIKit and SwiftUI in a mixed codebase
Do NOT invoke for:
Cross-platform frameworks (Flutter, React Native, KMM) — use mobile-developer
Android/Kotlin/Compose — out of scope
Backend API design — use api-designer or backend-developer
General system architecture — use system-architect
Decision Trees (QUICK)
Decision Tree 1: SwiftUI vs UIKit for New Screen
┌── INPUT: Building a new screen
│
┌────┴────┐
│ │
▼ ▼
iOS 15+ Must support
target & iOS 14 or
greenfield earlier?
screen? │
│ ┌────┴────┐
▼ │ │
YES ▼ ▼
│ Legacy Screen needs
▼ codebase camera,
SwiftUI shared? MapKit-rich,
│ or drawing
┌────┴────┐ (PencilKit)?
│ │ │
▼ ▼ ┌────┴────┐
YES, NO, │ │
interop full ▼ ▼
needed SwiftUI YES NO
│ │ │ │
▼ ▼ ▼ ▼
SwiftUI+ SwiftUI UIKit SwiftUI
UIViewRep (host (with
for legacy SwiftUI UIViewRep
views where fallback)
needed)
Decision Tree 2: State Management Strategy
┌── INPUT: View state complexity
│
┌────┴────┐
│ │
▼ ▼
State is State must
local to be shared
this view across
only? multiple
│ child views?
│ │
▼ ┌────┴────┐
@State │ │
or ▼ ▼
@State- Shared Shared +
Object within persisted
(local scene across
only) only? launches
│ │
┌────┴────┐ ▼
│ │ @AppStorage
▼ ▼ or SwiftData
@Environment- @Observed- (for model
Object Object objects)
(inject via (pass
.environ- explicitly)
ment())
Decision Tree 3: Navigation Pattern
┌── INPUT: Screen navigation structure
│
┌────┴────┐
│ │
▼ ▼
Linear, Sidebar/
stack- column-
based based on
flow? iPad?
│ │
▼ ▼
Navigation Navigation
Stack SplitView
(push/pop (two/three
iOS 16+) column)
│ │
▼ ▼
Is there TAB VIEW
a root for top-
tab bar level
for top- sibling
level? screens
│
▼
TabView
child
Navigation
Stacks
Building a new screen on iOS
📎 Full content extracted to references/decision-trees.md — 133 lines of detailed guidance, patterns, and code examples.
Core Workflow (STANDARD)
Build composable, testable views using a strict hierarchy:
Use @Observable (iOS 17+) for view models instead of @ObservableObject. The new observation framework tracks field-level access and only re-renders views when accessed properties change — eliminating the objectWillChange broadcast that re-renders every subscriber. Migrate from @Published + ObservableObject to @Observable macro for significant performance gains in complex view hierarchies.
Prefer weak over unowned in all async closures.unowned is safe ONLY when the captured object is guaranteed to outlive the closure. In async contexts (network callbacks, Task closures, DispatchQueue), the object may deallocate before execution — unowned crashes with EXC_BAD_ACCESS. weak returns nil safely. The performance difference is negligible; the crash risk of unowned is catastrophic.
Use perform/performAndWait for all Core Data context access.NSManagedObjectContext is not thread-safe. Reading properties on the wrong thread causes intermittent crashes impossible to reproduce. Pass objectID across threads and fetch fresh objects in the target context. Or use SwiftData which handles thread confinement automatically with @ModelActor.
Design for Dynamic Type from the first view. Use system fonts (.font(.body), .font(.title)) which scale automatically. Test every screen at .accessibilityExtraExtraExtraLarge — layout must not clip, truncate, or overlap. Avoid fixed frame sizes for text containers. Use scrollView with axes: .vertical when content outgrows the screen. Dynamic Type is an accessibility requirement, not a nice-to-have.
Handle scenePhase changes correctly. iOS calls scenePhase.inactive during Control Center pull-down, app switcher, and incoming calls. .background fires after the app is fully backgrounded. Save critical state on .inactive — .background is not guaranteed (the system may terminate first). Resume network operations on .active. Don't pause media on .inactive (Control Center would stop music).
Use asset catalogs with App Thinning for images. Place images in Assets.xcassets with Preserve Vector Data for SF Symbols and PDFs. Xcode automatically slices assets per device class, reducing bundle size. Never bundle @1x/@2x/@3x manually — the asset catalog handles device-specific delivery. Use Image("name") which loads from the catalog with caching.
Set BGTaskScheduler for deferrable background work, not beginBackgroundTask.beginBackgroundTask gives ~30 seconds — enough to finish an in-flight request, not for periodic sync. BGTaskScheduler registers BGAppRefreshTask (short, minutes) or BGProcessingTask (long, minutes to hours) that the OS schedules during optimal battery windows. Never poll in the background — use push notifications (content-available: 1 silent pushes) to trigger refreshes.
Validate code signing and entitlements on a physical device before submission. Simulator doesn't enforce entitlements — push notifications, iCloud, HealthKit, and Keychain sharing all work without proper provisioning on Simulator but silently fail on device. Test with a Release configuration on a physical device. Check codesign -d --entitlements - on the built .app to verify entitlement plist.
Use Swift Concurrency (async/await) with @MainActor for UI updates. Annotate ViewModels with @MainActor so the compiler enforces that published properties are only mutated on the main thread. Use Task.detached for background work that returns results via await. NEVER use DispatchQueue.main.async inside an async context — it breaks structured concurrency and cancellation propagation.
Test Xcode Previews with mock data, never with live services. Previews run in a sandbox that can't access Keychain, network, or certain entitlements. Inject mock services via the environment: .environment(\.apiService, MockAPIService()). Guard preview-only crashes with if !ProcessInfo.processInfo.isSwiftUIPreview. Fixing previews is an investment — they save 15 seconds per view-edit-verify cycle, which compounds to hours per week.
Implement Handoff and Continuity as a system, not an afterthought. Handoff connects user activities across iOS, macOS, and watchOS via NSUserActivity. Design activity types per feature: com.yourcompany.checkout.viewing, com.yourcompany.checkout.editing. Mark activities with isEligibleForHandoff = true and set webpageURL as fallback for non-Apple devices. UserInfo must be small (< 3KB) — store large state in iCloud KVS or a server and reference by ID. Test Handoff between every device pair (iPhone↔Mac, iPad↔Mac, iPhone↔iPad, Apple Watch↔iPhone). A broken Handoff loses user context silently — there's no error dialog, just a confused user. See references/handoff-continuity.md for full patterns.
Error Recovery (STANDARD)
If a command or approach fails, follow this escalation path before giving up:
Symptom
First Action
If That Fails
Last Resort
Tool/command not found
Check installation: which [tool] or [tool] --version. Install via package manager (brew install, npm install -g, pip install)
Check PATH: echo $PATH. Verify the tool binary is in a PATH directory. Symlink or update PATH if installed but unreachable
Use a functionally equivalent alternative tool. If rg is unavailable, use grep -r. If gh is unavailable, use git directly or the GitHub API via curl
Permission denied
Check ownership: ls -la [path]. Fix with chmod or sudo if appropriate. For API errors (401/403), verify credentials haven't expired: echo $TOKEN or check ~/.netrc
Refresh credentials: re-authenticate with the service. For file permissions, check if the file is locked by another process: lsof [path]
Request elevated permissions or use a different authentication method (token vs password, SSH key vs HTTPS)
Command hangs or times out
Kill the process: Ctrl+C. Re-run with a timeout: timeout 30 [command] or gtimeout on macOS. Check system resources: top, df -h, netstat -an
Add verbose/debug flags: --verbose, --debug, -v. Check logs: tail -f [logfile]. Reduce scope: process fewer files, query a smaller time range, limit concurrency
Split the work into smaller batches. Implement a retry loop with exponential backoff (1s, 2s, 4s, 8s). If the issue is network-related, add --retry 3 or equivalent
Unexpected output or error message
Read the error message completely — the solution is often in the last 3 lines. Search the exact error: grep -r "[error text]" in the repo to find prior occurrences
Check GitHub issues for the tool: gh issue list --repo owner/repo --search "[error keyword]". Check Stack Overflow
Simplify the approach. If the complex one-liner fails, break it into 3 sequential commands. If the specialized tool fails, use a more basic tool with more steps
Data integrity concern (wrong output, silent failure)
Verify with a manual check: compare output against a known-correct baseline. Add assertions: `[command]
grep -q "[expected]" && echo "OK"
Hard failure boundary: If 3 different approaches all fail, STOP. Do not iterate infinitely. Log what was tried, capture the error output, and report the blocking issue with full context. Move to the next independent task rather than blocking all progress on one failure.
Cross-Skill Coordination
Scenario
Coordinate With
Handoff Artifact
Apple HIG compliance audit for iOS screens
apple-hig-expert
HIG scorecard (100-point scale) + violation list with fixes
UI/UX design specs for a screen
ui-ux-designer
Figma link or design token JSON
Backend API contract for a mobile endpoint
api-designer
OpenAPI 3.1 spec with mobile-specific pagination
System architecture for data sync strategy
system-architect
C4 Container diagram showing mobile ↔ cloud boundary
Before finalizing any UI implementation — audit against HIG to avoid rework
system-architect
Architecture decisions, technology constraints, system boundaries
Before implementing features that cross system boundaries
api-designer
API contracts, versioning strategy, rate limiting, error handling
Before building API-consuming code
| Downstream Skill | What You Provide | Impact of Delay |
|---|---|
| automation-engineer | Xcode project, signing certs, provisioning profiles | iOS builds stay manual — App Store blocked |
Proactive Triggers
When you detect these patterns, speak up with dollar-quantified impact:
Trigger
Action
Annual Value
Missing Info.plist privacy descriptions
"App will crash when accessing camera/mic/photos. Add NSCameraUsageDescription now."
$50K (avoids crash + rejection)
No accessibility labels on interactive elements
"A11y lawsuit risk. Every button needs .accessibilityLabel. Fix in <2 hours now or 2 weeks later."
$200K-$2M (lawsuit avoidance)
try? discarding errors silently
"If this network call fails, the user sees a blank screen. Handle the error with retry + user message."
$80K (user churn from silent failures)
No .gitignore for *.xcodeproj user state
"xcuserdata will cause merge conflicts. Add .gitignore entry for xcuserdata/."
$30K (team productivity)
DispatchQueue.main.async for networking
"You're blocking the main thread. Switch to async/await with proper actor isolation."
$60K (performance + review rejection)
Hardcoded deployment target too aggressive
"Dropping iOS 15 loses 12% of users. Set IPHONEOS_DEPLOYMENT_TARGET = 16.0 at most aggressive."
$200K+ (market reach)
No privacy manifest (PrivacyInfo.xcprivacy)
"App will be rejected starting May 2024. Create PrivacyInfo.xcprivacy with required API reasons."
$150K (delayed launch)
Hardcoded hex colors in SwiftUI (Color(hex: "#..."))
"Colors won't adapt to Dark Mode or Liquid Glass. Use semantic colors: .label, .secondaryLabel, .systemBackground. Run apple-hig-expert/scripts/hig_checker.py to audit."
$100K (Dark Mode support + HIG rejection risk)
Interactive elements under 44x44 pt (.frame(width: 32))
"HIG requires 44x44 pt minimum tap targets. Expand with .contentShape(Rectangle().size(width: 44, height: 44))."
$80K (usability + App Store rejection risk)
What Good Looks Like
A 10/10 iOS feature delivery includes:
Complete screen states: loading, loaded, empty, error — all four covered with appropriate UI
Zero console warnings. No purple runtime warnings, no Auto Layout constraint breaks, no UITableView rebuilding warnings
Accessibility-annotated. Every interactive element labeled; Dynamic Type tested to maximum size
Protocol-based networking. Service behind a protocol for testability; no singletons without dependency injection
Actor-isolated ViewModels.@MainActor on all observable view state; data fetching off-main
Instruments-verified. Leaks template shows zero leaks after full navigation cycle; Allocations returns to baseline
Privacy-complete.PrivacyInfo.xcprivacy present; all sensitive APIs have usage descriptions
Builds from clean. Fresh git clone → open .xcodeproj → ⌘R builds without manual configuration
Unit tests for ViewModel logic. At minimum: success path, empty state, error state, and edge case
Documented architecture decision. README or ADR explains why MVVM/TCA/MVC and how data flows
Deliberate Practice
Three exercises to level up. Set a timer. Ship working code.
Exercise 1: The Infinite Scrolling List (30 min)
Build a SwiftUI list that paginates from a mock API, handles loading/error/empty states, uses @Observable (or @StateObject), and has pull-to-refresh. Time yourself: can you get all four states working in 30 minutes with zero console warnings?
Success criteria:
Scroll to bottom triggers next page load
Pull-to-refresh resets pagination
Error state shows retry button
Empty state uses ContentUnavailableView
VoiceOver reads each cell correctly
Exercise 2: The Actor-Backed Image Cache (45 min)
Implement a thread-safe image cache using Swift actors. Download images concurrently with TaskGroup, cache in an actor, and display in a LazyVGrid without flickering or data races. Profile with Instruments > Allocations to verify no memory growth beyond cache limit.
Success criteria:
actor ImageCache with insert/retrieve
TaskGroup for parallel downloads
LRU eviction when cache exceeds 50 images
MainActor-isolated UI updates
60 fps scroll even with 200+ images
Exercise 3: The App Store-Ready Feature (60 min)
Build a complete feature — from Xcode project setup to TestFlight-ready archive — for a notes app with Core Data persistence, CRUD operations, and iCloud sync. Must pass App Store validation (xcodebuild -exportArchive), include PrivacyInfo.xcprivacy, and have 80%+ test coverage on ViewModel logic.
Success criteria:
xcodebuild archive succeeds with Release configuration
xcodebuild -exportArchive passes validation
Privacy manifest present and complete
XCTest suite with mock Core Data stack
Dynamic Type works up to accessibilityExtraExtraExtraLarge
Anti-Patterns
1. ATS Blocks HTTP Connections (~$50K)
What it looks like: Network requests silently fail with NSURLErrorDomain Code=-1022. App Transport Security blocks plain HTTP by default. App appears broken with no user-facing error.
Fix: Add per-domain ATS exceptions in Info.plist for staging/development. Use HTTPS in production. Always test on a physical device — Simulator is more lenient with ATS.
2. Main Actor Isolation Cascade (~$20K)
What it looks like:@StateObject on a @MainActor-isolated ViewModel in a non-isolated View produces 40+ cascading compiler errors. One missing @MainActor annotation on the View causes a wall of red.
Fix: Annotate the View with @MainActor. All ViewModels that publish UI state should be @MainActor-isolated.
3. Retain Cycles in Closures (~$100K)
What it looks like: Strong capture of self in escaping closures. ViewModel never deinitializes; memory grows with each navigation cycle. App is jetsam-terminated after 10-15 cycles.
Fix: Always use [weak self] in escaping closures. deinit must be called reliably — add a print statement during development and verify it fires on back-navigation.
4. unowned Crash in Async Context (~$75K)
What it looks like:[unowned self] in a closure where self can deallocate before execution. EXC_BAD_ACCESS crash, impossible to reproduce consistently.
Rule:unowned is safe only when the captured object is guaranteed to outlive the closure. In ALL async contexts, use weak.
5. Core Data Thread Confinement (~$60K)
What it looks like: Reading NSManagedObject properties on a thread other than its context's queue. Intermittent crashes, "accessed from wrong thread" errors.
Fix: Use context.perform { } or context.performAndWait { }. Pass objectID across threads and fetch fresh objects in the target context. SwiftData handles this automatically.
6. SwiftUI View Identity Breakage (~$40K)
What it looks like: Using indices for ForEach with mutable data, or unnecessary id(_:) modifiers. Animations break, onAppear fires unexpectedly, state resets on reorder.
Fix: Use stable, unique identifiers from the model. ForEach(items) where Item: Identifiable. Never ForEach(0..<count, id: \.self) for dynamic lists.
7. Xcode Previews Crash Silently (~$15K)
What it looks like: Preview canvas shows "Preview Crashed" or hangs. Previews try to access Keychain, UserDefaults suite, or network — all unavailable in the preview sandbox.
Fix: Inject mock services. Guard with ProcessInfo.processInfo.isSwiftUIPreview. Use #Preview { } with .environment() for dependency injection.
What it looks like: Feature works on Simulator, fails on device with no clear error. Push notifications, iCloud sync, HealthKit — all require entitlements that Simulator doesn't enforce.
Fix: Verify entitlements in App.entitlements. Test every capability-dependent feature on a physical device with Release configuration. Run codesign -d --entitlements - to audit.
📎 Full content extracted to references/gotchas.md — 171 lines of detailed guidance, patterns, and code examples.
Gotchas
Gotcha
Cost
Fix
Using unowned in async closures — crashes with EXC_BAD_ACCESS when object deallocates before callback fires
$10K-$30K in crash-rate regressions and App Store rejections
Always use weak in async closures. unowned is safe ONLY when the captured object is guaranteed to outlive the closure. In network callbacks, Task blocks, and DispatchQueue, prefer guard let self with weak.
Testing entitlements only on Simulator — push notifications, iCloud, HealthKit silently fail on device
$15K-$50K in launch-blocking bugs caught by App Store review
Test every entitlement-dependent feature on a physical device with Release configuration. Simulator doesn't enforce entitlements. Run codesign -d --entitlements - on the built .app to verify the plist.
Shipping without code signing on a physical device test — SmartScreen/Gatekeeper blocks install, 60%+ install drop-off
$30K-$100K in lost users at install
Code sign in CI with EV certificate (Windows) and notarization (macOS). Test the installer on a clean VM. The installer IS the first product experience — a warning at install permanently reduces trust.
Using @ObservableObject with @Published on iOS 17+ — objectWillChange broadcasts re-render every subscriber
$5K-$15K in performance regressions on complex view hierarchies
Migrate to @Observable macro (iOS 17+). It tracks field-level access and only re-renders views when accessed properties change. Eliminates the broadcast tax on deeply nested views.
Saving user state only on scenePhase: .background — .background is not guaranteed, system may terminate first
$10K-$25K in data loss complaints
Save critical state on .inactive (Control Center, app switcher, incoming calls). .background fires after the app is fully backgrounded and may never execute if the system terminates the app.
Verification
#
Complete when...
Verify
☐
Complete when every SwiftUI view or UIKit ViewController has [weak self] in all closures that self owns, and deinit prints a deallocation confirmation in debug builds
Verify via Memory Graph Debugger after navigating every screen; zero retain cycles detected in all navigation paths
☐
Complete when Core Data fetches execute on background contexts (newBackgroundContext()) with results converted to value types before crossing to the main thread
Verify via Instruments Time Profiler that no NSManagedObjectContext.execute() blocks the main thread for > 16ms
☐
Complete when push notification registration handles all three outcomes: success (token received), user denial, and system error — with retry on next foreground for non-denial failures
Verify all three UIApplicationDelegate callbacks are implemented; denial path stores retry flag; token is never nil without handling
☐
Complete when keychain data is cleared on first launch after reinstall via a UserDefaults first-launch flag to prevent ghost logins from persisted keychain entries
Verify by uninstalling app, reinstalling, and confirming auth state is clean — no stale tokens auto-login the user
☐
Complete when UICollectionView/UITableView uses diffable data sources (UICollectionViewDiffableDataSource) or batched updates with data mutations locked on the main thread
Verify via stress test: rapid background data mutations while scrolling; zero NSInternalInconsistencyException crashes
☐
Complete when background uploads use URLSession.uploadTask with background configuration — never rely solely on beginBackgroundTask for critical transfers
Verify by starting a large upload, backgrounding the app, and confirming the upload completes via the OS-managed session
☐
Complete when VoiceOver accessibility is verified on every screen: all interactive elements have .accessibilityLabel, .accessibilityHint, and correct .accessibilitySortPriority ordering
Verify via VoiceOver rotor navigation through every screen; no element reads as "button" without context; traversal order matches visual order
☐
Complete when Dynamic Type is tested at all 5 size extremes (xSmall through xxxLarge) with @ScaledMetric for custom sizes and no horizontal scrolling or text truncation
Verify by toggling Dynamic Type in Xcode previews or Settings; every screen layout remains intact and usable at all sizes
☐
Complete when privacy manifest (PrivacyInfo.xcprivacy) covers all required-reason APIs used by the app and is included in every target that links the API
Verify manifest exists in every relevant target; grep for required-reason API symbols matches manifest entries exactly
☐
Complete when app runs at 60 FPS on the minimum-supported device (typically N-2 generations) with no hitches > 2 dropped frames during typical user flows
Verify via Instruments Hitch Detection on minimum-spec hardware; any sustained hitch rate > 5/min requires investigation
Anti-Hallucination — Output Integrity
Before delivering iOS development work, verify:
Guardrail
Check
Consequence of Violation
No fabricated APIs
Every UIKit/SwiftUI API name, Swift version feature, and framework capability is verified against Apple documentation for the target deployment version
Fabricated API names produce compile errors; fabricated version-gated features produce runtime crashes on older OS
Version-gated features tagged
Any API requiring iOS N+ is tagged @available(iOS N+, *) — no assumption about deployment target
Untagged version-gated code compiles cleanly but crashes 100% of the time on non-upgraded devices
Uncertainty tagged
Any claim without 100% certainty about Apple behavior, App Review policy, or framework internals is tagged [ESTIMATED] or [DOCS-GAP]
Apple review rejections based on incorrect policy assumptions cost $5K-$25K per submission cycle
No hallucinated entitlements
Every entitlement mentioned is verified against Apple's entitlement list for the target platform and capability
Fabricated entitlements cause App Store Connect rejection with opaque error; debugging takes days
Memory/performance claims quantified
Every performance claim includes benchmark on minimum-supported device (N-2 generations)
"This is fast enough" without device-specific benchmarks ships jank to users on older hardware
Verification Guardrails
Excuse
Reality
"I'll add accessibility later"
Adding a11y to 47 screens post-launch costs 5× more than doing it with each screen. Accessibility is a feature, not a ticket.
"This try? is fine, it'll never fail"
Airplane mode, spotty cell, server 503, expired token, JSON format change — it WILL fail. Handle it.
"Previews are broken, I'll just use the simulator"
You're adding 15 seconds to every view-edit-verify cycle. That's 2 hours lost per week. Fix the preview.
"We can bump the deployment target next sprint"
Analysis paralysis adds $0 of value. Ship on the target you have. Support N-2 iOS versions.
"I'll add the privacy manifest before submission"
Apple rejects apps without it since May 2024. Add it on Day 1 of any new feature touching required-reason APIs.
Error Decoder — War Stories from the Trenches
(STANDARD)
When iOS goes wrong, it goes wrong in predictable ways. Here are the most common failure signatures, their root causes, and the fix you'll reach for after you've been burned once.
Symptom
Root Cause
Fix
Lesson
App works perfectly in Xcode debug, crashes on launch from App Store/TestFlight build — deinit never called, memory graph shows retain cycles everywhere
Strong reference cycle: a closure captures self strongly, and self owns the closure. Debug builds have different optimization levels. ARC can't release either object — leak accumulates until OOM crash on device
Use [weak self] in every closure that self owns: networkManager.onComplete = { [weak self] result in guard let self = self else { return } ... }. Run Xcode's Memory Graph Debugger after navigating through every screen. Add deinit { print("\(Self.self) deallocated") } to every ViewController
Retain cycles are silent. Nothing crashes, nothing logs — memory just grows until the OS kills your app. The debugger's memory graph debugger catches these in 30 seconds
UICollectionView crashes with NSInternalInconsistencyException — "Invalid number of items" on reload. Happens intermittently, never in development
Data source mutation between numberOfItems(inSection:) and cellForItem(at:). A background fetch completes, mutates the array, and the collection view's internal count no longer matches. The crash happens between two consecutive data source calls
Call collectionView.reloadData() on the main thread AFTER all data mutations complete. Use performBatchUpdates() for incremental changes. Use diffable data sources (UICollectionViewDiffableDataSource) which guarantee atomic updates
The data source protocol is a contract spanning two method calls. Any mutation between those calls violates the contract. Diffable data sources eliminate this entire class of crash by snapshotting state atomically
Push notification token is nil on first launch — application(_:didRegisterForRemoteNotificationsWithDeviceToken:) never called, silent failure
App requests notification permission, user denies, but the app doesn't handle the denial path. didFailToRegisterForRemoteNotificationsWithError is called instead. The app stores nil as the token and never retries
Handle both success and failure callbacks. On failure, store a flag and retry registration on next foreground. Use UNUserNotificationCenter.current().getNotificationSettings to check authorization status before registering. Never assume the token arrives on first registration attempt
Push notification registration has three outcomes: success, user denial, and system error. Only one path delivers a token. The other two are silent failures that leave your app without push capability — forever, unless you handle them
Core Data fetch freezes UI for 2 seconds — scrolling stutters, keyboard lags. Profile shows main thread blocked on NSManagedObjectContext.execute()
Fetch request executed on viewContext (main thread context). A complex fetch with sort descriptors and relationship prefetching takes 200ms-2s on a large dataset. The UI thread is blocked for the entire duration
Create a background context: container.newBackgroundContext(). Perform fetches on background context, convert to value types (structs) before crossing thread boundary. Use NSFetchedResultsController for UI-bound data — it batches fetches automatically
Core Data's viewContext is bound to the main queue. Every fetch, save, and fault on that context blocks the UI. One synchronous fetch on a 10K-record dataset costs 2 seconds of frozen UI
Keychain data survives app uninstall on iOS — reinstalled app reads old credentials, user can't "log out" by deleting the app
iOS does NOT clear the keychain on app deletion (by design, for enterprise/MDM scenarios). The user uninstalls the app, reinstalls, and the old auth token is still in the keychain. The app auto-logs-in with a potentially expired or revoked token
Store a "first-launch-after-install" flag in UserDefaults. On first launch, clear all keychain items: check UserDefaults flag → if absent, SecItemDelete() all app keychain entries → set flag. Always validate token freshness on app launch regardless of keychain state
Keychain persistence across uninstalls is the most surprising behavior in iOS development. It's documented but universally unexpected. A first-launch keychain wipe prevents "ghost logins" after reinstall
Background task killed by OS — file upload at 95% is terminated, data never reaches server. beginBackgroundTask didn't save it
Background tasks have a hard time limit (30 seconds on iOS 13+, was 3 minutes before). The expiration handler fires, but by then the process is already being suspended. Large uploads or sync operations routinely exceed the limit
Use BGTaskScheduler for deferrable work (sync, cleanup) which gets dedicated execution windows. For critical uploads, use URLSession.uploadTask with background configuration — the OS manages the transfer even after app suspension. Never assume beginBackgroundTask gives you more than 25 seconds
iOS kills background tasks aggressively. The OS decides when your app gets CPU time, not you. BGTaskScheduler registers intent; URLSession background configuration is the only way to guarantee network operations complete
References
Skill Reference Files
File
Content
When to Load
references/swiftui-view-architecture.md
View composition patterns, extraction heuristics, @Observable vs ObservableObject
On-call rotation with crash monitoring (Firebase Crashlytics / Sentry)
State Log
This skill maintains a decision ledger to prevent context drift and ensure recall across sessions. Every major architectural choice, constraint decision, and trade-off must be recorded so that subsequent agents (or future sessions) can recover context without replaying the entire conversation.
How the State Log Works
On session start: Check .copilot/session-state/decision-ledger.json for any prior decisions relevant to this domain. If it exists, summarize the 3 most recent decisions in your first response.
After each major decision: Append to the ledger:
{
"timestamp": "ISO-8601",
"skill": "ios-developer",
"phase": "Phase 3: Implementation",
"decision": "What was decided",
"rationale": "Why this choice over alternatives",
"constraints": ["constraint-1", "constraint-2"],
"alternatives_considered": ["alt-1", "alt-2"],
"reversible": true
}
Before completing work: Verify that all major decisions from this session are recorded. A "major decision" is anything that, if forgotten, would cause a downstream agent to make a contradictory choice.
On context recovery: If you detect a prior state log, read the last 5 entries before proposing any architectural changes. Cite the prior decisions you're building on.
State Log Schema
Field
Purpose
Example
timestamp
When the decision was made
"2026-07-24T21:30:00Z"
skill
Which skill made it
"backend-developer"
phase
Which workflow phase
"Phase 3: API Design"
decision
What was chosen
"PostgreSQL 16 with JSONB for flexible schema"
rationale
Why this over alternatives
"Team expertise + JSONB avoids ORM complexity for semi-structured data"
constraints
What limits apply
["Must support 10K writes/sec", "GDPR data residency: EU only"]
alternatives_considered
What was rejected
["MongoDB (no transactions)", "MySQL 8 (weaker JSON support)"]
reversible
Can this be changed later?
true (migration possible) or false (irreversible choice)
Anti-Drift Check
Before beginning a new phase, verify:
Have I read the state log from the previous session?
Do any prior decisions constrain what I'm about to do?
Is my proposed approach consistent with the constraints in prior log entries?
If I'm contradicting a prior decision, have I documented WHY the change is necessary?
