SwiftyJourney

Write, review, or improve SwiftUI code following best practices for state management, view composition, performance, accessibility, and modern APIs. Use when building SwiftUI features, refactoring views, reviewing code quality, or adopting modern SwiftUI patterns.

Use this skill to turn vague, ambiguous, or "lousy" requirements into precise, testable specifications BEFORE any code is written -- even when the user never says "BDD", "use case", or "acceptance criteria". Trigger when someone has a half-baked feature idea, an under-specified ticket, or a business brief that's "open to interpretation" and needs it pinned down: clarifying questions, As-a/I-want/So-that narratives, Given/When/Then acceptance criteria, use cases (data inputs, happy path, error and cancel courses), model-spec tables, request/response payload contracts, flowcharts, and module-dependency diagrams. This is the SPECIFICATION altitude -- WHAT to build and the contracts to honor. Hand off the implementation to the iOS architecture skill (composition root, layers, packages, concurrency), SwiftUI view code, and Swift Testing syntax -- do NOT use this skill to write or refactor that code, only to define what it must satisfy.

Use when the user is designing, structuring, refactoring, or reviewing the architecture of an iOS/Swift app: separating features into modules/layers (domain, API, cache, presentation, UI), wiring dependencies in a composition root, breaking up massive view controllers, making code testable via protocol boundaries and test doubles, adapter/proxy/pagination patterns, or handling Sendable/@MainActor at module boundaries. Trigger even when 'architecture' isn't mentioned -- e.g. 'where should networking code live', 'my view controller is untestable', 'how do I split this into Swift packages', 'MVVM vs MVP'. Do NOT use for pure SwiftUI view/state/styling work (swiftui-expert), writing BDD specs or user stories (requirements-engineering), Swift Testing syntax (swift-testing-expert), or non-iOS architecture (Android, backend services).

Transforms code into clean, testable, and maintainable architecture using SOLID principles, Clean Architecture, and proven design patterns. Use this skill when you need to: design a new feature with proper separation of concerns, refactor legacy or monolithic code, review architecture for SOLID violations, establish dependency-injection boundaries, plan a testing strategy, or document architectural decisions. Language-agnostic; includes concrete Swift/iOS examples from the Essential Developer methodology.

Use this skill to bridge SwiftUI and UIKit in either direction. Embed SwiftUI in a UIKit app -- present or child-embed a UIHostingController, put SwiftUI in UICollectionView/UITableView cells via UIHostingConfiguration, or build a widget / Live Activity. Wrap UIKit for use in SwiftUI -- UIViewRepresentable / UIViewControllerRepresentable with a Coordinator for delegates and data sources. Pass data and state across the boundary (init params, @Binding, closures, environment/trait forwarding), fix hosting-controller sizing, and migrate a UIKit AppDelegate/SceneDelegate app incrementally to the SwiftUI App lifecycle. Trigger even when the user doesn't say "interop" -- e.g. "show this SwiftUI screen from my view controller", "use my UIKit map view in SwiftUI", "put SwiftUI in a collection view cell". Do NOT use for pure SwiftUI view code (swiftui-expert), app architecture / composition root (ios-architecture-expert), or general Swift language questions (swift-language-expert).

Use this skill for non-obvious Swift LANGUAGE and standard-library techniques -- features that make code clearer, safer, or faster but that developers routinely miss. Covers pattern matching (if/guard-case, switch over tuples); functions, closures, and key paths (variadics, autoclosures, rethrows); value semantics and custom types (copy-on-write, ~Copyable, callAsFunction, recursive enums, property wrappers); protocols and generics (associated types, opaque some vs existential any, phantom types); collections (lazy, RangeSet, InlineArray, sorting); strings and Unicode (grapheme-correct iteration, custom interpolation); concurrency and errors (async/await, task groups, AsyncStream, typed throws); and debugging and code organization (assertions, dump, enum namespaces, directives). Trigger for "how do I do X in Swift" and idiomatic refactors. Do NOT use for SwiftUI (swiftui-expert), app architecture or actor isolation in a layered app (ios-architecture-expert), or Swift Testing syntax (swift-testing-expert).