axiom

Parse and analyze iOS/macOS crash logs (.ips, .crash, or pasted text) to identify root cause

Ask a question about iOS/Swift development - routes to the right Axiom skill or agent

Smart audit selector - analyzes your project and suggests relevant audits

Diagnose and fix Xcode build failures (launches build-fixer agent)

Scan Xcode project for build performance optimizations (launches build-optimizer agent)

Run automated performance profiling via xctrace CLI (launches performance-profiler agent)

Run XCUITests and parse results using the test-runner agent

Capture screenshot from booted iOS Simulator

Project health dashboard - shows environment status and suggests improvements

Launch simulator testing agent for test scenarios and visual verification

Use this agent when the user mentions accessibility checking, App Store submission, code review, or WCAG compliance. Automatically runs comprehensive accessibility audit to detect VoiceOver issues, Dynamic Type violations, color contrast failures, and WCAG compliance problems - prevents App Store rejections and ensures usability for users with disabilities. <example> user: "Can you check my app for accessibility issues?" assistant: [Launches accessibility-auditor agent] </example> <example> user: "I need to submit to the App Store soon, can you review accessibility?" assistant: [Launches accessibility-auditor agent] </example> <example> user: "Review my code for accessibility compliance" assistant: [Launches accessibility-auditor agent] </example> <example> user: "Check if my UI follows WCAG guidelines" assistant: [Launches accessibility-auditor agent] </example> <example> user: "I just added new UI, can you scan for accessibility problems?" assistant: [Launches accessibility-auditor agent] </example> Explicit command: Users can also invoke this agent directly with `/axiom:audit accessibility`

Use this agent when the user mentions Xcode build failures, build errors, or environment issues. Automatically diagnoses and fixes Xcode build failures using environment-first diagnostics - saves 30+ minutes by checking zombie processes, Derived Data, SPM cache, and simulator state before code investigation. <example> user: "My build is failing with BUILD FAILED but no error details" assistant: [Automatically launches build-fixer agent] </example> <example> user: "Xcode says 'No such module' after I updated packages" assistant: [Launches build-fixer agent] </example> <example> user: "Tests passed yesterday but now they're failing and I haven't changed anything" assistant: [Launches build-fixer agent] </example> <example> user: "My app builds but it's running old code" assistant: [Launches build-fixer agent] </example> <example> user: "Getting 'Unable to boot simulator' error" assistant: [Launches build-fixer agent] </example> <example> user: "Build sometimes succeeds, sometimes fails" assistant: [Launches build-fixer agent] </example> Explicit command: Users can also invoke this agent directly with `/axiom:fix-build`

Use this agent when the user mentions slow builds, build performance, or build time optimization. Automatically scans Xcode projects for build performance optimizations - identifies slow type checking, expensive build phase scripts, suboptimal build settings, and parallelization opportunities to reduce build times by 30-50%. <example> user: "My builds are taking forever, can you help optimize?" assistant: [Automatically launches build-optimizer agent] </example> <example> user: "How can I speed up my Xcode build times?" assistant: [Launches build-optimizer agent] </example> Explicit command: Users can also invoke this agent directly with `/axiom:optimize-build`

Use this agent to scan Swift code for camera, video, and audio capture issues including deprecated APIs, missing interruption handlers, threading violations, and permission anti-patterns. Covers AVCaptureSession, photo/video recording, and audio capture. <example> user: "Can you check my camera code for issues?" assistant: [Launches camera-auditor agent] </example> <example> user: "Audit my capture implementation" assistant: [Launches camera-auditor agent] </example> <example> user: "Is my camera code following best practices?" assistant: [Launches camera-auditor agent] </example> <example> user: "Check for deprecated camera APIs" assistant: [Launches camera-auditor agent] </example> <example> user: "Review my AVFoundation capture code" assistant: [Launches camera-auditor agent] </example> Explicit command: Users can also invoke this agent directly with `/axiom:audit camera`

Use this agent when the user mentions Codable review, JSON encoding/decoding issues, data serialization audit, or modernizing legacy code. Automatically scans Swift/Objective-C for Codable anti-patterns (manual JSON building, try? swallowing errors, JSONSerialization usage) and date handling issues - prevents silent data loss and production bugs. <example> user: "Can you check my Codable code for issues?" assistant: [Launches codable-auditor agent] </example> <example> user: "Review my JSON encoding/decoding for best practices" assistant: [Launches codable-auditor agent] </example> <example> user: "Audit my code for proper Codable usage" assistant: [Launches codable-auditor agent] </example> <example> user: "Check for JSONSerialization that should use Codable" assistant: [Launches codable-auditor agent] </example> <example> user: "Scan for try? decoder issues before release" assistant: [Launches codable-auditor agent] </example> Explicit command: Users can also invoke this agent directly with `/axiom:audit codable`

Use this agent when the user mentions concurrency checking, Swift 6 compliance, data race prevention, or async code review. Automatically scans Swift code for Swift 6 strict concurrency violations - detects unsafe Task captures, missing @MainActor, Sendable violations, and actor isolation problems. <example> user: "Can you check my code for Swift 6 concurrency issues?" assistant: [Launches concurrency-auditor agent] </example> <example> user: "I'm getting data race warnings, can you scan for concurrency violations?" assistant: [Launches concurrency-auditor agent] </example> Explicit command: Users can also invoke this agent directly with `/axiom:audit concurrency`

Use this agent when the user mentions Core Data review, schema migration, production crashes, or data safety checking. Automatically scans Core Data code for the 5 most critical safety violations - schema migration risks, thread-confinement errors, N+1 query patterns, production data loss risks, and performance issues - prevents production crashes and permanent data loss. <example> user: "Can you check my Core Data code for safety issues?" assistant: [Launches core-data-auditor agent] </example> <example> user: "I'm about to ship an app with Core Data, can you review it?" assistant: [Launches core-data-auditor agent] </example> <example> user: "Review my code for Core Data migration risks" assistant: [Launches core-data-auditor agent] </example> <example> user: "I need to add a Core Data attribute, what should I check first?" assistant: [Launches core-data-auditor agent] </example> <example> user: "Check for thread-confinement violations in my persistence layer" assistant: [Launches core-data-auditor agent] </example> Explicit command: Users can also invoke this agent directly with `/axiom:audit core-data`

Use this agent when the user has a crash log (.ips, .crash, or pasted text) that needs analysis. Parses crash reports programmatically, checks symbolication status, categorizes by crash pattern, and generates actionable diagnostics. <example> user: "Analyze this crash log" [pastes crash report] assistant: [Launches crash-analyzer agent] </example> <example> user: "Here's a crash from TestFlight, what's wrong?" assistant: [Launches crash-analyzer agent] </example> <example> user: "Parse this .ips file: ~/Library/Logs/DiagnosticReports/MyApp.ips" assistant: [Launches crash-analyzer agent] </example> <example> user: "Why did my app crash? Here's the report..." assistant: [Launches crash-analyzer agent] </example> Explicit command: Users can also invoke this agent directly with `/axiom:analyze-crash`

Use this agent when the user mentions database schema review, migration safety, GRDB migration audit, or SQLite schema checking. Automatically scans database migration and schema code for the 10 most critical violations - unsafe ALTER TABLE patterns, DROP operations, missing idempotency, foreign key misuse, and transaction safety - prevents data loss, migration crashes, and silent corruption. <example> user: "Can you check my database migrations for safety?" assistant: [Launches database-schema-auditor agent] </example> <example> user: "Review my GRDB schema code for issues" assistant: [Launches database-schema-auditor agent] </example> <example> user: "Audit my SQLite migrations before release" assistant: [Launches database-schema-auditor agent] </example> <example> user: "I'm adding a column to my database, can you check the migration?" assistant: [Launches database-schema-auditor agent] </example> <example> user: "Check my database code for data loss risks" assistant: [Launches database-schema-auditor agent] </example> Explicit command: Users can also invoke this agent directly with `/axiom:audit database-schema`

Use this agent when the user mentions battery drain, energy optimization, power consumption audit, or pre-release energy check. Automatically scans codebase for the 8 most common energy anti-patterns - timer abuse, polling instead of push, continuous location, animation leaks, background mode misuse, network inefficiency, GPU waste, and disk I/O patterns. <example> user: "Can you check my app for battery drain issues?" assistant: [Launches energy-auditor agent] </example> <example> user: "Audit my code for energy efficiency" assistant: [Launches energy-auditor agent] </example> Explicit command: Users can also invoke this agent directly with `/axiom:audit energy`

Use this agent when the user mentions Foundation Models review, on-device AI audit, LanguageModelSession issues, @Generable checking, or Apple Intelligence integration review. Automatically scans Foundation Models code for the 10 most critical violations - missing availability checks, main thread blocking, manual JSON parsing, missing error handling, and session lifecycle issues - prevents crashes, guardrail violations, and poor user experience. <example> user: "Can you check my Foundation Models code for issues?" assistant: [Launches foundation-models-auditor agent] </example> <example> user: "Review my @Generable structs for correctness" assistant: [Launches foundation-models-auditor agent] </example> <example> user: "Audit my Apple Intelligence integration" assistant: [Launches foundation-models-auditor agent] </example> <example> user: "My LanguageModelSession keeps crashing" assistant: [Launches foundation-models-auditor agent] </example> <example> user: "Check if I'm handling Foundation Models errors properly" assistant: [Launches foundation-models-auditor agent] </example> Explicit command: Users can also invoke this agent directly with `/axiom:audit foundation-models`

Use this agent when the user mentions in-app purchase review, IAP audit, StoreKit issues, purchase bugs, transaction problems, or subscription management. Automatically audits existing IAP code to detect missing transaction.finish() calls, weak receipt validation, missing restore functionality, subscription status tracking issues, and StoreKit testing configuration gaps - prevents revenue loss, App Store rejections, and customer support issues. <example> user: "Can you review my in-app purchase implementation?" assistant: [Launches iap-auditor agent] </example> <example> user: "I'm having issues with subscription renewals" assistant: [Launches iap-auditor agent] </example> <example> user: "Audit my StoreKit 2 code" assistant: [Launches iap-auditor agent] </example> <example> user: "Check if I'm handling transactions correctly" assistant: [Launches iap-auditor agent] </example> <example> user: "My restore purchases isn't working properly" assistant: [Launches iap-auditor agent] </example>

Use this agent when the user wants to add in-app purchases, implement StoreKit 2, or set up subscriptions. Implements complete IAP following testing-first workflow with StoreKit configuration, centralized StoreManager, transaction handling, and restore purchases. <example> user: "Implement in-app purchases for my app" assistant: [Launches iap-implementation agent] </example> <example> user: "Add subscription support with monthly and annual plans" assistant: [Launches iap-implementation agent] </example> Explicit command: Users can also invoke this agent directly with `/axiom:audit iap-implementation`

Use this agent when the user mentions iCloud sync issues, CloudKit errors, ubiquitous container problems, or asks to audit cloud sync. Automatically runs comprehensive iCloud audit to detect missing entitlement checks, unsafe file coordination, missing error handling, and CloudKit anti-patterns - prevents sync failures and data conflicts. <example> user: "Check my iCloud integration" assistant: [Launches icloud-auditor agent] </example> <example> user: "Audit my CloudKit code" assistant: [Launches icloud-auditor agent] </example> <example> user: "My iCloud sync isn't working" assistant: [Launches icloud-auditor agent] </example> <example> user: "Review my file coordination code" assistant: [Launches icloud-auditor agent] </example> <example> user: "Check for iCloud Drive issues" assistant: [Launches icloud-auditor agent] </example> Explicit command: Users can also invoke this agent directly with `/axiom:audit icloud`

Use this agent when the user mentions Liquid Glass review, iOS 26 UI updates, toolbar improvements, or visual effect migration. Automatically scans SwiftUI codebase for Liquid Glass adoption opportunities - identifies views for glass effects, toolbar improvements, migration from old blur effects, and tinting opportunities for iOS 26+. <example> user: "Can you check my app for Liquid Glass adoption opportunities?" assistant: [Launches liquid-glass-auditor agent] </example> <example> user: "I have old UIBlurEffect code, should I migrate to Liquid Glass?" assistant: [Launches liquid-glass-auditor agent] </example> Explicit command: Users can also invoke this agent directly with `/axiom:audit liquid-glass`

Use this agent when the user mentions memory leak prevention, code review for memory issues, or proactive leak checking. Automatically scans codebase for the 6 most common memory leak patterns - timer leaks, observer leaks, closure captures, delegate cycles, view callbacks, and PhotoKit accumulation. <example> user: "Can you check my code for memory leaks?" assistant: [Launches memory-auditor agent] </example> <example> user: "Review my code for retain cycles" assistant: [Launches memory-auditor agent] </example> Explicit command: Users can also invoke this agent directly with `/axiom:audit memory`

Use this agent when the user wants to modernize iOS code to iOS 17/18 patterns, migrate from ObservableObject to @Observable, update @StateObject to @State, or adopt modern SwiftUI APIs. Scans for legacy patterns and provides migration paths with code examples. <example> user: "How do I migrate from ObservableObject to @Observable?" assistant: [Launches modernization-helper agent] </example> <example> user: "Are there any deprecated APIs in my SwiftUI code?" assistant: [Launches modernization-helper agent] </example> <example> user: "Update my code to use modern SwiftUI patterns" assistant: [Launches modernization-helper agent] </example> <example> user: "Should I still use @StateObject?" assistant: [Launches modernization-helper agent] </example> <example> user: "Modernize my app for iOS 18" assistant: [Launches modernization-helper agent] </example> Explicit command: Users can also invoke this agent directly with `/axiom:audit modernization` or `/axiom:modernize`

Use this agent when the user mentions networking review, deprecated APIs, connection issues, or App Store submission prep. Scans for deprecated networking APIs (SCNetworkReachability, CFSocket, NSStream) and anti-patterns (reachability checks, hardcoded IPs, missing error handling) - prevents App Store rejections. <example> user: "Can you check my networking code for deprecated APIs?" assistant: [Launches networking-auditor agent] </example> <example> user: "I'm getting App Store review warnings about networking" assistant: [Launches networking-auditor agent] </example> Explicit command: Users can also invoke this agent directly with `/axiom:audit networking`

Use this agent when the user wants automated performance profiling, headless Instruments analysis, or CLI-based trace collection. Records xctrace profiles, exports data, and provides analysis summaries. <example> user: "Profile my app's CPU usage" assistant: [Launches performance-profiler agent] </example> <example> user: "Run Time Profiler on my app" assistant: [Launches performance-profiler agent] </example> <example> user: "Check for memory leaks without opening Instruments" assistant: [Launches performance-profiler agent] </example> <example> user: "Profile my app's launch time" assistant: [Launches performance-profiler agent] </example> <example> user: "Run a headless performance trace" assistant: [Launches performance-profiler agent] </example> Explicit command: Users can also invoke this agent directly with `/axiom:profile`

Use this agent when the user mentions App Store screenshot validation, screenshot review, checking screenshots before submission, or verifying screenshot dimensions and content. Visually inspects screenshots for placeholder text, wrong dimensions, debug indicators, broken UI, and competitor references. <example> user: "Can you check my App Store screenshots for issues?" assistant: [Launches screenshot-validator agent] </example> <example> user: "Validate my screenshots before I submit to the App Store" assistant: [Launches screenshot-validator agent] </example> <example> user: "Are my screenshots the right dimensions?" assistant: [Launches screenshot-validator agent] </example> <example> user: "Check my marketing screenshots for problems" assistant: [Launches screenshot-validator agent] </example> <example> user: "Review screenshots in ~/Desktop/AppScreenshots" assistant: [Launches screenshot-validator agent] </example> Explicit command: Users can also invoke this agent directly with `/axiom:audit screenshots`

Use this agent when the user mentions security review, App Store submission prep, Privacy Manifest requirements, hardcoded credentials, or sensitive data storage. Scans for API keys in code, insecure @AppStorage usage, missing Privacy Manifests (iOS 17+), ATS violations, and logging sensitive data. <example> user: "Can you check my code for security issues?" assistant: [Launches security-privacy-scanner agent] </example> <example> user: "I need to prepare for App Store security review" assistant: [Launches security-privacy-scanner agent] </example> <example> user: "Are there any hardcoded credentials in my codebase?" assistant: [Launches security-privacy-scanner agent] </example> <example> user: "Do I need a Privacy Manifest?" assistant: [Launches security-privacy-scanner agent] </example> <example> user: "Check if I'm storing tokens securely" assistant: [Launches security-privacy-scanner agent] </example> Explicit command: Users can also invoke this agent directly with `/axiom:audit security` or `/axiom:audit privacy`

Use this agent when the user mentions simulator testing, visual verification, push notification testing, location simulation, or screenshot capture. Sets up test scenarios, captures screenshots, checks logs for crashes/errors, and iterates on fixes with visual verification. <example> user: "Take a screenshot to verify this fix" assistant: [Launches simulator-tester agent] </example> <example> user: "Test my app with location simulation" assistant: [Launches simulator-tester agent] </example> Explicit command: Users can also invoke this agent directly with `/axiom:test-simulator`

Use this agent when the user mentions SPM resolution failures, "no such module" errors, duplicate symbol linker errors, version conflicts between packages, or Swift 6 package compatibility issues. Analyzes Package.swift and Package.resolved to diagnose and resolve Swift Package Manager dependency conflicts. <example> user: "SPM won't resolve my dependencies" assistant: [Launches spm-conflict-resolver agent] </example> <example> user: "I'm getting 'No such module' after adding a package" assistant: [Launches spm-conflict-resolver agent] </example> <example> user: "Duplicate symbol linker error" assistant: [Launches spm-conflict-resolver agent] </example> <example> user: "Two packages require different versions of the same dependency" assistant: [Launches spm-conflict-resolver agent] </example> <example> user: "Package won't build with Swift 6" assistant: [Launches spm-conflict-resolver agent] </example> Explicit command: Users can also invoke this agent directly with `/axiom:resolve-deps`

Use this agent when the user wants to audit SpriteKit game code for common issues. Automatically scans for physics bitmask problems, draw call waste, node accumulation, action memory leaks, coordinate confusion, touch handling bugs, missing object pooling, and missing debug overlays. <example> user: "Can you check my SpriteKit code for issues?" assistant: [Launches spritekit-auditor agent] </example> <example> user: "Audit my game for performance problems" assistant: [Launches spritekit-auditor agent] </example> Explicit command: Users can also invoke this agent directly with `/axiom:audit spritekit`

Use this agent when the user mentions file storage issues, data loss, backup bloat, or asks to audit storage usage. Automatically runs comprehensive storage audit to detect files in wrong locations, missing backup exclusions, missing file protection, and storage anti-patterns - prevents data loss and backup bloat. <example> user: "Check my file storage usage" assistant: [Launches storage-auditor agent] </example> <example> user: "Audit my app for storage issues" assistant: [Launches storage-auditor agent] </example> <example> user: "My app backup is too large" assistant: [Launches storage-auditor agent] </example> <example> user: "Users are reporting lost data" assistant: [Launches storage-auditor agent] </example> <example> user: "Review my file management code" assistant: [Launches storage-auditor agent] </example> Explicit command: Users can also invoke this agent directly with `/axiom:audit storage`

Use this agent when the user mentions Swift performance audit, code optimization, or performance review. Automatically scans Swift code for performance anti-patterns - detects unnecessary copies, ARC overhead, unspecialized generics, collection inefficiencies, actor isolation costs, and memory layout issues that cause slowdowns and excessive allocations. <example> user: "Can you check my Swift code for performance issues?" assistant: [Launches swift-performance-analyzer agent] </example> <example> user: "Audit my code for optimization opportunities" assistant: [Launches swift-performance-analyzer agent] </example> <example> user: "I'm seeing excessive memory allocations, can you scan for problems?" assistant: [Launches swift-performance-analyzer agent] </example> <example> user: "Review my Swift performance anti-patterns" assistant: [Launches swift-performance-analyzer agent] </example> <example> user: "Check if I'm using COW correctly" assistant: [Launches swift-performance-analyzer agent] </example> Explicit command: Users can also invoke this agent directly with `/axiom:audit swift-performance`

Use this agent when the user mentions SwiftData review, @Model issues, SwiftData migration safety, or SwiftData performance checking. Automatically scans SwiftData code for the 10 most critical violations - struct models, missing VersionedSchema models, relationship defaults, migration timing, background context misuse, and N+1 patterns - prevents crashes, data loss, and silent corruption. <example> user: "Can you check my SwiftData code for issues?" assistant: [Launches swiftdata-auditor agent] </example> <example> user: "Review my @Model definitions for correctness" assistant: [Launches swiftdata-auditor agent] </example> <example> user: "I'm about to ship with SwiftData, can you audit it?" assistant: [Launches swiftdata-auditor agent] </example> <example> user: "Check my SwiftData migrations for safety" assistant: [Launches swiftdata-auditor agent] </example> <example> user: "My SwiftData relationships keep crashing" assistant: [Launches swiftdata-auditor agent] </example> Explicit command: Users can also invoke this agent directly with `/axiom:audit swiftdata`

Use this agent when the user mentions SwiftUI architecture review, separation of concerns, testability issues, or "logic in view" problems. Automatically scans SwiftUI code for architectural anti-patterns - logic in view bodies, async boundary violations, property wrapper misuse, and testability gaps. Complements (but is distinct from) performance and navigation audits. <example> user: "Check my SwiftUI architecture for separation of concerns" assistant: [Launches swiftui-architecture-auditor agent] </example> <example> user: "Review my view models and state management" assistant: [Launches swiftui-architecture-auditor agent] </example> <example> user: "Am I using @State correctly?" assistant: [Launches swiftui-architecture-auditor agent] </example> <example> user: "Audit my app for testability and business logic separation" assistant: [Launches swiftui-architecture-auditor agent] </example> Explicit command: Users can also invoke this agent directly with `/axiom:audit swiftui-architecture`

Use this agent when the user mentions SwiftUI layout review, adaptive layout issues, GeometryReader problems, or multi-device layout checking. Automatically scans SwiftUI layout code for the 10 most critical violations - GeometryReader misuse, deprecated screen APIs, hardcoded breakpoints, identity loss from conditional stacks, and missing lazy containers - prevents layout breaks across device sizes and orientations. <example> user: "Can you check my SwiftUI layouts for issues?" assistant: [Launches swiftui-layout-auditor agent] </example> <example> user: "Review my adaptive layout code" assistant: [Launches swiftui-layout-auditor agent] </example> <example> user: "My layout breaks on iPad, can you scan for problems?" assistant: [Launches swiftui-layout-auditor agent] </example> <example> user: "Check for GeometryReader misuse in my views" assistant: [Launches swiftui-layout-auditor agent] </example> <example> user: "Audit my SwiftUI code for hardcoded sizes" assistant: [Launches swiftui-layout-auditor agent] </example> Explicit command: Users can also invoke this agent directly with `/axiom:audit swiftui-layout`

Use this agent when the user mentions SwiftUI navigation issues, deep linking problems, state restoration bugs, or navigation architecture review. Automatically scans SwiftUI navigation code for architecture issues - detects missing NavigationPath, deep link gaps, state restoration problems, wrong container usage, and navigation correctness issues. <example> user: "Check my SwiftUI navigation for correctness issues" assistant: [Launches swiftui-nav-auditor agent] </example> <example> user: "My deep links aren't working, can you scan my navigation code?" assistant: [Launches swiftui-nav-auditor agent] </example> Explicit command: Users can also invoke this agent directly with `/axiom:audit swiftui-nav`

Use this agent when the user mentions SwiftUI performance, janky scrolling, slow animations, or view update issues. Automatically scans SwiftUI code for performance anti-patterns - detects expensive operations in view bodies, unnecessary updates, missing lazy loading, and SwiftUI-specific issues that cause frame drops. <example> user: "My SwiftUI app has janky scrolling, can you check for performance issues?" assistant: [Launches swiftui-performance-analyzer agent] </example> <example> user: "My views are updating too often, can you scan for issues?" assistant: [Launches swiftui-performance-analyzer agent] </example> Explicit command: Users can also invoke this agent directly with `/axiom:audit swiftui-performance`

Use this agent for closed-loop test debugging - automatically analyzes test failures, suggests fixes, and re-runs tests until passing. Combines test-runner with intelligent failure analysis using screenshots, logs, and pattern recognition. <example> user: "My LoginTests are failing, help me fix them" assistant: [Launches test-debugger agent] </example> <example> user: "Debug why testCheckout keeps timing out" assistant: [Launches test-debugger agent] </example> <example> user: "Fix my flaky UI tests" assistant: [Launches test-debugger agent] </example> Explicit command: Users can also invoke this agent directly with `/axiom:run-tests` (for debugging, specify the failing test)

Use this agent when the user mentions flaky tests, tests that pass locally but fail in CI, race conditions in tests, or needs to diagnose WHY a specific test fails. Focuses on Swift Testing patterns (confirmation, @MainActor, .serialized trait) and diagnoses root causes of intermittent failures. <example> user: "My tests fail randomly in CI" assistant: [Launches test-failure-analyzer agent] </example> <example> user: "This test passes locally but fails in CI" assistant: [Launches test-failure-analyzer agent] </example> <example> user: "I have a flaky test that fails 20% of the time" assistant: [Launches test-failure-analyzer agent] </example> <example> user: "My Swift Testing tests have race conditions" assistant: [Launches test-failure-analyzer agent] </example> <example> user: "Test passes individually, fails when run with others" assistant: [Launches test-failure-analyzer agent] </example> Explicit command: Users can also invoke this agent directly with `/axiom:audit test-failures`

Use this agent when the user wants to run XCUITests, parse test results, view test failures, or export test attachments. Runs xcodebuild test and parses .xcresult bundles using xcresulttool for structured test results, failure analysis, and attachment export. <example> user: "Run my UI tests and show me what failed" assistant: [Launches test-runner agent] </example> <example> user: "Run tests for the LoginTests scheme" assistant: [Launches test-runner agent] </example> <example> user: "Export the failure screenshots from my last test run" assistant: [Launches test-runner agent] </example> <example> user: "What tests failed and why?" assistant: [Launches test-runner agent] </example> Explicit command: Users can also invoke this agent directly with `/axiom:run-tests`

Use this agent when the user wants to audit test quality, find flaky test patterns, speed up test execution, or prepare for Swift Testing migration. Scans for sleep() calls, shared mutable state, missing assertions, XCTest to Swift Testing migration opportunities, and Swift 6 concurrency issues in tests. <example> user: "Can you audit my tests for issues?" assistant: [Launches testing-auditor agent] </example> <example> user: "Why are my tests flaky?" assistant: [Launches testing-auditor agent] </example> <example> user: "How can I make my tests faster?" assistant: [Launches testing-auditor agent] </example> <example> user: "Should I migrate to Swift Testing?" assistant: [Launches testing-auditor agent] </example> <example> user: "Check my tests for Swift 6 issues" assistant: [Launches testing-auditor agent] </example> Explicit command: Users can also invoke this agent directly with `/axiom:audit testing`

Use this agent when the user mentions TextKit review, text layout issues, Writing Tools integration, or UITextView/NSTextView code review. Automatically scans for TextKit 1 fallback triggers, deprecated glyph APIs, and missing TextKit 2 features - prevents loss of Writing Tools support and ensures modern text handling for complex scripts. <example> user: "Can you check my text editor for TextKit issues?" assistant: [Launches textkit-auditor agent] </example> <example> user: "Why isn't Writing Tools appearing in my text view?" assistant: [Launches textkit-auditor agent] </example> <example> user: "Review my UITextView code" assistant: [Launches textkit-auditor agent] </example> <example> user: "Check for TextKit 2 compatibility" assistant: [Launches textkit-auditor agent] </example> <example> user: "I need to add a text editor, can you review the implementation?" assistant: [Launches textkit-auditor agent] </example> Explicit command: Users can also invoke this agent directly with `/axiom:audit textkit`

Use when fixing VoiceOver issues, Dynamic Type violations, color contrast failures, touch target problems, keyboard navigation gaps, or Reduce Motion support - comprehensive accessibility diagnostics with WCAG compliance, Accessibility Inspector workflows, and App Store Review preparation for iOS/macOS

Use when implementing alarm functionality, scheduling wake alarms, or integrating AlarmKit with Live Activities. Covers AlarmKit authorization, alarm configuration, SwiftUI views, and Live Activity integration.

Use when structuring app entry points, managing authentication flows, switching root views, handling scene lifecycle, or asking 'how do I structure my @main', 'where does auth state live', 'how do I prevent screen flicker on launch', 'when should I modularize' - app-level composition patterns for iOS 26+

Use when making app surface in Spotlight search, Siri suggestions, or system experiences - covers the 6-step strategy combining App Intents, App Shortcuts, Core Spotlight, and NSUserActivity to feed the system metadata for iOS 16+

Use when integrating App Intents for Siri, Apple Intelligence, Shortcuts, Spotlight, or system experiences - covers AppIntent, AppEntity, parameter handling, entity queries, background execution, authentication, and debugging common integration issues for iOS 16+

Use when implementing App Shortcuts for instant Siri/Spotlight availability, configuring AppShortcutsProvider, adding suggested phrases, or debugging shortcuts not appearing - covers complete App Shortcuts API for iOS 16+

Reference for App Store Connect crash analysis, TestFlight feedback, metrics dashboards, and data export workflows

Use when app is rejected by App Review, submission blocked, or appeal needed - systematic diagnosis from rejection message to fix with guideline-specific remediation patterns and appeal writing

App Store submission reference — complete metadata field specs, App Review guideline index, privacy manifest schema, age rating system, export compliance, EU DSA requirements, IAP review pipeline, and WWDC25 submission changes

Use when preparing ANY app for App Store submission - enforces pre-flight checklist, rejection prevention, privacy compliance, and metadata completeness to prevent common App Store rejections

Use when researching Apple frameworks, APIs, or WWDC sessions - provides techniques for retrieving full transcripts, code samples, and documentation using Chrome browser and sosumi.ai

Use when ANY question involves Apple framework APIs, Swift compiler errors, or Xcode-bundled documentation. Covers Liquid Glass, Swift 6.2 concurrency, Foundation Models, SwiftData, StoreKit, 32 Swift compiler diagnostics.

Use when automating App Store Connect via MCP — submit builds, manage TestFlight, respond to reviews, triage feedback programmatically

Use when needing synchronous actor access in tests, legacy delegate callbacks, or performance-critical code. Covers MainActor.assumeIsolated, @preconcurrency protocol conformances, crash behavior, Task vs assumeIsolated.

Use when encountering "Unable to simultaneously satisfy constraints" errors, constraint conflicts, ambiguous layout warnings, or views positioned incorrectly - systematic debugging workflow for Auto Layout issues in iOS

Reference — AVFoundation audio APIs, AVAudioSession categories/modes, AVAudioEngine pipelines, bit-perfect DAC output, iOS 26+ spatial audio capture, ASAF/APAC, Audio Mix with Cinematic framework

Use when automating iOS Simulator UI interactions beyond simctl capabilities. Reference for AXe CLI covering accessibility-based tapping, gestures, text input, screenshots, video recording, and UI tree inspection.

Symptom-based background task troubleshooting - decision trees for 'task never runs', 'task terminates early', 'works in dev not prod', 'handler not called', with time-cost analysis for each diagnosis path

Complete background task API reference - BGTaskScheduler, BGAppRefreshTask, BGProcessingTask, BGContinuedProcessingTask (iOS 26), beginBackgroundTask, background URLSession, with all WWDC code examples

Use when implementing BGTaskScheduler, debugging background tasks that never run, understanding why tasks terminate early, or testing background execution - systematic task lifecycle management with proper registration, expiration handling, and Swift 6 cancellation patterns

Use when encountering dependency conflicts, CocoaPods/SPM resolution failures, "Multiple commands produce" errors, or framework version mismatches - systematic dependency and build configuration debugging for iOS projects. Includes pressure scenario guidance for resisting quick fixes under time constraints

Use when build times are slow, investigating build performance, analyzing Build Timeline, identifying type checking bottlenecks, enabling compilation caching, or optimizing incremental builds - comprehensive build optimization workflows including Xcode 26 compilation caching

camera freezes, preview rotated wrong, capture slow, session interrupted, black preview, front camera mirrored, camera not starting, AVCaptureSession errors, startRunning blocks, phone call interrupts camera

Reference — AVCaptureSession, AVCapturePhotoSettings, AVCapturePhotoOutput, RotationCoordinator, photoQualityPrioritization, deferred processing, AVCaptureMovieFileOutput, session presets, capture device APIs

AVCaptureSession, camera preview, photo capture, video recording, RotationCoordinator, session interruptions, deferred processing, capture responsiveness, zero-shutter-lag, photoQualityPrioritization, front camera mirroring

Use when debugging 'file not syncing', 'CloudKit error', 'sync conflict', 'iCloud upload failed', 'ubiquitous item error', 'data not appearing on other devices', 'CKError', 'quota exceeded' - systematic iCloud sync diagnostics for both CloudKit and iCloud Drive

Use when choosing between CloudKit vs iCloud Drive, implementing reliable sync, handling offline-first patterns, or designing sync architecture - prevents common sync mistakes that cause data loss

Use when implementing 'CloudKit sync', 'CKSyncEngine', 'CKRecord', 'CKDatabase', 'SwiftData CloudKit', 'shared database', 'public database', 'CloudKit zones', 'conflict resolution' - comprehensive CloudKit database APIs and modern sync patterns reference

Use when working with Codable protocol, JSON encoding/decoding, CodingKeys customization, enum serialization, date strategies, custom containers, or encountering "Type does not conform to Decodable/Encodable" errors - comprehensive Codable patterns and anti-patterns for Swift 6.x

Use when profiling async/await performance, diagnosing actor contention, or investigating thread pool exhaustion. Covers Swift Concurrency Instruments template, task visualization, actor contention analysis, thread pool debugging.

Use when debugging schema migration crashes, concurrency thread-confinement errors, N+1 query performance, SwiftData to Core Data bridging, or testing migrations without data loss - systematic Core Data diagnostics with safety-first migration patterns

Use when choosing Core Data vs SwiftData, setting up the Core Data stack, modeling relationships, or implementing concurrency patterns - prevents thread-confinement errors and migration crashes

Use for Core Location troubleshooting - no location updates, background location broken, authorization denied, geofence not triggering

Use for Core Location API reference - CLLocationUpdate, CLMonitor, CLServiceSession, authorization, background location, geofencing

Use for Core Location implementation patterns - authorization strategy, monitoring strategy, accuracy selection, background location

Use when indexing app content for Spotlight search, using NSUserActivity for prediction/handoff, or choosing between CSSearchableItem and IndexedEntity - covers Core Spotlight framework and NSUserActivity integration for iOS 9+

Use when adding/modifying database columns, encountering "FOREIGN KEY constraint failed", "no such column", "cannot add NOT NULL column" errors, or creating schema migrations for SQLite/GRDB/SQLiteData - prevents data loss with safe migration patterns and testing workflows for iOS/macOS apps

Use when adding debug-only deep links for testing, enabling simulator navigation to specific screens, or integrating with automated testing workflows - enables closed-loop debugging without production deep link implementation

Use when app runs at unexpected frame rate, stuck at 60fps on ProMotion, frame pacing issues, or configuring render loops. Covers MTKView, CADisplayLink, CAMetalDisplayLink, frame pacing, hitches, system caps.

Symptom-based energy troubleshooting - decision trees for 'app at top of battery settings', 'phone gets hot', 'background drain', 'high cellular usage', with time-cost analysis for each diagnosis path

Complete energy optimization API reference - Power Profiler workflows, timer/network/location/background APIs, iOS 26 BGContinuedProcessingTask, MetricKit monitoring, with all WWDC code examples

Use when app drains battery, device gets hot, users report energy issues, or auditing power consumption - systematic Power Profiler diagnosis, subsystem identification (CPU/GPU/Network/Location/Display), anti-pattern fixes for iOS/iPadOS

Use when implementing widgets, Live Activities, Control Center controls, or app extensions - comprehensive API reference for WidgetKit, ActivityKit, App Groups, and extension lifecycle for iOS 14+

Use when implementing widgets, Live Activities, or Control Center controls - enforces correct patterns for timeline management, data sharing, and extension lifecycle to prevent common crashes and memory issues

Use when asking about 'FileProtectionType', 'file encryption iOS', 'NSFileProtection', 'data protection', 'secure file storage', 'encrypt files at rest', 'complete protection', 'file security' - comprehensive reference for iOS file encryption and data protection APIs

Use when debugging Foundation Models issues — context exceeded, guardrail violations, slow generation, availability problems, unsupported language, or unexpected output. Systematic diagnostics with production crisis defense.

Reference — Complete Foundation Models framework guide covering LanguageModelSession, @Generable, @Guide, Tool protocol, streaming, dynamic schemas, built-in use cases, and all WWDC 2025 code examples

Use when implementing on-device AI with Apple's Foundation Models framework — prevents context overflow, blocking UI, wrong model use cases, and manual JSON parsing when @Generable should be used. iOS 26+, macOS 26+, iPadOS 26+, axiom-visionOS 26+

Use when first installing Axiom, unsure which skill to use, want an overview of available skills, or need help finding the right skill for your situation — interactive onboarding that recommends skills based on your project and current focus

Use when writing raw SQL queries with GRDB, complex joins, ValueObservation for reactive queries, DatabaseMigrator patterns, query profiling under performance pressure, or dropping down from SQLiteData for performance - direct SQLite access for iOS/macOS

Use when app freezes, UI unresponsive, main thread blocked, watchdog termination, or diagnosing hang reports from Xcode Organizer or MetricKit

Use when implementing haptic feedback, Core Haptics patterns, audio-haptic synchronization, or debugging haptic issues - covers UIFeedbackGenerator, CHHapticEngine, AHAP patterns, and Apple's Causality-Harmony-Utility design principles from WWDC 2021

Reference — Comprehensive Apple Human Interface Guidelines covering colors (semantic, custom, patterns), backgrounds (material hierarchy, dynamic), typography (built-in styles, custom fonts, Dynamic Type), SF Symbols (rendering modes, color, axiom-localization), Dark Mode, accessibility, and platform-specific considerations

Use when making design decisions, reviewing UI for HIG compliance, choosing colors/backgrounds/typography, or defending design choices - quick decision frameworks and checklists for Apple Human Interface Guidelines

Use when implementing 'iCloud Drive', 'ubiquitous container', 'file sync', 'NSFileCoordinator', 'NSFilePresenter', 'isUbiquitousItem', 'NSUbiquitousKeyValueStore', 'ubiquitous file sync' - comprehensive file-based iCloud sync reference

Use when implementing in-app purchases, StoreKit 2, subscriptions, or transaction handling - testing-first workflow with .storekit configuration, StoreManager architecture, transaction verification, subscription management, and restore purchases for consumables, non-consumables, and auto-renewable subscriptions

Use when fixing or auditing ANY accessibility issue - VoiceOver, Dynamic Type, color contrast, touch targets, WCAG compliance, App Store accessibility review.

Use when implementing ANY Apple Intelligence or on-device AI feature. Covers Foundation Models, @Generable, LanguageModelSession, structured output, Tool protocol, iOS 26 AI integration.

Use when ANY iOS build fails, test crashes, Xcode misbehaves, or environment issue occurs before debugging code. Covers build failures, compilation errors, dependency conflicts, simulator problems, environment-first diagnostics.

Use when writing ANY code with async, actors, threads, or seeing ANY concurrency error. Covers Swift 6 concurrency, @MainActor, Sendable, data races, async/await patterns, performance optimization.

Use when working with ANY data persistence, database, axiom-storage, CloudKit, migration, or serialization. Covers SwiftData, Core Data, GRDB, SQLite, CloudKit sync, file storage, Codable, migrations.

Use when building ANY 2D or 3D game, game prototype, or interactive simulation with SpriteKit, SceneKit, or RealityKit. Covers scene graphs, ECS architecture, physics, actions, game loops, rendering, SwiftUI integration, SceneKit migration.

Use when working with ANY GPU rendering, Metal, OpenGL migration, shaders, 3D content, RealityKit, AR, or display performance. Covers Metal migration, shader conversion, RealityKit ECS, RealityView, variable refresh rate, ProMotion.

Use when integrating ANY iOS system feature - Siri, Shortcuts, Apple Intelligence, widgets, IAP, camera, photo library, photos picker, audio, axiom-haptics, axiom-localization, privacy, alarms. Covers App Intents, WidgetKit, StoreKit, AVFoundation, PHPicker, PhotosPicker, Core Haptics, App Shortcuts, Spotlight, AlarmKit.

Use when deploying ANY machine learning model on-device, converting models to CoreML, compressing models, or implementing speech-to-text. Covers CoreML conversion, MLTensor, model compression (quantization/palettization/pruning), stateful models, KV-cache, multi-function models, async prediction, SpeechAnalyzer, SpeechTranscriber.

CoreML diagnostics - model load failures, slow inference, memory issues, compression accuracy loss, compute unit problems, conversion errors.

CoreML API reference - MLModel lifecycle, MLTensor operations, coremltools conversion, compression APIs, state management, compute device availability, performance profiling.

Use when deploying custom ML models on-device, converting PyTorch models, compressing models, implementing LLM inference, or optimizing CoreML performance. Covers model conversion, compression, stateful models, KV-cache, multi-function models, MLTensor.

Use when implementing speech-to-text, live transcription, or audio transcription. Covers SpeechAnalyzer (iOS 26+), SpeechTranscriber, volatile/finalized results, AssetInventory model management, audio format handling.

Use when implementing or debugging ANY network connection, API call, or socket. Covers URLSession, Network.framework, NetworkConnection, deprecated APIs, connection diagnostics, structured concurrency networking.

Use when app feels slow, memory grows, battery drains, or diagnosing ANY performance issue. Covers memory leaks, profiling, Instruments workflows, retain cycles, performance optimization.

Use when writing ANY test, debugging flaky tests, making tests faster, or asking about Swift Testing vs XCTest. Covers unit tests, UI tests, fast tests without simulator, async testing, test architecture.

Use when building, fixing, or improving ANY iOS UI including SwiftUI, UIKit, layout, navigation, animations, design guidelines. Covers view updates, layout bugs, navigation issues, performance, architecture, Apple design compliance.

Use when implementing ANY computer vision feature - image analysis, object detection, pose detection, person segmentation, subject lifting, hand/body pose tracking.

Use when planning comprehensive Liquid Glass adoption across an app, auditing existing interfaces for Liquid Glass compatibility, implementing app icon updates, or understanding platform-specific Liquid Glass behavior - comprehensive reference guide covering all aspects of Liquid Glass adoption from WWDC 2025

Use when implementing Liquid Glass effects, reviewing UI for Liquid Glass adoption, debugging visual artifacts, optimizing performance, or requesting expert review of Liquid Glass implementation - provides comprehensive design principles, API patterns, and troubleshooting guidance from WWDC 2025. Includes design review pressure handling and professional push-back frameworks

Complete LLDB command reference — variable inspection, breakpoints, threads, expression evaluation, process control, memory commands, and .lldbinit customization

Use when ANY runtime debugging is needed — setting breakpoints, inspecting variables, evaluating expressions, analyzing threads, or reproducing crashes interactively with LLDB

Use when localizing apps, using String Catalogs, generating type-safe symbols (Xcode 26+), handling plurals, RTL layouts, locale-aware formatting, or migrating from .strings files - comprehensive i18n patterns for Xcode 15-26

MapKit troubleshooting — annotations not appearing, region jumping, clustering not working, search failures, overlay rendering issues, user location problems

MapKit API reference — SwiftUI Map, MKMapView, Marker, Annotation, MKLocalSearch, MKDirections, Look Around, MKMapSnapshotter, clustering, overlays, GeoToolbox PlaceDescriptor, geocoding

Use when implementing maps, annotations, search, directions, or debugging MapKit display/performance issues - SwiftUI Map, MKMapView, MKLocalSearch, clustering, Look Around

Use when you see memory warnings, 'retain cycle', app crashes from memory pressure, or when asking 'why is my app using so much memory', 'how do I find memory leaks', 'my deinit is never called', 'Instruments shows memory growth', 'app crashes after 10 minutes' - systematic memory leak detection and fixes for iOS/macOS

Use when ANY Metal porting issue occurs - black screen, rendering artifacts, shader errors, wrong colors, performance regressions, GPU crashes

Use when converting shaders or looking up API equivalents - GLSL to MSL, HLSL to MSL, GL/DirectX to Metal mappings, MTKView setup code

Use when porting OpenGL/DirectX to Metal - translation layer vs native rewrite decisions, migration planning, anti-patterns

MetricKit API reference for field diagnostics - MXMetricPayload, MXDiagnosticPayload, MXCallStackTree parsing, crash and hang collection

Reference — Comprehensive Network.framework guide covering NetworkConnection (iOS 26+), NWConnection (iOS 12-25), TLV framing, Coder protocol, NetworkListener, NetworkBrowser, Wi-Fi Aware discovery, and migration strategies

Use when debugging connection timeouts, TLS handshake failures, data not arriving, connection drops, performance issues, or proxy/VPN interference - systematic Network.framework diagnostics with production crisis defense

This skill should be used when working with NWConnection patterns for iOS 12-25, supporting apps that can't use async/await yet, or maintaining backward compatibility with completion handler networking.

Network framework migration guides. Use when migrating from BSD sockets to NWConnection, NWConnection to NetworkConnection (iOS 26+), or URLSession StreamTask to NetworkConnection.

Use when implementing Network.framework connections, debugging connection failures, migrating from sockets/URLSession streams, or adopting structured concurrency networking patterns - prevents deprecated API usage, reachability anti-patterns, and thread-safety violations with iOS 12-26+ APIs

CarPlay Now Playing integration patterns. Use when implementing CarPlay audio controls, CPNowPlayingTemplate customization, or debugging CarPlay-specific issues.

MusicKit Now Playing integration patterns. Use when playing Apple Music content with ApplicationMusicPlayer and understanding automatic vs manual Now Playing info updates.

Use when Now Playing metadata doesn't appear on Lock Screen/Control Center, remote commands (play/pause/skip) don't respond, artwork is missing/wrong/flickering, or playback state is out of sync - provides systematic diagnosis, correct patterns, and professional push-back for audio/video apps on iOS 18+

Use when debugging memory leaks from blocks, blocks assigned to self or properties, network callbacks, or crashes from deallocated objects - systematic weak-strong pattern diagnosis with mandatory diagnostic rules

Use when optimizing large value type performance, working with noncopyable types, reducing ARC traffic, or using InlineArray/Span for zero-copy memory access. Covers borrowing, consuming, inout modifiers, consume operator, ~Copyable types, InlineArray, Span, value generics.

Use when app feels slow, memory grows over time, battery drains fast, or you want to profile proactively - decision trees to choose the right Instruments tool, deep workflows for Time Profiler/Allocations/Core Data, and pressure scenarios for misinterpreting results

Reference — PHPickerViewController, PHPickerConfiguration, PhotosPicker, PhotosPickerItem, Transferable, PHPhotoLibrary, PHAsset, PHAssetCreationRequest, PHFetchResult, PHAuthorizationStatus, limited library APIs

PHPicker, PhotosPicker, photo selection, limited library access, presentLimitedLibraryPicker, save to camera roll, PHPhotoLibrary, PHAssetCreationRequest, Transferable, PhotosPickerItem, photo permissions

Use when implementing privacy manifests, requesting permissions, App Tracking Transparency UX, or preparing Privacy Nutrition Labels - covers just-in-time permission requests, tracking domain management, and Required Reason APIs from WWDC 2023

Use when RealityKit entities not visible, anchors not tracking, gestures not responding, performance drops, materials wrong, or multiplayer sync fails

RealityKit API reference — Entity, Component, System, RealityView, Model3D, anchor types, material system, physics, collision, animation, audio, accessibility

Use when building 3D content, AR experiences, or spatial computing with RealityKit. Covers ECS architecture, SwiftUI integration, RealityView, AR anchors, materials, physics, interaction, multiplayer, performance.

Use when migrating from Realm to SwiftData - comprehensive migration guide covering pattern equivalents, threading model conversion, schema migration strategies, CloudKit sync transition, and real-world scenarios

SceneKit → RealityKit concept mapping, complete API cross-reference for migration, scene graph API, materials, lighting, camera, physics, animation, constraints

Use when working with SceneKit 3D scenes, migrating SceneKit to RealityKit, or maintaining legacy SceneKit code. Covers scene graph, materials, physics, animation, SwiftUI bridge, migration decision tree.

Use when you need complete SF Symbols API reference including every rendering mode, symbol effect, configuration option, UIKit equivalent, and platform availability - comprehensive code examples for iOS 17 through iOS 26

Use when implementing SF Symbols rendering modes, symbol effects, animations, custom symbols, or troubleshooting symbol appearance - covers the full symbol effects system from iOS 17 through SF Symbols 7 Draw animations in iOS 26

Use when preparing ANY app for submission, handling App Store rejections, writing appeals, or managing App Store Connect. Covers submission checklists, rejection troubleshooting, metadata requirements, privacy manifests, age ratings, export compliance.

Use when physics contacts don't fire, objects tunnel through walls, frame rate drops, touches don't register, memory spikes, coordinate confusion, or scene transition crashes

SpriteKit API reference — all node types, physics body creation, action catalog, texture atlases, constraints, scene setup, particles, SKRenderer

Use when building SpriteKit games, implementing physics, actions, scene management, or debugging game performance. Covers scene graph, physics engine, actions system, game loop, rendering optimization.

Use when migrating from SwiftData to SQLiteData — decision guide, pattern equivalents, code examples, CloudKit sharing (SwiftData can't), performance benchmarks, gradual migration strategy

SQLiteData advanced patterns, @Selection column groups, single-table inheritance, recursive CTEs, database views, custom aggregates, TableAlias self-joins, JSON/string aggregation

Use when working with SQLiteData @Table models, CRUD operations, query patterns, CloudKit SyncEngine setup, or batch imports. Covers model definitions, @FetchAll/@FetchOne, upsert patterns, database setup with Dependencies.

Use when debugging 'files disappeared', 'data missing after restart', 'backup too large', 'can't save file', 'file not found', 'storage full error', 'file inaccessible when locked' - systematic local file storage diagnostics

Use when asking about 'purge files', 'storage pressure', 'disk space iOS', 'isExcludedFromBackup', 'URL resource values', 'volumeAvailableCapacity', 'low storage', 'file purging priority', 'cache management' - comprehensive reference for iOS storage management and URL resource value APIs

Use when asking 'where should I store this data', 'should I use SwiftData or files', 'CloudKit vs iCloud Drive', 'Documents vs Caches', 'local or cloud storage', 'how do I sync data', 'where do app files go' - comprehensive decision framework for all iOS storage options

Reference — Complete StoreKit 2 API guide covering Product, Transaction, AppTransaction, RenewalInfo, SubscriptionStatus, StoreKit Views, purchase options, server APIs, and all iOS 18.4 enhancements with WWDC 2025 code examples

Swift concurrency API reference — actors, Sendable, Task/TaskGroup, AsyncStream, continuations, isolation patterns, DispatchQueue-to-actor migration with gotcha tables

Use when you see 'actor-isolated', 'Sendable', 'data race', '@MainActor' errors, or when asking 'why is this not thread safe', 'how do I use async/await', 'what is @MainActor for', 'my app is crashing with concurrency errors', 'how do I fix data races' - Swift 6 strict concurrency patterns with actor isolation and async/await

Use when optimizing Swift code performance, reducing memory usage, improving runtime efficiency, dealing with COW, ARC overhead, generics specialization, or collection optimization

Use when writing unit tests, adopting Swift Testing framework, making tests run faster without simulator, architecting code for testability, testing async code reliably, or migrating from XCTest - covers @Test/@Suite macros,

Use when SwiftData migrations crash, fail to preserve relationships, lose data, or work in simulator but fail on device - systematic diagnostics for schema version mismatches, relationship errors, and migration testing gaps

Use when creating SwiftData custom schema migrations with VersionedSchema and SchemaMigrationPlan - property type changes, relationship preservation (one-to-many, many-to-many), the willMigrate/didMigrate limitation, two-stage migration patterns, and testing migrations on real devices

Use when working with SwiftData - @Model definitions, @Query in SwiftUI, @Relationship macros, ModelContext patterns, CloudKit integration, iOS 26+ features, and Swift 6 concurrency with @MainActor — Apple's native persistence framework

Use when implementing iOS 26 SwiftUI features - covers Liquid Glass design system, performance improvements, @Animatable macro, 3D spatial layout, scene bridging, WebView/WebPage, AttributedString rich text editing, drag and drop enhancements, and visionOS integration for iOS 26+

Use when implementing SwiftUI animations, understanding VectorArithmetic, using @Animatable macro, zoom transitions, UIKit/AppKit animation bridging, choosing between spring and timing curve animations, or debugging animation behavior - comprehensive animation reference from iOS 13 through iOS 26

Use when separating logic from SwiftUI views, choosing architecture patterns, refactoring view files, or asking 'where should this code go', 'how do I organize my SwiftUI app', 'MVVM vs TCA vs vanilla SwiftUI', 'how do I make SwiftUI testable' - comprehensive architecture patterns with refactoring workflows for iOS 26+

Reference — SwiftUI stacks, grids, outlines, and scroll enhancements through iOS 26

Use when SwiftUI view debugging requires systematic investigation - view updates not working after basic troubleshooting, intermittent UI issues, complex state dependencies, or when Self._printChanges() shows unexpected update patterns - systematic diagnostic workflows with Instruments integration

Use when debugging SwiftUI view updates, preview crashes, or layout issues - diagnostic decision trees to identify root causes quickly and avoid misdiagnosis under pressure

Use when implementing SwiftUI gestures (tap, drag, long press, magnification, rotation), composing gestures, managing gesture state, or debugging gesture conflicts - comprehensive patterns for gesture recognition, composition, accessibility, and cross-platform support

Reference — Complete SwiftUI adaptive layout API guide covering ViewThatFits, AnyLayout, Layout protocol, onGeometryChange, GeometryReader, size classes, and iOS 26 window APIs

Use when layouts need to adapt to different screen sizes, iPad multitasking, or iOS 26 free-form windows — decision trees for ViewThatFits vs AnyLayout vs onGeometryChange, size class limitations, and anti-patterns preventing device-based layout mistakes

Use when debugging navigation not responding, unexpected pops, deep links showing wrong screen, state lost on tab switch or background, crashes in navigationDestination, or any SwiftUI navigation failure - systematic diagnostics with production crisis defense

Reference — Comprehensive SwiftUI navigation guide covering NavigationStack (iOS 16+), NavigationSplitView (iOS 16+), NavigationPath, deep linking, state restoration, Tab+Navigation integration (iOS 18+), Liquid Glass navigation (iOS 26+), and coordinator patterns

Use when implementing navigation patterns, choosing between NavigationStack and NavigationSplitView, handling deep links, adopting coordinator patterns, or requesting code review of navigation implementation - prevents navigation state corruption, deep link failures, and state restoration bugs for iOS 18+

Use when UI is slow, scrolling lags, animations stutter, or when asking 'why is my SwiftUI view slow', 'how do I optimize List performance', 'my app drops frames', 'view body is called too often', 'List is laggy' - SwiftUI performance optimization with Instruments 26 and WWDC 2025 patterns

Use when implementing SwiftUI search — .searchable, isSearching, search suggestions, scopes, tokens, programmatic search control (iOS 15-18). For iOS 26 search refinements (bottom-aligned, minimized toolbar, search tab role), see swiftui-26-ref.

Use when needing thread-safe primitives for performance-critical code. Covers Mutex (iOS 18+), OSAllocatedUnfairLock (iOS 16+), Atomic types, when to use locks vs actors, deadlock prevention with Swift Concurrency.

Use when ANY beta tester reports a crash, ANY crash appears in Organizer or App Store Connect, crash logs need symbolication, app was killed without crash report, or you need to triage TestFlight feedback

Use when testing async code with Swift Testing. Covers confirmation for callbacks, @MainActor tests, async/await patterns, timeout control, XCTest migration, parallel test execution.

TextKit 2 complete reference (architecture, migration, Writing Tools, SwiftUI TextEditor) through iOS 26

Timer, DispatchSourceTimer, Combine Timer.publish, AsyncTimerSequence, Task.sleep API reference with lifecycle diagrams, RunLoop modes, and platform availability

Use when implementing timers, debugging timer crashes (EXC_BAD_INSTRUCTION), Timer stops during scrolling, or choosing between Timer/DispatchSourceTimer/Combine/async timer APIs

Use when implementing drag and drop, copy/paste, ShareLink, or ANY content sharing between apps or views - covers Transferable protocol, TransferRepresentation types, UTType declarations, SwiftUI surfaces, and NSItemProvider bridging

Use when building ANY tvOS app - covers Focus Engine, Siri Remote input, storage constraints (no Document directory), no WebView, TVUIKit, TextField workarounds, AVPlayer tuning, Menu button state machines, and tvOS-specific gotchas that catch iOS developers

Apple platform typography reference (San Francisco fonts, text styles, Dynamic Type, tracking, leading, internationalization) through iOS 26

Use when setting up UI test recording in Xcode 26, enhancing recorded tests for stability, or configuring test plans for multi-configuration replay. Based on WWDC 2025-344 "Record, replay, and review".

Use when writing UI tests, recording interactions, tests have race conditions, timing dependencies, inconsistent pass/fail behavior, or XCTest UI tests are flaky - covers Recording UI Automation (WWDC 2025), condition-based waiting, network conditioning, multi-factor testing, crash debugging, and accessibility-first testing patterns

Use when CAAnimation completion handler doesn't fire, spring physics look wrong on device, animation duration mismatches actual time, gesture + animation interaction causes jank, or timing differs between simulator and real hardware - systematic CAAnimation diagnosis with CATransaction patterns, frame rate awareness, and device-specific behavior

Use when wrapping UIKit views/controllers in SwiftUI, embedding SwiftUI in UIKit, or debugging UIKit-SwiftUI interop issues. Covers UIViewRepresentable, UIViewControllerRepresentable, UIHostingController, UIHostingConfiguration, coordinators, lifecycle, state binding, memory management.

Use when starting any iOS/Swift conversation - establishes how to find and use Axiom skills, requiring Skill tool invocation before ANY response including clarifying questions

subject not detected, hand pose missing landmarks, low confidence observations, Vision performance, coordinate conversion, VisionKit errors, observation nil, text not recognized, barcode not detected, DataScannerViewController not working, document scan issues

Use when needing Vision framework API details for hand/body pose, segmentation, text recognition, barcode detection, document scanning, or Visual Intelligence integration. Covers VNRequest types, coordinate conversion, DataScannerViewController, RecognizeDocumentsRequest, SemanticContentDescriptor, IntentValueQuery.

subject segmentation, VNGenerateForegroundInstanceMaskRequest, isolate object from hand, VisionKit subject lifting, image foreground detection, instance masks, class-agnostic segmentation, VNRecognizeTextRequest, OCR, VNDetectBarcodesRequest, DataScannerViewController, document scanning, RecognizeDocumentsRequest

Use when encountering BUILD FAILED, test crashes, simulator hangs, stale builds, zombie xcodebuild processes, "Unable to boot simulator", "No such module" after SPM changes, or mysterious test failures despite no code changes - systematic environment-first diagnostics for iOS/macOS projects

Reference — all 20 Xcode MCP tools with parameters, return schemas, and examples

Xcode MCP setup — enable mcpbridge, per-client config, permission handling, multi-Xcode targeting, troubleshooting

Xcode MCP workflow patterns — BuildFix loop, TestFix loop, preview verification, window targeting, tool gotchas

Use when connecting to Xcode via MCP, using xcrun mcpbridge, or working with ANY Xcode MCP tool (XcodeRead, BuildProject, RunTests, RenderPreview). Covers setup, tool reference, workflow patterns, troubleshooting.

Use when writing, running, or debugging XCUITests. Covers element queries, waiting strategies, accessibility identifiers, test plans, and CI/CD test execution patterns.

Use when automating Instruments profiling, running headless performance analysis, or integrating profiling into CI/CD - comprehensive xctrace CLI reference with record/export patterns

5 hooks across 4 events