zhongwei/gh-sjungling-claude-plugins-plugins-swift-engineer
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Initial commit

Browse Source
This commit is contained in:
Zhongwei Li
2025-11-30 08:57:43 +08:00
commit 9208f30000
10 changed files with 727 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

274
skills/ios-swift-expert/SKILL.md Normal file
View File

@@ -0,0 +1,274 @@
---
name: ios-swift-expert
description: Elite iOS and macOS development expertise for Swift, SwiftUI, UIKit, Xcode, and the entire Apple development ecosystem. Automatically activates when working with .swift files, Xcode projects (.xcodeproj, .xcworkspace), SwiftUI interfaces, iOS frameworks (UIKit, Core Data, Combine, etc.), app architecture, or Apple platform development.
---
# iOS and macOS Development Expert
## Overview
Elite-level guidance for iOS and macOS development with deep expertise in Swift, SwiftUI, UIKit, and the entire Apple development ecosystem.
**Core principle:** Follow Apple's Human Interface Guidelines, Swift API Design Guidelines, and modern iOS development best practices while writing clean, performant, memory-safe code.
## When to Use
Automatically activates when:
- Working with `.swift` source files
- Opening or modifying Xcode projects (`.xcodeproj`, `.xcworkspace`)
- Editing SwiftUI views or UIKit view controllers
- Implementing iOS/macOS frameworks (Core Data, Combine, UIKit, SwiftUI, etc.)
- Debugging Xcode build errors or runtime issues
- Designing app architectures (MVVM, MVI, Clean Architecture)
- Optimizing performance or fixing memory leaks
- Implementing accessibility, localization, or privacy features
- Configuring app targets, build settings, or project structure
Manual invocation when:
- User explicitly asks about Swift language features
- User needs guidance on Apple platform APIs
- User requests iOS/macOS development best practices
- User encounters Apple platform-specific problems
## When NOT to Use This Skill
Do not use this skill for:
- General programming questions unrelated to Apple platforms
- Backend server development (unless using Vapor/Swift on server)
- Cross-platform mobile development (React Native, Flutter, Kotlin Multiplatform)
- Web development (unless WebKit/Safari specific or Swift for WebAssembly)
- Android development
- Desktop development on non-Apple platforms
## Core Expertise Areas
### Swift Language Mastery
- **Modern Swift Features**: Value types, protocol-oriented programming, generics, result builders, property wrappers, async/await, actors
- **Memory Management**: ARC, weak/unowned references, retain cycles, memory graph debugging
- **Concurrency**: Structured concurrency with async/await, actors, task groups, continuation, legacy GCD patterns
- **Error Handling**: Proper use of throws, Result type, error propagation, custom error types
- **Type Safety**: Leveraging Swift's type system for safer code, phantom types, type erasure
### SwiftUI Development
- **Declarative UI**: Views, modifiers, composition, custom view builders
- **State Management**: @State, @Binding, @ObservedObject, @StateObject, @EnvironmentObject, @Observable (iOS 17+)
- **Layout System**: VStack, HStack, ZStack, GeometryReader, Layout protocol (iOS 16+), safe areas
- **Animations**: Implicit animations, explicit animations, transitions, matched geometry effect
- **Navigation**: NavigationStack (iOS 16+), NavigationPath, programmatic navigation, deep linking
- **Advanced Patterns**: ViewModifiers, PreferenceKeys, custom environments, coordinators
### UIKit (Legacy & Hybrid Apps)
- **View Controllers**: Lifecycle, containment, custom transitions, adaptive layouts
- **Auto Layout**: Constraints, stack views, size classes, intrinsic content size
- **Table/Collection Views**: Data sources, delegates, diffable data sources, compositional layout
- **Gestures**: Tap, swipe, pan, long press, custom gesture recognizers
- **Core Animation**: Layer animations, keyframe animations, CADisplayLink
- **Integration**: Bridging UIKit and SwiftUI with UIViewRepresentable/UIViewControllerRepresentable
### iOS Frameworks & APIs
- **Core Data**: Managed object context, fetch requests, predicates, migrations, relationships
- **Combine**: Publishers, subscribers, operators, cancellables, error handling, backpressure
- **Core Location**: Location services, geofencing, heading, privacy best practices
- **CloudKit**: Public/private databases, records, subscriptions, sharing
- **StoreKit**: In-app purchases, subscriptions, transaction handling, receipt validation
- **HealthKit, HomeKit, ARKit, RealityKit**: Domain-specific framework expertise
### Xcode & Build System
- **Project Structure**: Targets, schemes, configurations, build phases, script phases
- **Build Settings**: Optimization levels, code signing, provisioning profiles, entitlements
- **Debugging Tools**: LLDB, breakpoints, view debugging, Instruments, memory graph debugger
- **Testing**: XCTest, UI testing, performance testing, test plans, code coverage
- **Swift Package Manager**: Package manifests, dependencies, versioning, local packages
### App Architecture
- **MVVM**: Model-View-ViewModel with SwiftUI or UIKit
- **MVI**: Model-View-Intent unidirectional data flow
- **Clean Architecture**: Layered separation, dependency injection, testability
- **Coordinator Pattern**: Navigation flow management
- **Repository Pattern**: Data layer abstraction
- **Design Patterns**: Factory, observer, strategy, dependency injection containers
## Development Workflow
### 1. Build Verification
**Always verify builds** after making changes using `xcodebuild`:
```bash
xcodebuild -project YourProject.xcodeproj -scheme YourScheme -quiet build
```
- Use `-quiet` flag to minimize output as specified in project documentation
- Replace placeholders with actual project and scheme names
- For workspaces, use `-workspace YourWorkspace.xcworkspace`
- Check exit code to confirm success
### 2. Code Standards
Follow these standards for all Swift code:
**Naming Conventions:**
- Types: UpperCamelCase (e.g., `UserProfileViewController`)
- Functions/variables: lowerCamelCase (e.g., `fetchUserData()`)
- Constants: lowerCamelCase (e.g., `let maxRetryCount = 3`)
- Protocols: UpperCamelCase, often ending in -able, -ible, or -ing (e.g., `Codable`, `Drawable`)
**Access Control:**
- Default to `private` or `fileprivate` for implementation details
- Use `internal` (default) for module-internal APIs
- Mark `public` or `open` only for exported APIs
- Consider `@testable import` for testing instead of making everything public
**Code Organization:**
- Group related code with `// MARK: - Section Name`
- Order: properties, initializers, lifecycle methods, public methods, private methods
- One type per file (exceptions for small helper types)
- Use extensions for protocol conformance
**Memory Safety:**
- Use `[weak self]` in closures that may outlive the caller
- Use `[unowned self]` only when certain closure won't outlive the reference
- Break retain cycles between parent/child view controllers
- Monitor retain cycles in Instruments
### 3. Testing Requirements
Write testable code with appropriate coverage:
**Unit Tests:**
- Test business logic, view models, data transformations
- Mock network/database dependencies
- Use dependency injection for testability
- Aim for >80% coverage on critical paths
**UI Tests:**
- Test critical user flows (login, purchase, main features)
- Use accessibility identifiers for reliable element selection
- Keep UI tests fast and focused
### 4. Performance Considerations
Optimize for user experience:
**Rendering Performance:**
- Keep view hierarchies shallow
- Avoid expensive operations in `body` (SwiftUI) or `layoutSubviews` (UIKit)
- Profile with Instruments (Time Profiler, SwiftUI view body)
- Lazy-load content, virtualize lists
**Memory Management:**
- Release large objects when no longer needed
- Monitor memory warnings and respond appropriately
- Profile with Instruments (Allocations, Leaks)
- Avoid strong reference cycles
**Battery Life:**
- Minimize location services usage
- Batch network requests
- Use background modes judiciously
- Profile with Instruments (Energy Log)
### 5. Apple Platform Best Practices
Follow Apple's official guidelines for:
- Human Interface Guidelines (navigation, controls, interactions, accessibility)
- Privacy & Security (permissions, data handling, authentication)
- Accessibility (VoiceOver, Dynamic Type, color contrast)
- Localization (NSLocalizedString, RTL languages, formatting)
See `./references/apple-guidelines.md` for detailed requirements and best practices.
## Problem-Solving Approach
### 1. Analysis Phase
- Read error messages carefully (Xcode, runtime logs, crash reports)
- Check project-specific requirements in CLAUDE.md
- Review existing code patterns and architecture
- Consider iOS version compatibility and API availability
### 2. Solution Design
- Provide multiple approaches when appropriate, explaining trade-offs
- Reference official Apple documentation and WWDC sessions
- Consider performance, memory, and battery impact
- Suggest appropriate design patterns for the problem
### 3. Implementation
- Write clean, readable Swift code following API Design Guidelines
- Include inline comments for complex logic
- Add proper error handling with meaningful error messages
- Ensure code is testable with dependency injection where appropriate
### 4. Validation
- Verify code builds successfully with `xcodebuild`
- Test on simulator and, when possible, physical devices
- Check for retain cycles and memory leaks
- Validate accessibility and localization
## Communication Style
**Clear and Actionable:**
- Provide specific code examples, not just descriptions
- Explain the "why" behind architectural and implementation decisions
- Offer step-by-step instructions for complex implementations
- Highlight potential pitfalls and how to avoid them
**Authoritative Sources:**
- Link to Apple's official documentation
- Cite WWDC sessions for best practices
- Reference Swift Evolution proposals for language features
- Point to Human Interface Guidelines for design decisions
- See `./references/apple-guidelines.md` for documentation links
**Trade-offs:**
- Performance vs. code simplicity
- SwiftUI vs. UIKit for specific use cases
- Async/await vs. completion handlers
- Protocol-oriented vs. class-based design
**Complete implementation examples:** See `./references/code-examples.md` for SwiftUI views, MVVM view models, Core Data setup, and memory management patterns.
**Design patterns and solutions:** See `./references/patterns.md` for dependency injection, result builders, coordinator pattern, and other common solutions.
**Debugging guidance:** See `./references/debugging-strategies.md` for comprehensive debugging techniques for Xcode build issues, runtime problems, and SwiftUI-specific debugging.
## Success Criteria
Guidance is successful when:
- Code builds successfully using `xcodebuild` with `-quiet` flag
- Solutions follow Apple's Human Interface Guidelines
- Implementations are memory-safe and performant
- Code adheres to Swift API Design Guidelines
- Solutions are testable and maintainable
- Proper error handling is implemented
- Accessibility and localization are considered
- User privacy and security best practices are followed
- Target iOS/macOS versions are compatible
## Additional Resources
For complete reference materials, see:
- `./references/code-examples.md` - SwiftUI, MVVM, Core Data, and memory management examples
- `./references/patterns.md` - Dependency injection, result builders, coordinator pattern
- `./references/debugging-strategies.md` - Xcode, runtime, and SwiftUI debugging techniques
- `./references/apple-guidelines.md` - Official Apple documentation and guidelines
## Remember
- Always verify builds with `xcodebuild -quiet`
- Follow project-specific standards from CLAUDE.md
- Write memory-safe code with proper ARC usage
- Consider accessibility, localization, and privacy
- Reference Apple documentation and WWDC best practices
- Explain trade-offs in architectural decisions
- Provide clear, actionable code examples

55
skills/ios-swift-expert/references/apple-guidelines.md Normal file
View File

@@ -0,0 +1,55 @@
# Apple Guidelines & Resources
Authoritative sources for iOS and macOS development best practices.
## Official Documentation
- **Apple Developer Documentation**: https://developer.apple.com/documentation/
- **Swift Language Guide**: https://docs.swift.org/swift-book/
- **Human Interface Guidelines**: https://developer.apple.com/design/human-interface-guidelines/
- **Swift API Design Guidelines**: https://www.swift.org/documentation/api-design-guidelines/
- **WWDC Videos**: https://developer.apple.com/videos/
## Human Interface Guidelines
Follow platform conventions for:
- Navigation patterns and controls
- Interactions and gestures
- Dynamic Type for accessibility
- Privacy preferences handling
- Multitasking and background modes
## Swift API Design Guidelines
Key principles:
- Clarity at the point of use
- Naming that makes code read like prose
- Prefer methods and properties over free functions
- Omit needless words
- Compensate for weak type information
## Privacy & Security
Best practices:
- Request permissions with clear purpose strings
- Handle user data securely (Keychain for credentials)
- Use App Transport Security (HTTPS by default)
- Implement Face ID/Touch ID for sensitive operations
- Follow privacy manifests requirements (iOS 17+)
## Accessibility
Requirements:
- Add accessibility labels and hints
- Support VoiceOver navigation
- Test with Accessibility Inspector
- Support Dynamic Type and larger text sizes
- Ensure sufficient color contrast
## Localization
Guidelines:
- Use `NSLocalizedString` for user-facing text
- Support right-to-left languages
- Externalize date/number formatting
- Test with pseudo-localization

153
skills/ios-swift-expert/references/code-examples.md Normal file
View File

@@ -0,0 +1,153 @@
# iOS Development Code Examples
Complete implementation examples for common iOS and macOS development patterns.
## SwiftUI View with Proper State Management
```swift
import SwiftUI
struct UserProfileView: View {
@StateObject private var viewModel = UserProfileViewModel()
@Environment(\.dismiss) private var dismiss
var body: some View {
NavigationStack {
ScrollView {
VStack(alignment: .leading, spacing: 16) {
// Profile content
AsyncImage(url: viewModel.avatarURL) { image in
image
.resizable()
.scaledToFill()
} placeholder: {
ProgressView()
}
.frame(width: 100, height: 100)
.clipShape(Circle())
Text(viewModel.userName)
.font(.title)
.accessibilityAddTraits(.isHeader)
}
.padding()
}
.navigationTitle("Profile")
.toolbar {
ToolbarItem(placement: .navigationBarTrailing) {
Button("Done") {
dismiss()
}
}
}
.task {
await viewModel.loadProfile()
}
}
}
}
```
## MVVM ViewModel with Async/Await
```swift
import Foundation
import Combine
@MainActor
final class UserProfileViewModel: ObservableObject {
@Published private(set) var userName: String = ""
@Published private(set) var avatarURL: URL?
@Published private(set) var isLoading = false
@Published private(set) var error: Error?
private let userService: UserServiceProtocol
init(userService: UserServiceProtocol = UserService()) {
self.userService = userService
}
func loadProfile() async {
isLoading = true
error = nil
do {
let profile = try await userService.fetchCurrentUser()
userName = profile.name
avatarURL = profile.avatarURL
} catch {
self.error = error
}
isLoading = false
}
}
// Protocol for dependency injection and testing
protocol UserServiceProtocol {
func fetchCurrentUser() async throws -> UserProfile
}
```
## Core Data Stack with Modern Concurrency
```swift
import CoreData
final class PersistenceController {
static let shared = PersistenceController()
let container: NSPersistentContainer
private init() {
container = NSPersistentContainer(name: "AppModel")
container.loadPersistentStores { description, error in
if let error = error {
fatalError("Unable to load persistent stores: \(error)")
}
}
container.viewContext.automaticallyMergesChangesFromParent = true
}
func save() async throws {
let context = container.viewContext
guard context.hasChanges else { return }
try await context.perform {
try context.save()
}
}
func backgroundContext() -> NSManagedObjectContext {
let context = container.newBackgroundContext()
context.mergePolicy = NSMergeByPropertyObjectTrumpMergePolicy
return context
}
}
```
## Proper Memory Management with Closures
```swift
import UIKit
final class DataManager {
private var completionHandlers: [String: (Result<Data, Error>) -> Void] = [:]
func fetchData(forKey key: String, completion: @escaping (Result<Data, Error>) -> Void) {
completionHandlers[key] = completion
URLSession.shared.dataTask(with: URL(string: "https://example.com")!) { [weak self] data, response, error in
guard let self = self else { return }
if let error = error {
self.completionHandlers[key]?(.failure(error))
} else if let data = data {
self.completionHandlers[key]?(.success(data))
}
self.completionHandlers[key] = nil
}.resume()
}
}
```

26
skills/ios-swift-expert/references/debugging-strategies.md Normal file
View File

@@ -0,0 +1,26 @@
# Debugging Strategies
Comprehensive debugging techniques for iOS and macOS development.
## Xcode Build Issues
1. **Clean Build Folder**: Product → Clean Build Folder (Cmd+Shift+K)
2. **Delete Derived Data**: `rm -rf ~/Library/Developer/Xcode/DerivedData`
3. **Check Build Settings**: Verify code signing, Swift version, deployment target
4. **Read Error Carefully**: Xcode errors often include fix-its
5. **Check Dependencies**: Swift Package Manager, CocoaPods, or Carthage issues
## Runtime Issues
1. **Breakpoints**: Set symbolic breakpoints for exceptions
2. **LLDB Commands**: `po`, `expr`, `frame variable` for inspection
3. **View Debugging**: Use Xcode's visual debugger (Debug → View Debugging)
4. **Memory Graph**: Detect retain cycles with Debug → Memory Graph
5. **Instruments**: Profile with Time Profiler, Allocations, Leaks
## SwiftUI Debugging
1. **Preview Crashes**: Check `PreviewProvider` initialization
2. **State Updates**: Verify state changes on main thread
3. **View Redrawing**: Use `Self._printChanges()` to debug updates
4. **Modifiers Order**: Order matters (frame before padding vs. padding before frame)

78
skills/ios-swift-expert/references/patterns.md Normal file
View File

@@ -0,0 +1,78 @@
# Common Patterns & Solutions
Design patterns and solutions for iOS and macOS development.
## Pattern: Dependency Injection
**Problem:** Tight coupling makes testing difficult
**Solution:** Use protocol-based dependency injection
```swift
protocol NetworkServiceProtocol {
func fetch<T: Decodable>(_ endpoint: Endpoint) async throws -> T
}
struct ContentView: View {
@StateObject private var viewModel: ContentViewModel
init(networkService: NetworkServiceProtocol = NetworkService()) {
_viewModel = StateObject(wrappedValue: ContentViewModel(networkService: networkService))
}
var body: some View {
// View implementation
}
}
```
## Pattern: Result Builders
**Problem:** Complex view hierarchies
**Solution:** Use result builders for DSL-like syntax
```swift
@resultBuilder
struct ViewArrayBuilder {
static func buildBlock(_ components: [AnyView]...) -> [AnyView] {
components.flatMap { $0 }
}
static func buildExpression<V: View>(_ expression: V) -> [AnyView] {
[AnyView(expression)]
}
}
func createViews(@ViewArrayBuilder _ builder: () -> [AnyView]) -> [AnyView] {
builder()
}
```
## Pattern: Coordinator for Navigation
**Problem:** Complex navigation logic scattered across views
**Solution:** Centralize navigation in coordinator
```swift
@MainActor
final class AppCoordinator: ObservableObject {
@Published var path = NavigationPath()
enum Route: Hashable {
case detail(id: String)
case settings
case profile
}
func navigate(to route: Route) {
path.append(route)
}
func pop() {
path.removeLast()
}
func popToRoot() {
path = NavigationPath()
}
}
```