dpearson2699/swift-ios-skills
83 skills119k installs59.2k starsGitHub
Install
npx skills add https://github.com/dpearson2699/swift-ios-skillsSkills in this repo
1Swiftui Animationswiftui-animation is a deep SwiftUI motion reference for solo and indie iOS builders who already ship SwiftUI but need authoritative patterns beyond a short SKILL summary. It documents CustomAnimation (iOS 17+), spring and UnitCurve variants, PhaseAnimator and KeyframeAnimator multi-track setups, transaction-scoped implicit animation, transition and symbol-effect types, Reduce Motion compliance, and performance tips. Use it when an agent is implementing or refactoring animations—loading states, navigation transitions, SF Symbol effects, or custom curves—so code matches Apple’s APIs instead of fragile copy-paste. It is reference-grade procedural knowledge for Claude Code, Cursor, and Codex sessions on native iOS apps, not a generator or CI checker. Pair it with your feature spec and existing view hierarchy; outcomes are correct, accessible animation code aligned with current SDK capabilities.2.2kinstalls2Ios AccessibilityiOS Accessibility is a checker-style agent skill aimed at solo iOS builders who need a structured pass on SwiftUI before users with assistive tech hit production. The bundled eval frames a realistic shopping-cart screen—icon rows, custom steppers, swipe-to-delete, duplicate Edit actions, heart favorites, sheets, and photos—and expects a practical remediation list rather than WCAG boilerplate. The skill pushes you through Apple-specific expectations: correct accessibility labels, values, and traits; combining children to reduce rotor fatigue; custom accessibility actions when gestures are the only path; Voice Control naming; focus restoration after sheets; Dynamic Type layout tolerance; decorative versus content images; and Reduce Motion alternatives. Use it during Build while views are still open for refactor, then again in Ship as a pre-release accessibility gate for TestFlight or App Store review risk.2.1kinstalls3Swiftui Patternsswiftui-patterns is an agent skill that encodes SwiftUI architecture guidance for solo and indie iOS builders who want fewer framework fights and clearer data flow. It argues for lightweight MV—views as orchestration, business logic in models and services—and explains why gratuitous MVVM often works against SwiftUI’s struct-based lifecycle. The readme walks through core principles, practical MV patterns, migration paths when ViewModels already exist, injection choices, and a testing approach that keeps UI thin. Use it when your agent is scaffolding screens, debating state ownership, or refactoring oversized views into subviews instead of new layers. It matters because consistent architecture reduces rework before TestFlight and makes agent-generated SwiftUI easier to review and extend.2kinstalls4Swiftui PerformanceSwiftUI Performance summarizes Apple’s Demystify SwiftUI Performance (WWDC23) for solo iOS builders who see scroll hitches, launch hangs, or views that redraw too often. The skill encodes a single rule: only work required for the current state should run for the current frame. When that fails, blame excess per-update work, updates that fire too often, or unstable identity that forces SwiftUI to redo reusable work. The prescribed loop is Measure, Identify, Optimize, and Re-measure—re-measure is mandatory because SwiftUI optimizations are easy to misjudge visually. Practical sections cover precise dependencies (rows should not depend on whole collections), expensive body work, ForEach and List identity, initialization traps, Instruments-oriented debugging, fix patterns, and what to verify after a change. Use it during active UI implementation and again in Ship when profiling before release.2kinstalls5Ios Networkingios-networking is a Swift-focused agent skill packaged with structured evals that steer reviews of production-grade API clients on iOS. When you are building a mobile SaaS or consumer app, the skill pushes you past URLSession.shared shortcuts toward configured sessions, explicit HTTP status handling before decoding, and retry rules that exclude cancellation and most client errors while allowing sensible 429/5xx backoff. It reinforces security boundaries by keeping bearer tokens out of UserDefaults and deferring deep credential storage to dedicated security skills, while still demanding auth headers via centralized request construction. Solo indie iOS developers use it during implementation and pre-ship review so agents output a concise correction plan with Swift snippets. The bundled eval assertions act as a quality bar aligned with ship-phase testing expectations without replacing a full security audit.1.9kinstalls6Ios Localizationios-localization is a Swift-focused agent skill for solo iOS and macOS builders who must ship in multiple languages without silent UI bugs or review friction. It walks through modern Apple stack pieces: String Catalogs, compile-time-safe generated symbols, plural rules, FormatStyle for locale-correct numbers and dates, and RTL mirroring so navigation and stacks behave in Arabic and Hebrew. The skill emphasizes naming stable keys, choosing the right string types for SwiftUI vs programmatic copy, and testing pseudolocalization before release. Mistakes here show up as truncated buttons, wrong plural forms, or broken trailing layouts—exactly the class of issues that hurt conversion outside English-first markets. Invoke it when adding a new locale, migrating from legacy .strings files, or reviewing a PR that touches user-visible copy so you treat i18n as part of frontend engineering, not a last-minute export.1.9kinstalls7Push NotificationsPush-notifications is an agent skill for solo and indie iOS builders who need APNs done correctly the first time. It focuses on Swift and SwiftUI setups where teams often gate registerForRemoteNotifications on alert permission, cache tokens locally, or blur simulator behavior with real device registration. The skill walks through when to request user-visible notification authorization versus when you still need a device token for silent pushes and server-side binding. It also reviews backend payload choices—especially background apns-push-type, priority, and expiration—so chat or sync jobs do not spam high-priority alerts or rely on silent pushes as a substitute for robust sync. Use it while implementing notification delegates, token upload endpoints, and entitlement-backed capabilities, or when auditing an existing flow before TestFlight or production. The output is correction-focused guidance aligned with Apple’s separation of concerns, not a generic permission tutorial.1.9kinstalls8StorekitStoreKit is a Swift iOS agent skill focused on StoreKit 2 in-app purchases and auto-renewable subscriptions for modern iOS targets. It walks solo developers through loading products, presenting paywalls with SubscriptionStoreView or ProductView, processing purchases, listening to Transaction.updates, verifying entitlements, checking subscription status, restoring purchases, and handling edge cases such as billing retry, refunds, Family Sharing, and Ask to Buy. The skill positions StoreKit 2 as the default path and discourages older StoreKit 1 types, which reduces review churn and deprecation risk. Use it when you are shipping a freemium SaaS-style mobile app, tightening monetization before launch, or auditing an existing paywall implementation. It spans build work on the client, validate-phase pricing experiments, grow-phase lifecycle monetization, and ship-phase readiness including StoreKit configuration files for testing. Depth is advanced because Apple's purchase state machine, offer types, and entitlement timing are easy to get wrong without a structured checklist.1.8kinstalls9Swiftui NavigationSwiftui-navigation teaches solo iOS builders how to funnel every external entry point—custom schemes, Universal Links, and Handoff continuity—through a single MainActor router instead of scattering URL logic across views. The skill shows concrete RouterPath APIs that return OpenURLAction.Result, distinguish internal federation URLs from links that should open in Safari, and navigate typed routes such as status detail screens. Extension-friendly examples attach handlers at the app root so SwiftUI’s environment propagates deep-link behavior app-wide. Pitfalls and design-choice sections steer agents away from duplicate parsers and brittle path assumptions. Reach for it when your indie app must share content via URLs, support OAuth callbacks, or resume tasks from another device without breaking Apple’s system fallback semantics.1.8kinstalls10Swift Concurrencyswift-concurrency is an agent skill for solo iOS builders shipping with Swift 6 and recent Xcode releases. It focuses on approachable concurrency settings, default actor isolation, strict concurrency levels, and when CPU-bound work must leave the MainActor using @concurrent or nonisolated patterns. Use it while implementing features in Build, and again in Ship review when a teammate’s plan conflates migration toggles with full Swift 6 error semantics. The skill is written for agents that must not hand-wave actor hopping or mislabel nonisolated async behavior. It pairs well with architecture reviews before merge and reduces MainActor jank from decoding and heavy synchronous work on the UI actor.1.8kinstalls11SwiftdataSwiftdata is an agent skill for indie iOS builders shipping with Swift 6.3 and iOS 26+ who want SwiftData done by the book—not copied from outdated Core Data snippets. It covers defining @Model types, querying with #Predicate and @Query, configuring containers for SwiftUI and background actors, and planning migrations when schemas change. CloudKit sync and coexistence with Core Data are in scope when you are leveling up an existing app. The skill emphasizes concurrency with @ModelActor and lists common mistakes plus a review checklist so agents do not hand you fragile persistence code. Use it when you are building offline-first mobile features, replacing UserDefaults with real models, or auditing data code before TestFlight. Complexity is intermediate to advanced because migration and sync mistakes are expensive in production.1.8kinstalls12Swiftui Uikit InteropSwiftui-uikit-interop documents incremental migration from UIKit to SwiftUI for solo iOS builders maintaining a shipping app who cannot afford a big-bang rewrite. It walks through replacing one UIViewController at a time with a UIHostingController, pushing SwiftUI roots on existing navigation stacks, and embedding SwiftUI as child controllers where full-screen swaps are risky. Coverage includes navigation bridging, shared observable state across boundaries, UIHostingConfiguration for collection and table cells on iOS 16+, and environment bridging so SwiftUI reads dependencies UIKit already owns. Each pattern is self-contained with rationale and gotchas, which suits agent-assisted refactors where you paste before/after push examples. Use when you are mid-Build on a brownfield iOS codebase and need a safe, reviewable path toward SwiftUI without freezing feature work.1.8kinstalls13Swift Testingswift-testing is a review-and-guidance skill for solo and small-team iOS builders moving from XCTest to Swift Testing on modern Swift. It is built around eval-style migration scenarios: correcting plans that keep XCTestCase subclasses, misuse availability on suite types, or blindly replace every assertion with #expect. The skill steers you toward free functions or Swift Testing suites, per-test fixture isolation, and explicit guidance on when #require is mandatory versus optional expectations. It also answers coexistence questions during incremental migration and clarifies that UI testing remains on XCTest. Use it when your agent is drafting a migration checklist, reviewing a teammate’s plan, or generating examples for iOS 18 APIs without breaking test isolation or Apple’s testing model.1.8kinstalls14Apple On Device AiApple On-Device AI is an agent skill for solo and indie iOS and macOS builders who need private, low-latency ML without a standing cloud inference bill. It walks through a framework router so you pick Foundation Models for guided text and tool use on supported OS releases, Core ML when you need converted and compressed models on the Neural Engine, MLX Swift for transformer workloads in unified memory, or llama.cpp when GGUF and cross-platform LLM parity matter. Coverage includes structured generation schemas, session lifecycle, model conversion and quantization, and multi-backend layouts so one product can fall back gracefully across hardware. Use it when scoping tool-calling features, designing on-device RAG or summarization, or debugging thermal and memory issues before App Store submission. The skill emphasizes performance practices and pre-ship review rather than generic chat prompts, which keeps agent sessions anchored to Apple’s current APIs and realistic device constraints.1.8kinstalls15Swiftui Liquid GlassSwiftUI Liquid Glass is a reference skill for solo iOS builders adopting Apple’s dynamic translucent material on iOS 26 and aligned platforms. Standard chrome—tab bars, toolbars, navigation bars, sheets—may pick up Liquid Glass automatically with the latest SDK, but custom controls need deliberate use of glassEffect, grouped GlassEffectContainer layouts, ID and union modifiers for morphing, and GlassEffectTransition for state changes. The skill documents scroll edge effects, split-view background extension, and button styles so agents do not sprinkle glassEffect on every view and tank scroll performance or contrast. Availability gating sections help you ship backward-compatible fallbacks. Invoke it during Build when polishing navigation, floating controls, or marketing-style hero layers that should feel native on the 26 design language without reverse-engineering WWDC samples in chat.1.8kinstalls16WidgetkitWidgetKit is an agent skill from swift-ios-skills for solo iOS developers implementing WidgetKit and ActivityKit features with an AI coding assistant. Use it when you are building home screen, Lock Screen, or StandBy widgets; configuring timeline providers and widget families; adding interactive controls; shipping Live Activities with Dynamic Island presentations; or creating Control Center controls with the iOS 18+ APIs—plus Liquid Glass rendering, deep links, push-based reloads, and App Groups setup called out in the skill description. The main SKILL.md walks core protocols and families, while references/widgetkit-advanced.md covers timelines, push updates, and Xcode extension wiring. It targets intermediate builders who already have an Xcode project and need structured review or greenfield implementation rather than marketing or App Store copy. Prism places it on Build frontend for mobile apps; it is phase-specific because distribution and ASO are out of scope here.1.8kinstalls17Swift ChartsSwift Charts is an agent skill for solo iOS builders targeting iOS 26+ who need correct, maintainable data visualizations in SwiftUI. It walks through composing marks in a Chart container, configuring axes and scales, foreground style encoding, selection and scrollable chart behavior, annotations, legends, and vectorized plots when datasets are large. The skill explicitly covers implementation, review, and improvement—not only greenfield charts—plus specialized cases such as heat maps, Gantt charts, stacked and grouped bars, sparklines, and threshold lines. An included review checklist helps catch common mistakes before ship. Use it during Build frontend whenever analytics screens, dashboards, or in-app metrics need native Apple Charts rather than a WebView. Intermediate complexity: you should already model Identifiable data and SwiftUI views. Extended patterns live in references/charts-patterns.md for accessibility and theming.1.8kinstalls18Swiftui Layout Componentsswiftui-layout-components is a reference skill for solo and indie iOS builders who need reliable SwiftUI structure instead of one-off Stack experiments. It walks through layout fundamentals, grid and list patterns, scroll positioning, forms with validation, standard controls, searchable interfaces, and transient overlays—aligned to iOS 26+ and Swift 6.3 while noting compatibility back to iOS 17. Use it when you are building collection-style views, settings screens, search surfaces, or any data-driven layout where lazy loading and sectioned lists matter. The skill emphasizes when to use eager stacks versus lazy stacks inside ScrollView, and it closes with mistake guards and a review checklist so agent-generated UI code matches Apple-idiomatic patterns before you wire navigation and state in companion skills.1.8kinstalls19App IntentsApp Intents is an agent skill for solo and indie iOS builders who need Siri, Shortcuts, and Spotlight to surface the same entities their app already models. It treats App Intents and Core Spotlight as one indexing story: conform types to IndexedEntity, expose metadata with indexing keys, index through CSSearchableIndex (preferably a named production index), and open results with OpenIntent. The bundled eval pushes agents to flag duplicate indexing when legacy CSSearchableItem pipelines still run in parallel, and to correct attribute-set mistakes that silently break discoverability. Use it when you have a draft plan or snippet before you commit Swift changes, especially on newer iOS SDK lines where App Intents guidance moves quickly. It is packaged as procedural review knowledge rather than a code generator, so you still write the Intent definitions and entity types yourself.1.8kinstalls20Debugging InstrumentsDebugging-instruments is a field guide for solo iOS developers who need systematic crash and performance diagnosis without a dedicated QA team. It organizes LLDB commands for fast inspection without executing risky code paths, Memory Graph techniques for retain cycles and orphaned objects, and hang workflows when the main thread stalls. Build failure triage helps when compiler or linker noise hides the real issue, while Instruments sections map CPU, memory, energy, and network templates to typical indie pain points—scroll jank, background wakeups, and accidental N+1 networking. A common-mistakes list and review checklist keep agent-assisted sessions from stopping at the first symptom. Invoke during Ship while hardening a release candidate, and again in Operate when production crashes or metric alerts need the same tooling discipline.1.8kinstalls21Swift Languageswift-language equips solo iOS and Swift package authors with up-to-date language idioms for Swift 6.3-focused code paths that are not SwiftUI views and not concurrency-heavy actors. It spans expression-oriented control flow, typed error surfaces, builders and wrappers, the type system, decoding pipelines, string and collection utilities, formatting APIs, and performance-oriented attributes—while deliberately deferring async Sendable work and UI patterns to sibling skills. Invoke it when your coding agent drifts toward outdated Swift syntax, weak Codable strategies, or confused some/any usage in models, parsers, or domain logic. Because clean models and utilities underpin validation prototypes and ship-phase refactors, the skill is multi-phase in practice even though Prism shelves it under Build frontend for discoverability in mobile workflows.1.7kinstalls22Swiftui Gesturesswiftui-gestures is an advanced reference skill in the swift-ios-skills package that extends the main SKILL.md with production-ready SwiftUI gesture recipes. Solo and indie builders shipping iPhone or iPad apps with Claude Code or Cursor can follow concrete implementations for pinch-to-zoom on photos, simultaneous pan while magnifying, rotate-and-scale combos, reorderable lists, and velocity-aware drags. The doc also covers sequenced gestures such as long-press before drag using gesture state and enums, plus bridging when UIKit recognizers must coexist with SwiftUI. Use it when a feature needs more than a basic tap or drag and you want patterns that avoid common composition mistakes called out in the parent skill. It is reference-oriented—not a codegen workflow—so you paste and adapt snippets into views during active UI work.1.7kinstalls23AuthenticationThis authentication skill packages procedural knowledge for adding passwordless sign-in to Swift iOS apps when product wants passkeys first, optional physical security keys, and inline username-field suggestions. Solo and indie builders shipping consumer or B2B mobile SaaS can use it to avoid guessing at WebAuthn boundaries on Apple platforms: which credential provider to use, how registration differs from assertion, and why AutoFill-assisted requests belong in the UX. It emphasizes server-issued challenges and verifying passkey results on the backend before treating a user as signed in—matching how real relying parties on example.com-style domains operate. The included eval scenario (passkey registration and sign-in) gives agents a concrete bar for coverage. Use it while scaffolding auth modules or reviewing an agent-generated AuthenticationServices implementation, not as a substitute for your identity provider’s policy or threat modeling.1.7kinstalls24Vision FrameworkVision Framework is an agent skill package for solo indie iOS builders who need production-ready computer vision in Swift without stitching together fragmented Apple docs. It walks through the two API generations—modern request types versus legacy VNRequest—and gives copy-paste patterns for OCR, faces, barcodes, segmentation, tracking, and document scanning, with explicit notes on backward compatibility where it matters. When you need a live scanner, it points you to VisionKit’s DataScannerViewController; when you ship custom models, it covers VNCoreMLRequest wiring. The skill is aimed at Claude Code, Cursor, and similar agents helping you implement features during active app build work, especially when camera permissions, performance on device, and API availability gates (iOS 26 vs earlier) are easy to get wrong in chat-only planning.1.7kinstalls25Healthkithealthkit is an agent skill for solo and indie builders shipping native Apple health features. It steers implementation and design reviews toward platform-accurate HealthKit behavior on iPhone and iPad, including mandatory availability checks, capability and privacy string setup, and the distinction between write authorization status and opaque read permissions. The skill emphasizes that read denial does not reliably surface as empty arrays—you may see partial app-saved samples instead—and flags anti-patterns such as creating HKHealthStore before availability checks or deferring background delivery registration until after UI appears. Use it when scaffolding step-count sync, dashboards, or any feature that queries or writes HK samples, and when auditing teammate plans before TestFlight. It pairs well with SwiftUI frontend work and ship-phase security reviews of health data handling, without replacing Apple’s official HealthKit documentation or App Store privacy questionnaires.1.7kinstalls26Background ProcessingBackground Processing is an agent skill for solo and indie iOS builders who need reliable off-foreground work using Apple’s BackgroundTasks framework. It walks through declaring permitted identifiers in Info.plist, registering handlers with BGTaskScheduler, and choosing the right task type—short refreshes with BGAppRefreshTask, longer maintenance with BGProcessingTask, or iOS 26+ continued work started in the foreground. It also documents background URLSession downloads and silent push–style triggers so uploads, sync, and maintenance do not stall when the user leaves the app. Use it when you are wiring sync, cleanup, or deferred downloads and want expiration callbacks, completion reporting, and simulator debugging called out explicitly instead of learning from rejected submissions or flaky background launches.1.7kinstalls27TipkitTipKit is a reference-style agent skill that documents end-to-end TipKit implementation for iOS 17+ using Swift 6.3 conventions. Solo builders use it when they want in-app coaching bubbles—parameter rules, event donations, custom styles, and sequenced TipGroups—without reverse-engineering Apple samples from scratch. The readme spans Complete Tip with Rules and Events, Event-Based Rule with Donation Counting, integration with onboarding flows, and a full app wiring example agents can copy into feature modules. It fits indie apps that need gentle advanced-feature discovery after login or repeated searches, and includes testing and preview guidance so tips do not flake in CI. Intermediate complexity: you need an existing SwiftUI app shell and TipKit-capable deployment target before applying these patterns.1.7kinstalls28Speech RecognitionSpeech-recognition is a Swift iOS agent skill focused on modern Apple speech APIs for live transcription—think meeting recorders with rolling text and word-aligned playback highlights on iOS 26-era stacks. It encodes evaluation-backed expectations: use SpeechAnalyzer with SpeechTranscriber, progressive transcription presets, locale and availability guards, on-device model asset installation, and careful audio format bridging from AVAudioEngine. Solo indie iOS devs install it when Siri-era SFSpeechRecognizer snippets keep failing review or duplicating partial strings. The skill stresses separating volatile partials from final segments and always tearing down the analyzer session to prevent leaks and ghost microphones. It is Build-phase mobile frontend work with optional Speech framework integration depth; it does not cover server-side ASR or Android. Pair with your app’s privacy strings and microphone permission flow outside the skill.1.7kinstalls29CoremlCoreml is a Swift-focused agent skill for integrating Apple Core ML into iOS apps with accurate API usage and availability notes. Indie mobile builders use it when codegen or Stack Overflow snippets mix up async model loading, synchronous prediction calls, batch providers, or stateful audio models. The skill’s evals enforce a clear scope: stay on the Swift client integration surface—load, predict, batch predict, compile at runtime, and concurrency rules for stateful models—rather than expanding into Python-side model conversion or quantization workflows. That boundary matters for solo developers who already have a .mlmodel or Core ML package and need production-safe service code. Invoke it while implementing inference services, reviewing PRs that touch MLModel wrappers, or debugging availability guards across iOS 15–18+. Canonical placement is Build integrations; a secondary Ship testing pass helps validate batch and stateful paths before release.1.7kinstalls30Natural Languagenatural-language is an agent skill for solo iOS developers adding on-device text intelligence with Apple’s NaturalLanguage framework. It targets scenarios such as inbox features that detect language, tokenize words, extract people and organizations, score sentiment, and suggest semantically similar keywords for search. The skill stresses correct API pairing—NLTokenizer units, NLTagger schemes like nameType and sentimentScore with omitWhitespace and joinNames—and defensive coding when languages or embeddings are unavailable. Eval fixtures encode expectations so agents do not force-unwrap missing tags or assume embeddings exist for every locale. Use it when sketching an implementation plan or when reviewing agent-generated Swift for iOS 26-era NaturalLanguage and related translation UX, keeping work on-device where Apple intends.1.7kinstalls31Core BluetoothCore Bluetooth is an agent skill for solo and indie iOS builders who need reliable BLE without subtle delegate, retention, and background pitfalls. It walks through CBCentralManager lifecycle, authorization, filtered scanning, connection and service discovery, characteristic read/write/notify, and payload parsing with explicit byte-count checks. The guidance emphasizes patterns that eval scenarios cover—heart-rate service 180D, measurement 2A37, and safe writes to writable characteristics. Use it when an agent is generating or reviewing Swift BLE manager code, planning background BLE behavior, or hardening a fitness or IoT screen before TestFlight. It complements Apple’s docs with opinionated guardrails so agents do not emit scans that drain battery, drop peripherals from memory, or write without checking MTU and write-without-response capacity.1.7kinstalls32Alarmkitalarmkit is a procedural Swift skill for solo iOS builders who need Apple’s first-class alarm and countdown experience on iOS 26 and iPadOS 26, including Lock Screen prominence, Dynamic Island, and Apple Watch integration. AlarmKit sits on Live Activities: the system renders templated UI while you define behavior through AlarmManager scheduling, AlarmAttributes, AlarmPresentation, and AlarmButton for stop and snooze. The skill walks authorization, choosing alarms versus timers, state observation, and widget-related setup, with deeper patterns deferred to references/alarmkit-patterns.md. It fits productivity, fitness, or ritual apps that must break through Focus and Silent mode without building fragile custom notification hacks. Advanced Swift and Xcode targeting the new SDK baseline are assumed; it is not a cross-platform or Android alarm guide.1.7kinstalls33Core MotionCore Motion is an agent skill for solo iOS builders shipping SwiftUI games or motion-aware apps who need tilt, steps, activity, or altitude without reinventing Apple’s sensor APIs. It encodes how to use one shared CMMotionManager, declare NSMotionUsageDescription before reading motion, verify isDeviceMotionAvailable and attitude reference frames, pick an appropriate update interval for the interaction, and stop the matching updates when views or services tear down. The bundled evals stress privacy plist entries, avoiding per-view managers, and not assuming mutually exclusive activity flags or GPS-only altitude when combining pedometer, activity, and altimeter APIs. Use it when your agent is implementing motion-driven controls or reviewing a hiking/fitness sensor plan—not for generic SwiftUI layout or App Store launch copy.1.7kinstalls34PermissionkitPermissionkit is a Swift iOS agent skill focused on Apple’s PermissionKit APIs for family permissions, handles, questions, responses, and communication limits. Indie mobile developers use it when wiring PermissionButton or AskCenter into an app that targets iOS 26.0 and later, or when reviewing a teammate’s integration before TestFlight. The skill emphasizes version-accurate availability: core topic/handle/question APIs from 26.0, AskError from 26.1, and AskCenter plus PermissionButton from 26.2 unless guarded. It also corrects a common product mistake—treating PermissionKit as arbitrary in-app messaging routing when Apple limits communication experiences to iMessage. Agents applying this skill produce concise implementation guidance, preserve platform constraints, and avoid inventing signing entitlements that do not exist in Apple’s documentation. It is narrow by design: PermissionKit only, not a general parental-controls or SwiftUI architecture course.1.7kinstalls35Device IntegrityDevice Integrity is an agent skill that equips solo iOS builders and tiny backend teams to implement Apple App Attest correctly on the server. It answers what to verify when a client sends keyId, attestationObject, and a one-time challenge, and how to design assertion contracts for endpoints like premium downloads after the key is established. The skill is eval-driven against precise expectations: hash the challenge into clientDataHash, compose the nonce check against authData, validate the Apple extension OID, confirm RP ID hash, aaguid environment, initial counter, credentialId, and keyId alignment, then persist the verified public key and receipt for later assertions and fraud signals. Use it while hardening APIs during build integrations and again before ship when security review asks for a defensible checklist rather than copy-pasted snippets. It does not replace legal compliance review or DeviceCheck-only flows where App Attest is out of scope.1.7kinstalls36Contacts Frameworkcontacts-framework is an agent skill that teaches solo and indie iOS builders how to use Apple’s Contacts and ContactsUI frameworks end to end. It walks through plist usage strings, imports, permission requests before fetch or save, efficient fetching with the right key descriptors, and safe create/update via CNSaveRequest. For product flows that need a person picker, it explains embedding CNContactPickerViewController in SwiftUI without re-requesting access the same way as bulk reads. The skill also covers observing contact store changes and a checklist plus common mistakes so you do not ship privacy or threading bugs. Use it when your agent is implementing address-book features, CRM sync to local contacts, or invite flows on iPhone and iPad.1.6kinstalls37App Clipsapp-clips is a mobile-focused agent skill for solo iOS builders planning or reviewing Apple App Clips before implementation drift costs a release cycle. It concentrates on target setup, entitlement matrix, associated domains, and invocation routing when a lightweight clip must open from QR or NFC and the full app must continue the same URLs after install. The skill expects mixed SwiftUI for the clip and legacy UIKit scene delegates in shared modules—a common indie-team layout. Use it when you need a pre-implementation review of bundle ID prefix rules, on-demand install capability, and browsing-web user activities rather than generic SwiftUI tutorials. It keeps guidance App Clip–specific so agents do not conflate clip cold launch connection options with the continuation APIs that actually deliver universal links.1.6kinstalls38Core Nfccore-nfc is an agent skill for solo and indie iOS builders who need Apple Core NFC configured correctly before handoff to implementation. It focuses on entitlement and Info.plist correctness—TAG (not stale NDEF-only formats), ISO 7816 AID lists, FeliCa system codes without wildcards, usage descriptions, and availability guards—plus concise guidance on scanning ISO 7816, ISO 15693, MIFARE, and FeliCa tags in Swift. Use it when you are adding tap-to-read flows, transit cards, or identity-adjacent tag reads and want a checklist grounded in current platform rules rather than outdated NFC snippets. The skill pairs review prompts with expected outcomes so your agent catches misconfiguration early, reducing App Store rejection risk and on-device session failures.1.6kinstalls39Weatherkitweatherkit is an agent skill from the swift-ios-skills collection that teaches solo and indie builders how to integrate Apple WeatherKit into native iOS apps with modern Swift concurrency and SwiftUI. It documents a reusable WeatherManager built with the Observation framework, parallel fetches for current conditions, hourly and daily forecasts, severe weather alerts, and required attribution, plus follow-on patterns for charting trends, mapping condition enums to UI, caching responses, and tying requests to CoreLocation. Install it when your agent is scaffolding or extending a weather dashboard, travel app, or any mobile feature that must stay on Apple's first-party weather stack instead of a third-party REST API. The extended readme is explicitly an overflow reference when the main SKILL.md cap is exceeded, so agents can pull advanced snippets without hallucinating WeatherService APIs. Expect intermediate Swift fluency, an Apple Developer program setup with WeatherKit enabled, and Xcode targets that already use SwiftUI.1.6kinstalls40EnergykitEnergyKit is an agent skill for solo and indie iOS builders shipping EV-aware charging features with Apple’s EnergyKit framework. It helps you stay inside the real API contract: enable the capability, fetch ElectricityGuidance for an EnergyVenue, build a charging schedule, and emit ElectricVehicleLoadEvents with honest GuidanceState. The skill is aimed at reviewers and implementers who need Swift-level corrections without the agent inventing tokens or collapsing the whole session into one terminal event. Use it when integrating EV load reporting, debugging guidance mismatches, or validating that sampling cadence and lifecycle match Apple’s expectations. It matters because wrong tokens or missing intermediate events can silently break compliance with guidance programs and make production debugging painful on device-only flows.1.6kinstalls41Shareplay Activitiesshareplay-activities is a Swift-focused agent skill for building shared real-time experiences with Apple’s GroupActivities and SharePlay. Solo and indie iOS developers invoke it when they need synchronized media playback, collaborative app state, multiplayer-style game sync, or custom data channels integrated with FaceTime and iMessage. The SKILL.md walks from entitlements and eligibility checks through defining activities, managing session lifecycle, messaging, coordinated playback, in-app SharePlay launch, and optional journal-based file transfer. It also supplies a review checklist and common mistakes to reduce App Store and runtime failures. Use it during active feature implementation—not as a one-line API lookup—when you are committing to multi-device group sessions and need opinionated structure aligned with current Apple platform baselines.1.6kinstalls42Swift CodableSwift-codable is an agent skill that acts like a focused code-review coach for solo iOS builders integrating REST or JSON APIs. It corrects common plan mistakes: treating every model as Codable when responses only need Decodable, decoding bodies before checking status codes, misconfiguring key and date strategies, and reusing decoders across scopes when envelope helpers need their own instance. The skill is grounded in eval scenarios for modern iOS targets and expects concise Swift snippets that demonstrate the right pattern. Use it when an agent drafts an API layer or when you paste a flawed Codable plan for a shipping app. It complements manual testing and contract docs by encoding Apple-idiomatic defaults. It does not replace OpenAPI or backend schema ownership—it sharpens the Swift side of the contract.1.4kinstalls43Swiftui Webkitswiftui-webkit is a procedural agent skill for solo and indie iOS builders who need reliable WebKit inside SwiftUI without re-reading Apple sample code each time. It walks through the lowest-friction `WebView(url:)` embed for marketing or help pages, then graduates to a `@MainActor` `WebPage` model when you must drive loads, surface errors, and bind state into your view hierarchy. Coverage includes async iteration on `page.load` for requests, direct URLs, inline HTML, and typed data payloads, plus hooks for observing progress, titles, and navigation events. Ephemeral pages and custom user agents appear where you need session isolation or bot-friendly headers. Use it during Build when a hybrid screen, authenticated web flow, or rich article renderer is on the sprint board and your coding agent keeps guessing WebKit APIs.1.3kinstalls44CloudkitCloudkit is a Swift iOS agent skill focused on Apple CloudKit sync correctness, especially CKSyncEngine on recent iOS releases. Solo builders shipping iPhone or iPad apps with iCloud-backed data invoke it when a sync design looks plausible but violates platform rules—wrong database scope, missing push background mode, synchronous delegate methods, or naive “sync everything on every edit” expectations. The skill is structured around evaluation prompts and assertion checklists, so the agent behaves like a seasoned iOS engineer reviewing your plan or SwiftData model mapping rather than lecturing on generic backend theory. It emphasizes integration boundaries: delegate async signatures, filtered zone batches aligned to send context, persisted engine state, and when to force sync operations. Use it during Build while integrating CloudKit or SwiftData+CloudKit, before Ship performance and reliability testing, to avoid shipping sync architectures that fail silently in production.1.2kinstalls45ActivitykitActivityKit is an agent skill for solo iOS builders adding Live Activities such as delivery tracking, flights, or session timers. It grounds agents in current ActivityKit APIs: Activity.request and update with ActivityContent, proper end cleanup, and Dynamic Island layouts only where hardware supports them. The skill emphasizes Info.plist keys like NSSupportsLiveActivities, keeping ContentState payloads small, and handling stale presentations when updates lag. Server push requires observing activity.pushTokenUpdates and treating tokens as rotatable credentials you forward securely—not hard-coding one token forever. Eval-backed expectations steer reviewers away from scheduling mistakes and iOS-version-only APIs used without guards. Use during Build when SwiftUI widgets and app extensions must stay consistent with Apple’s Live Activity HIG. Skip if you are Android-only or a web PWA without a native iOS host app.1.2kinstalls46PhotokitDespite the photokit slug in the catalog, the bundled SKILL content documents AV Playback: AVFoundation and AVKit patterns for solo iOS builders shipping media features. It walks through AVPlayer lifecycle, asset loading, transport controls, and KVO-style state/time observation, then covers production concerns like HLS streams, audio session categories, background playback entitlements, lock-screen Now Playing metadata, remote command handling, and PiP. Each section points to Apple documentation anchors (sosumi.ai) so agents cite current APIs while generating SwiftUI-first UI code. Use when your agent keeps hallucinating deprecated player APIs or mishandles audio session interruptions. The skill is a pattern library rather than a runnable CLI—paste sections into feature work for podcasts, courses, or in-app video. Intermediate familiarity with Swift concurrency and entitlements helps.1.2kinstalls47MapkitMapkit is an agent skill for solo iOS builders shipping locator or discovery features in SwiftUI on iOS 18. It steers agents toward modern MapKit surfaces—searchable maps, autocomplete, result markers, selection-driven detail panels, turn-by-turn route overlays, and a user-location control—while calling out privacy strings and cancellation so live search and location tasks do not leak past view teardown. The embedded eval scenario (store locator) makes expectations concrete: completer-driven suggestions, full search requests, map selection types that match bindings, and Settings deep links when authorization is denied. Install it when your agent otherwise defaults to UIKit map views or omits debouncing and permission edge cases. It pairs with Claude Code, Cursor, or Codex on Swift/Xcode repos where MapKit is the integration boundary.1.2kinstalls48Realitykitrealitykit is an agent skill packaged as structured evals for solo iOS developers using SwiftUI and RealityKit. It targets common failure modes: presenting AR on unsupported devices, missing camera usage strings, misreading a black view as asset failure, and skipping ARWorldTrackingConfiguration.isSupported checks. The skill expects correction-focused reviews that explain when arkit belongs in UIRequiredDeviceCapabilities versus runtime-only gating, and how RealityViewCameraContent defaults to an AR camera view with non-AR fallback when AR or camera access is unavailable. Additional eval threads cover surface raycast placement and tap-to-place on physical surfaces. It is advanced, Apple-platform specific, and best invoked while implementing or hardening AR features rather than for greenfield tutorial pacing. Use it as a checklist-backed reviewer before TestFlight or App Store submission when AR is a headline feature.1.2kinstalls49Spritekitspritekit is a build-phase agent skill for concise iOS mini-game notes using SpriteKit inside SwiftUI. It targets retained SpriteView scenes, setup in didMove(to:) with appropriate scaleMode, and a contact pipeline where didBegin flags effects and update applies physics and node changes safely. Camera work goes through SKCameraNode for world motion and HUD attachment, and assets load through texture atlas preloading aligned with current SpriteKit APIs. The readme is eval-driven: expected outputs read like a review checklist rather than a full Xcode archive, which suits solo builders who want their agent to generate vetted snippets and self-audit against SpriteKit footguns. Use it when shipping a native iOS arcade or educational game alongside your SwiftUI shell without pasting outdated delegate patterns.1.2kinstalls50PdfkitPDFKit is a Prism agent skill that teaches solo and indie builders how to display, navigate, search, annotate, and manipulate PDFs on Apple platforms using PDFView, PDFDocument, PDFPage, PDFAnnotation, and PDFSelection. It targets Swift 6.3 and iOS 26+ while noting broader PDFKit availability back to iOS 11. Use it when you are embedding a reader in UIKit, wrapping PDFView for SwiftUI, generating thumbnails, filling forms, or adding signatures and markup without re-reading scattered Apple documentation. The skill walks through loading strategies, zoom and display configuration, outline bookmarks, find-string workflows, annotation creation, and UIViewRepresentable patterns, plus pitfalls and a pre-ship review checklist. It fits the Build phase for mobile products—contracts, reports, manuals, or user-uploaded documents—where PDF handling is a first-class screen rather than a web embed.1.2kinstalls51AvkitAVKit skill packages procedural knowledge for solo iOS developers shipping video playback with Apple’s AVKit stack. It supports two common agent tasks from its evals: auditing a proposed player setup—such as activating the audio session at launch without background modes—and producing corrected Swift plus Info.plist guidance; and implementing custom AVPlayerLayer views with a PiP button, including delegate handling and capability checks. The skill emphasizes accurate platform behavior: enable the right Background Modes for AirPlay and PiP, defer session activation until playback begins when appropriate, and do not assert unsupported claims about entitlements or silent PiP failures. Use it during Build when you are wiring movie playback, casting, or PiP in a SwiftUI or UIKit app and want an agent to sanity-check Apple documentation-aligned patterns.1.2kinstalls52MetrickitMetricKit is an agent skill for solo iOS developers who need production-grade Apple telemetry without a mobile platform team. It grounds agents in registering subscribers early, handling metric and diagnostic payloads symmetrically, saving raw JSON before network or parsing work, and retrieving missed daily batches on startup—patterns that eval fixtures in the skill explicitly test. Use it when code review comments misuse signpost APIs or when MetricKit is treated as instant dev-time feedback instead of aggregated daily reports. The skill fits Ship performance hardening and Operate monitoring shelves because the same subscriber architecture prevents data loss after crashes and supports upload pipelines to your analytics backend.1.2kinstalls53EventkitEventKit is a Swift iOS agent skill focused on calendar integration correctness for solo builders adding bookings, reminders, or Add to Calendar flows. It is structured around realistic review prompts—such as teams that request write-only access then try to fetch existing events for conflict checks—and returns API-accurate guidance on NSCalendarsWriteOnlyAccessUsageDescription versus NSCalendarsFullAccessUsageDescription, deprecated requestAccess patterns on older OS versions, and the limits of write-only creation without read access. It also covers EventKitUI presentation where users edit events in the system sheet, including cases where the app cannot inspect saved results without appropriate access. Use when implementing or reviewing EventKit code on iOS 17+ targets so App Store privacy strings and authorization match the features you actually ship.1.2kinstalls54MusickitMusicKit is an agent skill that walks solo and indie iOS builders through Apple Music integration using MusicKit and MediaPlayer on Swift 6.3 and iOS 26+. It is for developers who want in-app catalog search, subscription-aware flows, queue-based playback with ApplicationMusicPlayer, and correct Now Playing plus remote command handling without re-reading scattered Apple docs. The skill sequences project capability setup, NSAppleMusicUsageDescription, optional background audio, authorization, search, subscription checks, playback, queue edits, and Remote Command Center wiring, then closes with common mistakes and a review checklist. Use it when you are actively building a native iOS product that must respect Apple Music entitlements and MediaPlayer contracts, not when you only need a web landing page or a non-Apple audio source.1.2kinstalls55PencilkitPencilkit is an agent skill for solo iOS builders shipping sketching, annotation, or signature flows on iPad with Apple Pencil. It walks through the non-obvious integration details that break real apps: UIViewRepresentable around PKCanvasView, keeping PKToolPicker alive outside local scopes, adding the canvas as an observer before showing the picker, and choosing a drawingPolicy that matches whether fingers should draw. Eval expectations in the skill package stress serialization with dataRepresentation(), reload via PKDrawing(data:), and preventing binding feedback loops when SwiftUI re-renders. Use it during Build when your agent would otherwise emit a minimal canvas demo that loses tools on rotation or floods state updates. Intermediate complexity assumes SwiftUI fluency; it does not replace Human Interface Guidelines review or CloudKit conflict design, though eval prompts mention compatibility and CloudKit bytes as review scenarios. Optimized for Cursor, Claude Code, and Codex agents generating production-shaped Swift rather than one-file prototypes.1.2kinstalls56CryptokitThis CryptoKit skill gives solo iOS builders structured answers for real-world cryptography on Apple platforms—from recipient public-key encryption with HPKE to post-quantum options on newer OS releases. It is written for developers who know Swift but should not invent custom ECDH, HKDF, and AEAD compositions when Apple provides vetted APIs. The embedded eval scenarios stress transmitting encapsulated keys, using var stateful HPKE types, authenticating associated data, and understanding when quantum-secure ML-KEM and ML-DSA fit document-sharing or long-lived trust models. You reach for it while implementing secure messaging, file encryption, or signature verification in a native app, especially when compliance or threat models push you beyond symmetric-only shortcuts. The material stays framework-centric (CryptoKit, Secure Enclave constraints) so agents can produce checklists and code outlines that match Apple’s availability matrix instead of generic OpenSSL advice.1.2kinstalls57HomekitHomeKit is an agent skill from a Swift iOS skills pack that teaches correct HomeKit automation patterns for solo app builders shipping smart-home features. It is grounded in eval scenarios such as creating a Good Night action set fired at 22:30 with a daily repeating timer trigger, attaching scenes, and enabling the trigger only after homes are available. The skill stresses Apple platform prerequisites—HomeKit capability, usage description strings, and not touching homes before homeManagerDidUpdateHomes—and clarifies when to use core HomeKit types (HMHomeManager, HMHome, HMActionSet, HMTimerTrigger) versus mistakenly delegating timer automations to Matter-only flows. Use it while implementing integrations in a SwiftUI or UIKit app, debugging recurrence bugs, or onboarding accessories into your ecosystem. Complexity is intermediate: you need Xcode, a physical or simulated home setup, and comfort with async home updates. Outputs are implementation-ready Swift guidance and checklists aligned to skill eval expectations, not a turnkey Matter commissioning wizard.1.2kinstalls58Appmigrationkitappmigrationkit teaches agents the correct setup for Apple’s AppMigrationKit when a solo builder ships an iOS or iPadOS app that must import documents during onboarding—commonly from an Android counterpart. The skill stresses that migration is extension-driven and system-orchestrated, lists the data-container entitlement as a single-element bundle-ID array, and maps export/import roles to the AppMigrationExtension child protocols. Builders avoid the common failure mode of trying to run migration networking inside the main app or misconfiguring OS version gates between API and entitlement availability. Use it during implementation of the migration target and containing app launch checks, paired with Apple’s platform docs for edge cases. It is narrow, integration-focused procedural knowledge for Swift mobile shipping rather than a general app architecture skill.1.2kinstalls59Carplaycarplay is an agent skill aimed at solo iOS developers shipping navigation-class apps who must pass Apple’s CarPlay bar without mixing UIKit chrome into the wrong window. It structures entitlement requests, Info.plist scene manifests, navigation CPTemplateApplicationSceneDelegate connection handling, and CPMapTemplate as the root driving surface. The skill emphasizes a hard boundary: CPWindow renders map content only, while alerts, overlays, and chrome flow through CarPlay templates—exactly where App Review and driver-safety rules bite unprepared teams. Eval-backed expectations cover iOS 26-era APIs, simulator configurations beyond a single screen size, and on-road realities (locked iPhone, Siri, audio interruptions). Use it when Build integrations need CarPlay parity before Ship review prep; it also informs Validate prototypes that demo in-car flows and Launch distribution stories for navigation products.1.2kinstalls60GamekitGameKit is a Swift iOS agent skill for integrating Apple Game Center into games targeting modern iOS with Swift 6.3-era patterns. Solo game devs use it when they need players signed in via GKLocalPlayer, scores on leaderboards, achievement unlocks, friend invites, and either real-time or turn-based multiplayer without reading scattered Apple docs alone. The skill walks authentication first—because every feature depends on it—then access point and dashboard UX, competitive features, multiplayer flows, and a review checklist to catch App Store review issues. It sits squarely in build integrations: you are connecting your binary to Apple’s social and multiplayer services while the gameplay code is still taking shape.1.2kinstalls61PasskitPasskit is an agent skill for indie iOS developers adding Apple Pay to a SwiftUI store when the catalog is physical goods, subscriptions to boxes, or other non-digital inventory. It walks through Apple Developer capability setup, Merchant ID and payment processing certificate requirements, and runtime checks so you only present Pay when networks and capabilities allow. The skill emphasizes constructing PKPaymentRequest with shipping methods and summary items using NSDecimalNumber, placing the merchant-named total as the final line item, and retaining PKPaymentAuthorizationController with a proper delegate while the sheet is visible. Authorization should forward payment.token or paymentData to your payment processor—not treat PassKit as a standalone backend. It also flags App Review lines: use Apple Pay outside StoreKit for physical sales, and keep StoreKit for digital goods and in-app purchases. Solo builders invoke it when evals-style prompts demand a source-grounded checkout plan rather than copy-pasted snippets that leak controllers or misuse Double for currency.1.2kinstalls62CallkitCallKit is an agent skill for solo and indie builders shipping iOS VoIP clients who need a source-grounded PushKit plus CallKit incoming-call path aligned with iOS 26.x behavior. It walks through when VoIP pushes can be ignored versus when CallKit (or LiveCommunicationKit) reporting is mandatory, how to prefer the iOS 26.4 metadata delegate while keeping older delegate paths for earlier point releases, and the server-side APNs knobs that affect delivery. Use it while implementing or reviewing native Swift call flows so you do not miss mustReport semantics, completion ordering, or compliance notes that can silently stop VoIP push delivery after repeated report failures.1.2kinstalls63AdattributionkitAdAttributionKit is an agent skill for solo and indie iOS builders shipping ad-supported or publisher apps who must implement Apple’s privacy-preserving attribution APIs correctly. It focuses on custom-rendered install ads: turning server-signed compact JWS payloads into AppImpression objects, placing UIEventAttributionView over each clickable surface, and calling handleTap only after validated taps within Apple’s time limits. The skill also explains when to request fresh impressions after expiry, how StoreKit-managed product views and overlays differ from fully custom UI, and what to check when migrating from SKAdNetwork. Use it while building or refactoring monetization paths so attribution survives App Review expectations and you avoid silent attribution loss from overlapping views or expired impressions.1.2kinstalls64AccessorysetupkitAccessorySetupKit is a mobile agent skill for indie iOS builders adding Bluetooth Low Energy accessory onboarding on iOS 18 and later. It walks through Info.plist entries, ASDiscoveryDescriptor configuration, presenting the system picker, and continuing setup after the user selects a device—without asking for wide Bluetooth permission up front. The expected pattern activates ASAccessorySession, declares supported Bluetooth services and name prefixes that match your descriptor, handles delegate ordering when accessories are added and the picker dismisses, then connects using the returned bluetooth identifier with CoreBluetooth. It suits environmental sensors, branded BLE peripherals, and other hardware that advertises a known service UUID and name prefix. The skill is evaluation-backed for EnviroTag-style scenarios and stays narrow: it is not a general BLE mesh or background scanning guide, but a focused integration recipe for Apple’s sanctioned setup UX.1.2kinstalls65PaperkitPaperKit is an agent skill for indie iOS developers shipping annotation or document-markup features on Apple’s latest SDKs. It walks through importing PaperKit, hosting PaperMarkupViewController, persisting and editing PaperMarkup, configuring FeatureSet and insertion controllers, and bridging PencilKit drawing with structured markup elements—the same stack Notes and Screenshots use. The skill stresses platform availability (iOS 26+), Swift 6.3, and API volatility, and includes common mistakes and a review checklist so you do not ship half-wired editors. Reach for it when a spec calls for a system-standard markup toolbar rather than a fully custom canvas. Skip it if you target older OS versions or need only raw PencilKit without PaperKit’s structured model.1.2kinstalls66FinancekitFinanceKit is a source-grounded agent skill for solo iOS builders adding read-only financial account and transaction data to budgeting or personal-finance apps. It walks through organization-level managed entitlement requests, App Store Finance category constraints, and U.S. versus U.K. data availability so you do not ship builds that fail review or call APIs in unsupported regions. The skill emphasizes checking FinanceStore.isDataAvailable before authorization, plist usage strings, and async authorization outcomes. For querying, it specifies constructing a TransactionQuery with predicates and paging parameters and warns that transaction amounts must not be treated as signed values without proper model handling. Intermediate Swift developers shipping iPhone apps in eligible markets use it during integration spikes rather than as a generic Swift tutorial. It pairs with Xcode, Apple Developer account access, and FinanceKit framework targets on supported iOS versions.1.2kinstalls67ScenekitSceneKit is an agent skill that keeps solo iOS builders from shipping the wrong 3D loading assumptions in an existing app. Its evals steer agents away from treating hero.usdz or arbitrary OBJ exports as the default SceneKit ingestion path, and toward .scnassets packaging plus catalog-backed textures. When artists already ship OBJ or leadership wants USDZ everywhere, the skill explains where SceneKit still applies versus when you should plan a RealityKit handoff instead of incremental SceneKit patches. A second thread covers shader modifiers: how to attach geometry-stage GLSL snippets and pass time or custom values without breaking the built-in scn_frame contract. Use it while drafting asset pipelines or reviewing agent-generated SceneKit code before you merge. It does not replace artist tooling or a full migration project plan, but it reduces format and deprecation surprises early.1.2kinstalls68AudioaccessorykitAudioaccessorykit is a Swift iOS agent skill for solo builders extending a headphones app from AccessorySetupKit pairing to AudioAccessoryKit automatic switching. It encodes Apple’s split architecture: register the paired ASAccessory with AccessoryControlDevice.Configuration in the container app after setup completes, then run current(for:) and update(_:) from the app extension when firmware reports on-head or off-head placement. The skill’s eval rubric stresses Configuration-based registration, capability flags for audio switching and placement, and explicit handling of AccessoryControlDevice errors—common pitfalls when agents hallucinate deprecated Capabilities-only APIs. Install it when you are building a native iOS accessory experience rather than a cross-platform web MVP. It assumes you already have pairing working and need the minimal correct flow for wear-state-driven routing. Complexity is advanced because entitlements, extensions, and firmware events must align. Use alongside Apple platform docs and your own device lab; it is procedural guidance, not a hosted MCP bridge.1.2kinstalls69CryptotokenkitCryptoTokenKit is an advanced agent skill for solo iOS and Mac developers shipping hardware-backed authentication—smart cards for login and keychain unlock—not consumer Sign in with Apple or passkeys. It encodes evaluation-backed corrections so agents do not propose iOS token drivers for macOS system login, mis-nest Info.plist keys, or blur OAuth guidance into CTK work. Use when reviewing an extension plan, scaffolding a smart-card app extension, or debugging registration with the security agent. Expect tight focus on Apple’s extension point identifiers and per-session authentication boundaries. Best invoked in Claude Code or Cursor on Swift projects that already target CryptoTokenKit and Security frameworks.1.2kinstalls70RelevancekitRelevancekit is a focused agent skill for indie iOS and watchOS builders implementing watchOS 26 Smart Stack widgets that surface upcoming meetings only when each slot is contextually relevant. Instead of stretching a classic timeline provider across unrelated cards, the skill steers you toward RelevanceConfiguration, a RelevanceEntriesProvider, RelevanceEntry modeling, and WidgetRelevance attributes ordered by priority, with RelevantContext.date driving time-aware behavior. It also encodes the easy-to-miss platform guardrails: explicit watchOS 26 availability, preview branches when context.isPreview is true, and associated-kind linkage when your relevant widget shares DNA with an existing timeline widget. For a solo builder shipping a calendar-adjacent complication or stack card, this skill reduces API mismatch rework and helps agents produce assertion-friendly implementation plans evaluators can check against RelevanceKit expectations. Invoke it when you already know the product story—one card per meeting—and need structured Swift snippets rather than generic WidgetKit boilerplate.1.2kinstalls71DockkitThe dockkit skill structures how a solo iOS developer pairs a custom camera app with Apple’s DockKit hardware stand. It centers on DockAccessoryManager for accessory attach/detach, async state streams on iOS 17.4+, and the interaction between automatic system tracking and manual operator control. Builders get clarity on tap-to-track via normalized selectSubject coordinates, framing modes (.automatic vs .center), and region-of-interest behavior tied to the video frame. Hardware button and accessory events belong in the same control graph as tracking enable/disable, with manual angular velocity only after system tracking is off—matching Apple’s sequencing expectations. Privacy guidance is explicit: no DockKit-only plist key, but full camera usage strings and capture consent still apply. Use this skill when your MVP differentiator is a motorized stand experience, not a generic AVFoundation tutorial.1.2kinstalls72Browserenginekitbrowserenginekit is an advanced Swift iOS agent skill focused on Apple’s BrowserEngineKit distribution model for third-party browser engines. Solo developers shipping an alternative browser on iPhone use it when Xcode targets, entitlements, and process bootstrap are easy to get wrong—missing extension-specific entitlements, wrong UIRequiredDeviceCapabilities, or starting a content process before networking and rendering are connected. The skill’s eval framing expects concise setup reviews that name the four entitlement roles, arm64e and web-browser-engine capability requirements, and the host-as-broker XPC sequence. It steers implementations away from WKWebView shortcuts that do not satisfy alternative-engine rules. This is checker-oriented procedural knowledge for a narrow Apple platform surface, not a generic web view tutorial.1.2kinstalls73SensorkitSensorkit is an agent skill for solo and indie iOS builders shipping health or research apps that need Apple SensorKit—not generic motion APIs. It walks through entitlement values, Info.plist usage-detail dictionaries, authorization, and the mandatory delay before fetched sensor data is available. The procedural knowledge targets common failure modes such as casting accelerometer or rotation-rate samples to the wrong Core Motion types, or mis-typing wrist temperature, ECG, and PPG payloads. Use it when drafting compliance-ready setup checklists or reviewing fetch pipelines before TestFlight or study submission. It assumes you already have study approval context; it does not replace IRB or legal review. Intermediate-to-advanced Swift and capability-background knowledge helps. Outputs read like implementation checklists and corrected handler designs your coding agent can apply directly in Xcode.1.2kinstalls74TabletopkitTabletopKit Extended Patterns is an overflow reference skill for solo and indie iOS builders who use agent-assisted coding to ship board, card, and dice experiences on Apple’s TabletopKit stack. It documents how to implement TabletopGame observers so confirmed actions become the primary hook for game-specific state, how to reject illegal moves during validation on the multiplayer arbiter, and how to structure custom actions that plug into TableSnapshot-aware flows. The guide walks through dice physics, card and tile layouts, interaction delegates, score tracking, bookmarks, and undo—plus end-to-end game architecture and network coordination patterns that keep host and clients consistent. Use it while you are actively building or refactoring a tabletop title, not when you are still picking a game concept or doing market research. It pairs with Swift iOS skills in the same repo and assumes you already chose TabletopKit rather than a custom engine. Complexity is advanced because multiplayer validation, equipment moves, and framework callbacks must align with Apple’s tabletop model.1.1kinstalls75Ios Securityios-security is an agent skill for solo and indie builders shipping native iOS apps who need Apple-aligned patterns instead of ad-hoc storage and networking. It walks through Keychain Services as the only correct home for passwords and API keys, Data Protection classes, CryptoKit encryption, Secure Enclave key storage, and biometric authentication with LAContext. Network hardening covers App Transport Security defaults, certificate pinning, and secure coding habits that survive App Review. Privacy Manifests and a review checklist help you catch entitlement and declaration gaps before submission. Use it when implementing auth flows, encrypting sensitive payloads, configuring ATS exceptions deliberately, or auditing an existing codebase prior to launch. It complements mobile feature skills by focusing on what must not leak or weaken in production.1.1kinstalls76Ios Simulatorios-simulator is an agent skill for solo iOS builders who need a command-line Simulator test script instead of clicking through Xcode for every maps, location, or install smoke pass. It centers on `xcrun simctl`: pick or create a device, boot it, install an app bundle built for the simulator architecture, drive location with `simctl location start` for custom waypoint routes, and reset location plus shutdown or delete devices when finished. The skill’s eval contract stresses common pitfalls—install only `.app` targets, boot before launch, avoid hardcoded UDIDs, and do not treat `location run` as a GPX file loader. That makes it intermediate complexity: you already ship Swift/UIKit or SwiftUI apps and want agent-generated scripts that survive CI-like repetition. Use it when you are validating navigation, feature flags passed through `simctl spawn`, or push notification plumbing with `simctl push`, not when you only need unit tests on macOS without a simulator. Outcome is a reproducible simctl playbook your agent can extend for route-based features and disciplined teardown.724installs77Swift Securityswift-security is an agent skill that guides security review of Swift/iOS code with emphasis on Keychain, credentials, and common shipping mistakes. Packaged evals illustrate real failures: refresh tokens in UserDefaults, unchecked SecItemAdd results, missing accessibility attributes, and brittle delete-before-add updates. Solo builders use it when an agent must audit token helpers, session storage, or secret persistence before TestFlight or App Store submission. It fits the Ship phase security subphase for native mobile products—not generic cloud IAM or web-only OWASP checklists. Agents applying it should name findings with severity, map fixes to Apple Keychain best practices, and reference the skill’s security reference material. Outcomes are actionable review notes and corrected storage patterns that reduce credential exposure on device.717installs78Swift Architectureswift-architecture is a decision-and-implementation skill for solo and indie Apple developers who must choose how to structure SwiftUI or UIKit code before complexity becomes irreversible. It walks through Model-View with @Observable, MVVM, MVI, The Composable Architecture, Clean layers, VIPER, and Coordinator approaches with explicit tradeoffs on complexity and testability, then documents migration paths and recurring anti-patterns. Use it when greenfielding a feature, debating whether TCA is worth the boilerplate, or planning an incremental move off massive views. The guidance assumes Swift 6.3 concurrency and observation APIs, so agents produce patterns aligned with current Apple platform norms rather than legacy ObservableObject-only samples. It does not replace Xcode project setup or App Store launch checklists—it produces an architecture choice, structural boundaries, and review criteria you can hand to implementation skills or human reviewers.714installs79App Store Optimizationapp-store-optimization is an agent skill for solo iOS builders preparing an App Store launch or relaunch. It walks through how Apple-weighted metadata drives search versus how creative assets drive taps and installs, so you prioritize relevance over vanity keywords. The workflow expects practical plans: subtitle and keyword field strategy, a compelling description opening, screenshot sequencing, promotional text refreshes, Custom Product Pages aligned to ads or segments, in-app events for seasonal discovery, and structured PPO experiments. It deliberately stays out of deep App Review compliance checklists and StoreKit coding, keeping focus on storefront strategy. Use it when you have a habit tracker, utility, or SaaS companion app ready to list and need an agent to produce an actionable ASO document you can hand to design and marketing tasks.698installs80Core DataCore Data is an agent skill package that teaches solo and indie iOS builders how to design, migrate, and operate Apple’s SQLite-backed persistence stack on an iOS 26 baseline. It walks through model definition with inverses and fetch indexes, fetch optimization, relationship rules, threading contracts, save and rollback patterns, and the full migration ladder from lightweight mapping through custom mapping models to staged migrations with lightweight and custom stages. Operators get executable guidance for NSPersistentContainer and NSPersistentCloudKitContainer setup, CloudKit record-zone constraints, multi-target sync with persistent history and merge policies, batch operations that must refresh the view context, encryption options, and a structured error-handling triage. Review-oriented sections help agents audit plans for checksum mistakes, missing staged migration manager options on store descriptions, and widget or extension contexts that never merge SQL-level changes—so you catch data-loss and crash classes before they reach TestFlight.679installs81Focus EngineFocus Engine is an agent skill for solo and indie builders shipping native Apple apps with SwiftUI and UIKit on iOS 26+, iPadOS, macOS, tvOS, watchOS, and visionOS. It gives procedural guidance for @FocusState, defaultFocus, scene-focused values, focus sections, focus restoration, and custom routing with UIFocusGuide, plus platform-specific models such as tvOS Siri Remote navigation and visionOS RealityKit InputTargetComponent. Use it when agents otherwise guess at focus order, break restoration after sheets, or mix up UIKit guides with SwiftUI focus APIs. The skill separates general focus behavior from accessibility-specific VoiceOver flows, and includes a review checklist and references so implementations stay consistent across scenes and hardware. Intermediate complexity: you should already have a SwiftUI or UIKit screen tree before applying these patterns.676installs82Swift Formatstyleswift-formatstyle teaches agents and developers to display values with Apple’s FormatStyle protocol and Foundation’s concrete styles on iOS 15+, including duration formatters on iOS 16+. Solo indie app builders use it when wiring currency in checkout, relative “updated 5 min ago” labels, byte counts in settings, or parsing user-typed input back into typed values via ParseableFormatStyle. The skill emphasizes locale-aware output even for English-first apps—separators, calendars, and RTL-sensitive layout—while keeping String Catalog and full localization workflows out of scope. It pairs well with agent-assisted SwiftUI views where ad hoc string interpolation would break i18n and testability.676installs83Swiftlintswiftlint is an agent skill for solo and indie iOS developers who need SwiftLint to actually stick—not just `brew install` and hope. It walks through choosing an installation path (SPM SwiftLintPlugins as default, Homebrew for CI, Mint, CocoaPods legacy, or pinned binaries), how configuration files are discovered, and how to structure parent/child YAML for monorepos or modules. You get practical guidance on severity tuning, env interpolation, remote configs, and a rollout plan that avoids freezing a large legacy app under thousands of new violations. Use it while hardening Ship workflows: wire the plugin in Xcode, align pre-commit or CI with the same rules, and document team conventions. It pairs naturally with mobile Build work but lives on the Ship/review shelf because its outcome is enforceable quality standards before you tag a release or merge to main.617installs