Skill UI

Neumorphism, or Soft UI, is a contemporary design trend where interface elements appear extruded from the background material itself. This guide details the core principles—unified colors and dual shadows (light highlight and dark shadow)—and provides comprehensive implementation examples for web (CSS), iOS (SwiftUI), and cross-platform (Flutter) development. Use this style when a subtle, soft, and integrated aesthetic is desired.

A comprehensive guide for developers on creating and writing native modules and views using the Expo Modules API. It covers platform-specific implementation details for Swift (iOS), Kotlin (Android), and TypeScript. Use this when integrating system APIs, wrapping platform SDKs, or building complex native functionality that goes beyond standard React Native components.

Use @expo/ui to build high-fidelity, native user interfaces across iOS and Android from a single React codebase. This library renders real native UI components, such as SwiftUI on iOS and Jetpack Compose on Android. It promotes a universal component layer for cross-platform consistency, while also providing controlled access to platform-specific optimizations and drop-in replacements for existing community libraries.

This skill systematically scans Apple's comprehensive developer documentation, specifically targeting SwiftUI. It identifies deprecated APIs, finds their modern replacements, and updates the expert skill's reference guide. Use this when required to refresh deprecated features, check for new API deprecations after an iOS/Xcode update, or maintain the most current best practices for SwiftUI development.

This pattern demonstrates how to build a robust, thread-safe data persistence layer in Swift using the 'actor' model. It combines fast in-memory caching with reliable file-backed storage, automatically eliminating data races and the need for manual locks. Ideal for offline-first applications and managing shared mutable state in modern Swift concurrency.

A guide to the Swift 6.2 concurrency model, which mandates default single-threaded execution to eliminate accidental data races. Learn how to use MainActor for isolated consistency and utilize the @concurrent attribute for explicitly offloading CPU-intensive tasks to background threads, ensuring safe and predictable application architecture.

This comprehensive guide demonstrates how to achieve highly testable Swift code using protocol-based dependency injection. By abstracting external concerns—such as file systems, networking, and external APIs—into small, focused protocols, developers can write deterministic unit tests that mock side effects and error paths, ensuring robust architecture across different environments (App, Test, Preview).

A comprehensive guide covering modern best practices for building high-performance, declarative user interfaces in SwiftUI. Topics include using the advanced @Observable framework for state management, achieving type-safe navigation with NavigationStack, effective view composition, and optimizing rendering performance for iOS and macOS platforms.