SwiftUI Pro

When writing SwiftUI code, follow these modern API preferences to ensure compatibility with current standards and avoid deprecated patterns:

• Styling: Use foregroundStyle() instead of foregroundColor().
• Clipping: Use clipShape(.rect(cornerRadius:)) instead of cornerRadius().
• Tabs: Use the Tab API instead of tabItem().
• Haptics: Use sensoryFeedback() instead of UIKit APIs like UIImpactFeedbackGenerator.
• Overlays: Prefer the trailing closure version overlay(alignment:content:) over the deprecated overlay(_:alignment:). Example: .overlay { Text("Hello") }.
• Toolbar Placement: Use .topBarLeading and .topBarTrailing instead of the deprecated .navigationBarLeading and .navigationBarTrailing.
• Scroll Indicators: Use .scrollIndicators(.hidden) instead of showsIndicators: false in the initializer.
• Shapes: In iOS 17+, you can chain .fill() and .stroke() directly on a shape without using an overlay.
• Images: Prefer the generated symbol asset API Image(.assetName) over string-based Image("assetName") when configured.
• WebView: For iOS 26+, use the native WebView view type instead of wrapping WKWebView in UIViewRepresentable (requires import WebKit).

The swiftui-pro skill is designed to comprehensively review Swift and SwiftUI code for correctness, modern API usage, and adherence to project conventions. It is optimized for reviewing, writing, or improving SwiftUI projects with a focus on iOS 26+ and Swift 6.2+.

Core Review Principles

• Target Environment: iOS 26 is the default deployment target; use Swift 6.2 or later with modern Swift concurrency.
• Framework Preference: Prioritize SwiftUI; avoid UIKit unless explicitly requested.
• Architecture: Break different types into separate Swift files rather than grouping multiple structs, classes, or enums in one file. Use a feature-based folder layout.
• Dependencies: Do not introduce third-party frameworks without prior permission.

Review Process

The skill follows a structured review sequence covering:

1. Deprecated APIs
2. View, modifier, and animation optimization
3. Data flow configuration
4. Navigation performance (NavigationStack/NavigationSplitView)
5. Design and Human Interface Guidelines compliance
6. Accessibility (Dynamic Type, VoiceOver, Reduce Motion)
7. Performance optimization
8. Swift code validation (Concurrency, etc.)
9. Code hygiene

Note: For partial reviews, you can instruct the agent to load only specific relevant reference files (e.g., references/data.md).

When writing Swift code for SwiftUI projects, adhere to these modern language and API preferences:

String and Foundation APIs

• Use Swift-native string methods: replacing("a", with: "b") instead of replacingOccurrences(of: "a", with: "b").
• Use modern Foundation APIs: URL.documentsDirectory instead of FileManager lookups, and appending(path:) for URL path manipulation.
• Use localizedStandardContains() for filtering text based on user input.
• Use Date.now instead of Date().
• Use modern Date initializers for string conversion, e.g., Date(myString, strategy: .iso8601).
• Use PersonNameComponents for formatting names instead of string interpolation.

SwiftUI and UI Patterns

• Prefer static member lookup over struct instances: .circle instead of Circle(), and .borderedProminent instead of BorderedProminentButtonStyle().
• Use FormatStyle APIs for numbers instead of C-style formatting: Text(value, format: .number.precision(.fractionLength(2))) instead of String(format: "%.2f", value).
• Avoid manual date formatting strings for user display; if necessary, use "y" instead of "yyyy" for years to ensure correct localization.
• Note that import SwiftUI automatically provides access to UIImage or NSImage on their respective platforms; you do not need to explicitly import UIKit or import AppKit.

Logic and Safety

• Avoid force unwraps (!) and force try. Use if let, guard let, nil-coalescing, try?, or do-catch. If a failure is unrecoverable, use fatalError() with a clear description.
• Use the if let value { shorthand instead of if let value = value {.
• Omit return for single-expression functions.
• Use if and switch as expressions when assigning values to variables.
• Use count(where:) instead of filter().count when counting objects matching a predicate.
• Prefer Double over CGFloat (except when using optionals or inout).
• Make types conform to Comparable if they are repeatedly sorted using the same closure.
• Do not swallow user-triggered errors silently (e.g., using print(error.localizedDescription)); show an alert instead.

// Example: Using if/switch as expressions and omitting return
var tileColor: Color {
    if isCorrect {
        .green
    } else {
        .red
    }
}