From aigroup-workflow
Builds iOS/macOS/watchOS/tvOS apps with SwiftUI, async/await concurrency, actors, and protocol-oriented design. Invoke for SwiftUI state management, UIKit integration, Combine, or Vapor.
How this skill is triggered — by the user, by Claude, or both
Slash command
/aigroup-workflow:swift-expertThe summary Claude sees in its skill listing — used to decide when to auto-load this skill
1. **Architecture Analysis** - Identify platform targets, dependencies, design patterns
Validation checkpoints: After step 3, run
swift buildto verify compilation. After step 4, runswift build -warnings-as-errorsto surface actor isolation and Sendable warnings. After step 5, runswift testand confirm all async tests pass.
Load detailed guidance based on context:
| Topic | Reference | Load When |
|---|---|---|
| SwiftUI | references/swiftui-patterns.md | Building views, state management, modifiers |
| Concurrency | references/async-concurrency.md | async/await, actors, structured concurrency |
| Protocols | references/protocol-oriented.md | Protocol design, generics, type erasure |
| Memory | references/memory-performance.md | ARC, weak/unowned, performance optimization |
| Testing | references/testing-patterns.md | XCTest, async tests, mocking strategies |
// ✅ DO: async/await with structured error handling
func fetchUser(id: String) async throws -> User {
let url = URL(string: "https://api.example.com/users/\(id)")!
let (data, _) = try await URLSession.shared.data(from: url)
return try JSONDecoder().decode(User.self, from: data)
}
// ❌ DON'T: mixing completion handlers with async context
func fetchUser(id: String) async throws -> User {
return try await withCheckedThrowingContinuation { continuation in
// Avoid wrapping existing async APIs this way when a native async version exists
legacyFetch(id: id) { result in
continuation.resume(with: result)
}
}
}
// ✅ DO: use @Observable (Swift 5.9+) for view models
@Observable
final class CounterViewModel {
var count = 0
func increment() { count += 1 }
}
struct CounterView: View {
@State private var vm = CounterViewModel()
var body: some View {
VStack {
Text("\(vm.count)")
Button("Increment", action: vm.increment)
}
}
}
// ❌ DON'T: reach for ObservableObject/Published when @Observable suffices
class LegacyViewModel: ObservableObject {
@Published var count = 0 // Unnecessary boilerplate in Swift 5.9+
}
// ✅ DO: define capability protocols with associated types
protocol Repository<Entity> {
associatedtype Entity: Identifiable
func fetch(id: Entity.ID) async throws -> Entity
func save(_ entity: Entity) async throws
}
struct UserRepository: Repository {
typealias Entity = User
func fetch(id: UUID) async throws -> User { /* … */ }
func save(_ user: User) async throws { /* … */ }
}
// ❌ DON'T: use classes as base types when a protocol fits
class BaseRepository { // Avoid class inheritance for shared behavior
func fetch(id: UUID) async throws -> Any { fatalError("Override required") }
}
// ✅ DO: isolate mutable shared state in an actor
actor ImageCache {
private var cache: [URL: UIImage] = [:]
func image(for url: URL) -> UIImage? { cache[url] }
func store(_ image: UIImage, for url: URL) { cache[url] = image }
}
// ❌ DON'T: use a class with manual locking
class UnsafeImageCache {
private var cache: [URL: UIImage] = [:]
private let lock = NSLock() // Error-prone; prefer actor isolation
func image(for url: URL) -> UIImage? {
lock.lock(); defer { lock.unlock() }
return cache[url]
}
}
async/await for asynchronous operations (see pattern above)Sendable compliance for concurrencystruct/enum) by default/// …)!) without justificationWhen implementing Swift features, provide:
npx claudepluginhub codeape-7/ai-agent-workflowgroupBuilds iOS/macOS/watchOS/tvOS apps with SwiftUI, async/await concurrency, actors, and protocol-oriented design. Covers Combine, UIKit integration, and Vapor backend.
Provides expert guidance for iOS/macOS development with Swift, SwiftUI, UIKit, Core Data, Combine, Xcode projects, app architectures, build errors, and performance optimization.
Guides native iOS development with Swift and SwiftUI best practices, UIKit interop, Core Data/SwiftData persistence, Combine, structured concurrency, App Clips, WidgetKit, Xcode config, and SPM. Use for building or optimizing iOS apps.