AI Agent Skills

https://github.com/swiftzilla/skills
Admin
A collection of custom AI agent skills providing specialized capabilities and expertise for Swift...
Tokens:74,385
Snippets:922
Trust Score:3.1
Update:4 weeks ago
Show doc for...
Tokens:
Raw
### Install LLDB plugin

Source: https://github.com/swiftzilla/skills/blob/main/skills/swift_debug/SKILL.md

One-time setup to install the LLDB plugin. Adds the loader script to ~/.lldbinit.

```bash
scripts/swift_debug install
```

--------------------------------

### Multi-Target Package Example

Source: https://github.com/swiftzilla/skills/blob/main/skills/swift_package_manager/references/package_structure.md

Complete multi-target package example with products, dependencies, and targets.

```swift
let package = Package(
    name: "NetworkingKit",
    platforms: [.iOS(.v15), .macOS(.v12)],
    products: [
        .library(name: "Networking", targets: ["Networking"]),
        .library(name: "Auth", targets: ["Auth"]),
        .library(name: "NetworkingAll", targets: ["Networking", "Auth"]),
    ],
    dependencies: [
        .package(url: "https://github.com/Alamofire/Alamofire.git", from: "5.8.0"),
    ],
    targets: [
        .target(
            name: "Networking",
            dependencies: [
                .product(name: "Alamofire", package: "Alamofire"),
            ]
        ),
        .target(
            name: "Auth",
            dependencies: ["Networking"]
        ),
        .testTarget(
            name: "NetworkingTests",
            dependencies: ["Networking"]
        ),
    ]
)
```

--------------------------------

### Suite-Level Setup with static setUp/tearDown

Source: https://github.com/swiftzilla/skills/blob/main/skills/swift_testing/references/test_basics.md

Uses static setUp and tearDown methods to manage a shared resource once for the entire suite. The resource is created before all tests and cleaned up after.

```swift
@Suite
struct SharedResourceTests {
    static var sharedResource: Resource!
    
    static func setUp() {
        // Runs once before all tests
        sharedResource = Resource()
    }
    
    static func tearDown() {
        // Runs once after all tests
        sharedResource.cleanup()
    }
    
    @Test
    func test1() {
        // Use Self.sharedResource
    }
}
```

--------------------------------

### Install SwiftZilla skill using skills.sh (npx)

Source: https://github.com/swiftzilla/skills/blob/main/README.md

Use this command to install the swiftzilla skill via the Vercel skills CLI. Adjust the owner/repo path to match the GitHub URL where this repository is hosted.

```bash
npx skills add SwiftZilla-org/skills/skills/swiftzilla
```

--------------------------------

### Package.resolved Example

Source: https://github.com/swiftzilla/skills/blob/main/skills/swift_package_manager/references/dependencies.md

Example of a Package.resolved file, which records the exact resolved versions and revisions of dependencies.

```json
{
  "pins": [
    {
      "identity": "alamofire",
      "kind": "remoteSourceControl",
      "location": "https://github.com/Alamofire/Alamofire.git",
      "state": {
        "revision": "b2fa556e4e48cbf36b471c...",
        "version": "5.8.1"
      }
    }
  ],
  "version": 1
}
```

--------------------------------

### README.md template for a Swift package

Source: https://github.com/swiftzilla/skills/blob/main/skills/swift_package_manager/references/publishing.md

Template for a package README.md. Includes installation instructions with a Swift Package Manager dependency, usage example, platform requirements, and license.

```markdown
# MyPackage

Short description of what the package does.

## Installation

Add to Package.swift:
```swift
dependencies: [
    .package(url: "https://github.com/username/MyPackage.git", from: "1.0.0")
]
```

## Usage

```swift
import MyPackage

// Example code
```

## Requirements

- iOS 15.0+
- macOS 12.0+
- Swift 5.9+

## License

MIT

```

--------------------------------

### Zip Example

Source: https://github.com/swiftzilla/skills/blob/main/skills/swift_combine/references/operators.md

Combines two publishers into a tuple, waiting for both to emit before emitting. The sink prints the paired values.

```swift
let publisher1 = [1, 2, 3].publisher
let publisher2 = ["A", "B", "C"].publisher

publisher1
    .zip(publisher2)
    .sink { print($0) }  // (1, "A"), (2, "B"), (3, "C")
```

--------------------------------

### DocC comment example for a Swift class

Source: https://github.com/swiftzilla/skills/blob/main/skills/swift_package_manager/references/publishing.md

Example of a DocC comment for a public class, including a code example in the documentation.

```swift
/// A network manager for API requests
///
/// Use `NetworkManager` to make HTTP requests:
///
/// ```swift
/// let manager = NetworkManager()
/// let data = try await manager.fetch(url)
/// ```
public class NetworkManager {
    // ...
}

```

--------------------------------

### Setup and Teardown with @Suite init/deinit

Source: https://github.com/swiftzilla/skills/blob/main/skills/swift_testing/references/test_basics.md

Uses a suite with init and deinit to set up and tear down per-test resources. The database is created before each test and closed after.

```swift
@Suite
struct DatabaseTests {
    var database: Database!
    
    init() {
        // Runs before each test
        database = Database.inMemory()
    }
    
    deinit {
        // Runs after each test
        database.close()
    }
    
    @Test
    func insert() {
        database.insert(item)
        #expect(database.count == 1)
    }
}
```

--------------------------------

### Retry Example

Source: https://github.com/swiftzilla/skills/blob/main/skills/swift_combine/references/operators.md

Retries the publisher a specified number of times upon failure. The sink is omitted for brevity.

```swift
publisher
    .retry(3)
```

--------------------------------

### Catch Example

Source: https://github.com/swiftzilla/skills/blob/main/skills/swift_combine/references/operators.md

Catches errors from a publisher and replaces them with a fallback publisher. The error is printed and a default value is emitted.

```swift
publisher
    .catch { error -> Just<String> in
        print("Error: \(error)")
        return Just("default")
    }
```

--------------------------------

### Switch with Tuples

Source: https://github.com/swiftzilla/skills/blob/main/skills/swift_structure/references/control_flow.md

Demonstrates pattern matching on tuples in a switch statement. The example prints 'Near origin' for the point (1,1).

```swift
let point = (1, 1)

switch point {
case (0, 0):
    print("Origin")
case (_, 0):
    print("On x-axis")
case (0, _):
    print("On y-axis")
case (-2...2, -2...2):
    print("Near origin")  // This prints
default:
    print("Far away")
}
```

--------------------------------

### Append Example

Source: https://github.com/swiftzilla/skills/blob/main/skills/swift_combine/references/operators.md

Appends values to the end of a publisher's output. The sink prints the resulting sequence.

```swift
[1, 2].publisher
    .append(3)
    .append([4, 5])
    .sink { print($0) }  // 1, 2, 3, 4, 5
```

--------------------------------

### Timeout Example

Source: https://github.com/swiftzilla/skills/blob/main/skills/swift_combine/references/operators.md

Fails the publisher if no value is emitted within the specified time interval. The sink is omitted for brevity.

```swift
publisher
    .timeout(.seconds(5), scheduler: DispatchQueue.main)
```

--------------------------------

### Swift Protocol Definition and Conformance

Source: https://github.com/swiftzilla/skills/blob/main/skills/swift_style/references/protocols.md

This example illustrates the fundamental syntax for defining a protocol with properties, methods, and initializer requirements, followed by a concrete type conforming to the protocol. Use it as a foundation for any protocol-based Swift design.

```swift
// Protocol definition
protocol MyProtocol {
    var property: String { get set }
    func method() -> Int
    init(parameter: String)
}
```

```swift
// Conformance
struct MyType: MyProtocol {
    var property: String
    func method() -> Int { return 0 }
    init(parameter: String) { self.property = parameter }
}
```

--------------------------------

### Delay Example

Source: https://github.com/swiftzilla/skills/blob/main/skills/swift_combine/references/operators.md

Delays the emission of values by a specified time interval. The sink is omitted for brevity.

```swift
publisher
    .delay(for: .seconds(2), scheduler: DispatchQueue.main)
```

--------------------------------

### Basic Protocol with Conforming Struct

Source: https://github.com/swiftzilla/skills/blob/main/skills/swift_style/references/protocols.md

Defines a protocol with a method and a property requirement, then conforms a struct to it. Use this as a starting point for any protocol that requires both behavior and state.

```swift
protocol Drawable {
    func draw()
    var color: String { get set }
}

struct Circle: Drawable {
    var color: String
    var radius: Double
    
    func draw() {
        print("Drawing \(color) circle with radius \(radius)")
    }
}
```

--------------------------------

### Switch with Value Binding

Source: https://github.com/swiftzilla/skills/blob/main/skills/swift_structure/references/control_flow.md

Shows how to bind values in switch cases. The example prints 'Error 404' for the given status tuple.

```swift
let status = (code: 404, message: "Not Found")

switch status {
case (200, let message):
    print("Success: \(message)")
case (let code, _):
    print("Error \(code)")  // This prints
}
```

--------------------------------

### Merge Example

Source: https://github.com/swiftzilla/skills/blob/main/skills/swift_combine/references/operators.md

Merges two publishers of the same type, interleaving their emissions. The sink prints each value as it arrives.

```swift
let publisher1 = [1, 2, 3].publisher
let publisher2 = [4, 5, 6].publisher

publisher1
    .merge(with: publisher2)
    .sink { print($0) }  // 1, 4, 2, 5, 3, 6
```

--------------------------------

### Throttle Example

Source: https://github.com/swiftzilla/skills/blob/main/skills/swift_combine/references/operators.md

Throttles a publisher, emitting at most once per specified interval. The `latest: true` parameter ensures the most recent value is emitted.

```swift
buttonTapPublisher
    .throttle(for: .seconds(1), scheduler: RunLoop.main, latest: true)
    .sink { _ in
        self.handleTap()
    }
```

--------------------------------

### Running async code with Task

Source: https://github.com/swiftzilla/skills/blob/main/skills/swift_concurrency/SKILL.md

Shows three ways to run async code: a fire-and-forget Task, a Task with a priority, and a cancellable Task. The cancellation example creates a Task and then calls cancel() on it.

```swift
// Fire-and-forget
Task {
    let result = await asyncOperation()
}

// With priority
Task(priority: .background) {
    await heavyComputation()
}

// With cancellation
let task = Task {
    try await longRunningOperation()
}
task.cancel()
```

--------------------------------

### CombineLatest Example

Source: https://github.com/swiftzilla/skills/blob/main/skills/swift_combine/references/operators.md

Combines two publishers and emits the latest values from both. The sink prints the combined tuple whenever either publisher emits a new value.

```swift
let publisher1 = CurrentValueSubject<Int, Never>(1)
let publisher2 = CurrentValueSubject<String, Never>("A")

publisher1
    .combineLatest(publisher2)
    .sink { int, string in
        print("\(int) \(string)")
    }

publisher1.send(2)  // 2 A
publisher2.send("B")  // 2 B
```

--------------------------------

### Autoconnect a connectable publisher

Source: https://github.com/swiftzilla/skills/blob/main/skills/swift_combine/references/publishers_subscribers.md

Automatically connects the publisher when subscribed, starting the stream immediately.

```swift
let connectable = publisher
    .makeConnectable()
    .autoconnect()
```

--------------------------------

### ObserveOn (via receive) - Map and Receive on Main

Source: https://github.com/swiftzilla/skills/blob/main/skills/swift_combine/references/operators.md

This example shows using .receive(on:) after a .map operation to observe on the main thread. It demonstrates the pattern of performing expensive work on a background queue and then updating UI on the main thread.

```swift
publisher
    .map { expensiveOperation($0) }
    .receive(on: DispatchQueue.main)
    .assign(to: \.text, on: label)
```

--------------------------------

### Basic Closure Example

Source: https://github.com/swiftzilla/skills/blob/main/skills/swift_structure/references/closures.md

Defines a closure that takes a name and returns a greeting string. The closure is assigned to a constant and called like a function.

```swift
let greeting = { (name: String) -> String in
    return "Hello, \(name)!"
}

print(greeting("Ada"))  // "Hello, Ada!"
```

--------------------------------

### Count - Count Elements

Source: https://github.com/swiftzilla/skills/blob/main/skills/swift_combine/references/operators.md

Use .count() to emit the number of elements received from the publisher. The example prints the total count.

```swift
publisher
    .count()
    .sink { print("Total: \($0)") }
```

--------------------------------

### For-In Loop

Source: https://github.com/swiftzilla/skills/blob/main/skills/swift_structure/references/control_flow.md

Shows how to iterate over an array using a for-in loop, including using enumerated() to get index and value.

```swift
let names = ["Anna", "Alex", "Brian", "Jack"]

for name in names {
    print("Hello, \(name)!")
}

// With index
for (index, name) in names.enumerated() {
    print("\(index + 1): \(name)")
}
```

--------------------------------

### SubscribeOn - Subscribe on Global Queue

Source: https://github.com/swiftzilla/skills/blob/main/skills/swift_combine/references/operators.md

Use .subscribe(on:) to specify the queue on which the publisher performs its work. The example subscribes on DispatchQueue.global().

```swift
publisher
    .subscribe(on: DispatchQueue.global())
```

--------------------------------

### Switch with Ranges

Source: https://github.com/swiftzilla/skills/blob/main/skills/swift_structure/references/control_flow.md

Shows how to use range patterns in a switch statement to categorize a score. The example prints 'B' for a score of 85.

```swift
let score = 85

switch score {
case 0..<60:
    print("Failing")
case 60..<70:
    print("D")
case 70..<80:
    print("C")
case 80..<90:
    print("B")     // This prints
case 90...100:
    print("A")
default:
    print("Invalid score")
}
```

--------------------------------

### Debounce Example

Source: https://github.com/swiftzilla/skills/blob/main/skills/swift_combine/references/operators.md

Debounces a publisher, emitting only after a specified time interval has passed since the last emission. Useful for search-as-you-type scenarios.

```swift
searchTextPublisher
    .debounce(for: .seconds(0.5), scheduler: RunLoop.main)
    .sink { searchText in
        self.performSearch(searchText)
    }
```

--------------------------------

### Factory Method Style with Size Initializer

Source: https://github.com/swiftzilla/skills/blob/main/skills/swift_style/references/functions.md

Use factory methods with labeled parameters for clarity. The example shows a struct initializer with external labels, making the call read like a sentence.

```swift
struct Size {
    init(width: CGFloat, height: CGFloat) { ... }
}

let size = Size(width: 100, height: 200)
```

--------------------------------

### If Case

Source: https://github.com/swiftzilla/skills/blob/main/skills/swift_structure/references/control_flow.md

Demonstrates using if case for pattern matching. The first example checks if an integer is in a range, and the second matches an enum case with associated value.

```swift
let age = 25

if case 18...25 = age {
    print("Young adult")  // This prints
}

// With enum
enum Result {
    case success(String)
    case failure(Error)
}

let result: Result = .success("Data loaded")

if case .success(let message) = result {
    print(message)  // "Data loaded"
}
```

--------------------------------

### Basic Package.swift manifest

Source: https://github.com/swiftzilla/skills/blob/main/skills/swift_package_manager/SKILL.md

Defines a Swift package named MyLibrary with platform requirements, a library product, an external dependency on Alamofire, and separate test target. Use as a starting template for a new library package.

```swift
// swift-tools-version:5.9
import PackageDescription

let package = Package(
    name: "MyLibrary",
    platforms: [.iOS(.v15), .macOS(.v12)],
    products: [
        .library(
            name: "MyLibrary",
            targets: ["MyLibrary"]
        ),
    ],
    dependencies: [
        .package(url: "https://github.com/Alamofire/Alamofire.git", from: "5.8.0"),
    ],
    targets: [
        .target(
            name: "MyLibrary",
            dependencies: [
                .product(name: "Alamofire", package: "Alamofire")
            ]
        ),
        .testTarget(
            name: "MyLibraryTests",
            dependencies: ["MyLibrary"]
        ),
    ]
)
```

--------------------------------

### Scan operator

Source: https://github.com/swiftzilla/skills/blob/main/skills/swift_combine/references/operators.md

Accumulates values using a closure. In this example, it starts with 0 and adds each value, printing the running total: 1, 3, 6, 10.

```swift
// Accumulates values
[1, 2, 3, 4].publisher
    .scan(0) { accumulator, value in
        accumulator + value
    }
    .sink { print($0) }  // 1, 3, 6, 10
```

--------------------------------

### Explicit Sendable conformance for a class

Source: https://github.com/swiftzilla/skills/blob/main/skills/swift_concurrency/references/sendable.md

Shows a final class Config that explicitly conforms to Sendable. Classes require explicit conformance, and this example uses immutable properties.

```swift
// Classes require explicit conformance
final class Config: Sendable {
    let apiKey: String
    let timeout: TimeInterval
    
    init(apiKey: String, timeout: TimeInterval) {
        self.apiKey = apiKey
        self.timeout = timeout
    }
}
```

--------------------------------

### MVVM with Combine: UserListViewModel and APIService

Source: https://github.com/swiftzilla/skills/blob/main/skills/swift_combine/references/integration.md

Complete MVVM example with Combine: a User model, a UserListViewModel that fetches users via an APIService, and a SwiftUI view that displays them. The view model uses @Published properties and stores cancellables; the service uses URLSession.dataTaskPublisher and decodes JSON. The view shows a loading indicator and an alert on error.

```swift
// Model
struct User: Codable {
    let id: Int
    let name: String
}

// ViewModel
class UserListViewModel: ObservableObject {
    @Published var users = [User]()
    @Published var isLoading = false
    @Published var errorMessage: String?
    
    private var cancellables = Set<AnyCancellable>()
    private let apiService: APIServiceProtocol
    
    init(apiService: APIServiceProtocol = APIService()) {
        self.apiService = apiService
    }
    
    func fetchUsers() {
        isLoading = true
        errorMessage = nil
        
        apiService.fetchUsers()
            .receive(on: DispatchQueue.main)
            .sink(
                receiveCompletion: { [weak self] completion in
                    self?.isLoading = false
                    if case .failure(let error) = completion {
                        self?.errorMessage = error.localizedDescription
                    }
                },
                receiveValue: { [weak self] users in
                    self?.users = users
                }
            )
            .store(in: &cancellables)
    }
}

// Service
class APIService: APIServiceProtocol {
    func fetchUsers() -> AnyPublisher<[User], Error> {
        let url = URL(string: "https://api.example.com/users")!
        
        return URLSession.shared.dataTaskPublisher(for: url)
            .map(\.data)
            .decode(type: [User].self, decoder: JSONDecoder())
            .eraseToAnyPublisher()
    }
}

// View
struct UserListView: View {
    @StateObject private var viewModel = UserListViewModel()
    
    var body: some View {
        List(viewModel.users) { user in
            Text(user.name)
        }
        .onAppear {
            viewModel.fetchUsers()
        }
        .overlay {
            if viewModel.isLoading {
                ProgressView()
            }
        }
        .alert("Error", isPresented: .constant(viewModel.errorMessage != nil)) {
            Button("OK") {}
        } message: {
            Text(viewModel.errorMessage ?? "")
        }
    }
}
```

--------------------------------

### Async Let for Concurrent Fetching

Source: https://github.com/swiftzilla/skills/blob/main/skills/swift_concurrency/references/async_await.md

Uses async let to start two asynchronous operations concurrently and await both results. The comment indicates both fetches run concurrently.

```swift
func loadData() async throws -> (User, Settings) {
    async let userTask = fetchUser()
    async let settingsTask = fetchSettings()
    
    // Both fetch concurrently
    let user = try await userTask
    let settings = try await settingsTask
    
    return (user, settings)
}
```

--------------------------------

### Custom Property Wrapper

Source: https://github.com/swiftzilla/skills/blob/main/skills/swift_swiftui/references/property_wrappers.md

Create a custom property wrapper to persist values in UserDefaults. The example defines a UserDefault wrapper and uses it in a SettingsView with a TextField bound to the wrapped value.

```swift
@propertyWrapper
struct UserDefault<T> {
    let key: String
    let defaultValue: T
    
    var wrappedValue: T {
        get {
            UserDefaults.standard.object(forKey: key) as? T ?? defaultValue
        }
        nonmutating set {
            UserDefaults.standard.set(newValue, forKey: key)
        }
    }
}

struct SettingsView: View {
    @UserDefault(key: "username", defaultValue: "Guest")
    var username: String
    
    var body: some View {
        TextField("Username", text: $username)
    }
}
```

--------------------------------

### Create a GitHub repository for a Swift package

Source: https://github.com/swiftzilla/skills/blob/main/skills/swift_package_manager/references/publishing.md

Commands to initialize a local repository, commit all files, add a remote origin, and push to GitHub.

```bash
git init
git add .
git commit -m "Initial commit"
git remote add origin https://github.com/username/MyPackage.git
git push -u origin main

```

--------------------------------

### Switch with Where Clause

Source: https://github.com/swiftzilla/skills/blob/main/skills/swift_structure/references/control_flow.md

Demonstrates using a where clause in switch cases to add conditions. The example prints 'On line x=-y' for the point (10, -10).

```swift
let point = (x: 10, y: -10)

switch point {
case let (x, y) where x == y:
    print("On line x=y")
case let (x, y) where x == -y:
    print("On line x=-y")  // This prints
default:
    print("Somewhere else")
}
```

--------------------------------

### Defaulted Parameters in Date Initializer

Source: https://github.com/swiftzilla/skills/blob/main/skills/swift_style/references/functions.md

Provide sensible defaults for commonly-used arguments. The example shows an initializer with defaulted locale and timeZone parameters, allowing a simple call with only the required string.

```swift
extension Date {
    convenience init?(iso8601 string: String,
                     locale: Locale? = nil,
                     timeZone: TimeZone? = nil) { ... }
}

// Simple call
let date = Date(iso8601: "2025-04-01T12:00:00Z")
```

--------------------------------

### String Interpolation in Swift

Source: https://github.com/swiftzilla/skills/blob/main/skills/swift_structure/references/strings.md

Demonstrates basic interpolation, expressions, and formatting with String(format:).

```swift
let name = "Ada"
let age = 28

// Basic interpolation
let message = "Hello, \(name)! You are \(age) years old."

// Expressions
let result = "5 + 3 = \(5 + 3)"

// Formatting
let pi = 3.14159
let formatted = "Pi is approximately \(String(format: "%.2f", pi))"
```

--------------------------------

### URLSession dataTaskPublisher GET with decode and sink

Source: https://github.com/swiftzilla/skills/blob/main/skills/swift_combine/references/integration.md

Creates a data task publisher for a GET request, decodes the response, and receives on the main queue. Handles both completion and value events, printing errors or received data. Requires a cancellables set and a MyData type conforming to Decodable.

```swift
let url = URL(string: "https://api.example.com/data")!

URLSession.shared.dataTaskPublisher(for: url)
    .map(\.data)
    .decode(type: MyData.self, decoder: JSONDecoder())
    .receive(on: DispatchQueue.main)
    .sink(
        receiveCompletion: { completion in
            switch completion {
            case .finished:
                break
            case .failure(let error):
                print("Error: \(error)")
            }
        },
        receiveValue: { data in
            print("Received: \(data)")
        }
    )
    .store(in: &cancellables)
```

--------------------------------

### ReplaceError Example

Source: https://github.com/swiftzilla/skills/blob/main/skills/swift_combine/references/operators.md

Replaces any error from the publisher with a default value. The sink is omitted for brevity.

```swift
publisher
    .replaceError(with: "default")
```

--------------------------------

### Substrings in Swift

Source: https://github.com/swiftzilla/skills/blob/main/skills/swift_structure/references/strings.md

Demonstrates creating substrings and converting Substring to String.

```swift
let greeting = "Hello, World!"

// Creating substrings
let comma = greeting.firstIndex(of: ",")!
let beginning = greeting[..<comma]  // "Hello"

// Substring is not String (but easily convertible)
let stringBeginning = String(beginning)
```

--------------------------------

### GitHub release notes template

Source: https://github.com/swiftzilla/skills/blob/main/skills/swift_package_manager/references/publishing.md

Template for GitHub release notes. Includes sections for features, bug fixes, breaking changes, and a migration guide with a Swift Package Manager dependency update.

```markdown
## What's New

### Features
- Added X functionality
- Improved Y performance

### Bug Fixes
- Fixed Z issue

### Breaking Changes
- Changed API from A to B

## Migration Guide

Update your Package.swift:
```swift
.package(url: "...", from: "2.0.0")
```

```

--------------------------------

### Run swift_ask with a natural language question

Source: https://github.com/swiftzilla/skills/blob/main/skills/swift_ask/SKILL.md

Executes the swift_ask wrapper script from the skill's scripts/ folder. Requires the SWIFTZILLA_API_KEY environment variable to be set; otherwise, the tool fails fatally. Use for general Swift/iOS architectural questions only.

```bash
scripts/swift_ask "<NATURAL_LANGUAGE_QUESTION>"
```

--------------------------------

### Role-Prefixed Weak Types in addObserver

Source: https://github.com/swiftzilla/skills/blob/main/skills/swift_style/references/functions.md

Prefix weakly-typed parameters with role nouns to improve clarity. The example contrasts a clear version with a vague one, showing the recommended pattern.

```swift
// Clear
func addObserver(_ observer: NSObject, forKeyPath path: String)

// Vague
func add(_ observer: NSObject, for path: String)
```

--------------------------------

### Filter operator

Source: https://github.com/swiftzilla/skills/blob/main/skills/swift_combine/references/operators.md

Passes only values that satisfy a condition. In this example, it passes only values greater than 0.

```swift
publisher
    .filter { $0 > 0 }
```

--------------------------------

### Generate documentation with swift package or DocC

Source: https://github.com/swiftzilla/skills/blob/main/skills/swift_package_manager/references/publishing.md

Commands to generate documentation using Swift Package Manager or DocC directly.

```bash
# Generate documentation
swift build --target MyPackage
swift package generate-documentation

# Or use DocC
xcrun docc convert MyPackage.docc \
    --fallback-display-name MyPackage \
    --fallback-bundle-identifier com.example.MyPackage \
    --output-dir docs

```

--------------------------------

### Timer Publisher with autoconnect

Source: https://github.com/swiftzilla/skills/blob/main/skills/swift_combine/references/integration.md

Creates a timer that publishes the current date every second on the main run loop. Use autoconnect() to start immediately and store the subscription in a cancellables set to manage its lifetime.

```swift
Timer.publish(every: 1.0, on: .main, in: .common)
    .autoconnect()
    .sink { date in
        print("Tick: \(date)")
    }
    .store(in: &cancellables)
```

--------------------------------

### AssertNoFailure Example

Source: https://github.com/swiftzilla/skills/blob/main/skills/swift_combine/references/operators.md

Asserts that the publisher never fails, causing a runtime error if it does. The sink is omitted for brevity.

```swift
publisher
    .assertNoFailure()
```

--------------------------------

### ReceiveOn - Receive on Main Thread

Source: https://github.com/swiftzilla/skills/blob/main/skills/swift_combine/references/operators.md

Use .receive(on:) to switch the publisher's output to the main thread, typically for UI updates. The example shows receiving on DispatchQueue.main and updating UI in the sink.

```swift
publisher
    .receive(on: DispatchQueue.main)
    .sink { value in
        // Update UI on main thread
    }
```

--------------------------------

### Package directory structure

Source: https://github.com/swiftzilla/skills/blob/main/skills/swift_package_manager/SKILL.md

Shows the conventional layout of a Swift package with Package.swift, Sources, Tests, and README. Use this as a reference when creating a new package.

```text
MyPackage/
├── Package.swift          # Package manifest
├── Sources/
│   └── MyLibrary/
│       └── MyLibrary.swift
├── Tests/
│   └── MyLibraryTests/
│       └── MyLibraryTests.swift
└── README.md
```

--------------------------------

### Executable Product

Source: https://github.com/swiftzilla/skills/blob/main/skills/swift_package_manager/references/package_structure.md

Executable product declaration for a command-line tool.

```swift
.executable(
    name: "CLI-Tool",
    targets: ["CLI-Tool"]
)
```

--------------------------------

### Build and checksum an XCFramework

Source: https://github.com/swiftzilla/skills/blob/main/skills/swift_package_manager/references/publishing.md

Commands to build an XCFramework, zip it for distribution, and compute its checksum for use in a binary target.

```bash
# Build XCFramework
xcodebuild -create-xcframework \
    -framework MyFramework.framework \
    -output MyFramework.xcframework

# Zip for distribution
zip -r MyFramework.xcframework.zip MyFramework.xcframework

# Calculate checksum
swift package compute-checksum MyFramework.xcframework.zip

```

--------------------------------

### DropWhile operator

Source: https://github.com/swiftzilla/skills/blob/main/skills/swift_combine/references/operators.md

Ignores values from a publisher until a condition is false. In this example, it drops values while they are less than 5.

```swift
publisher
    .drop(while: { $0 < 5 })
```

--------------------------------

### Fluent Function Naming with insert(_:at:)

Source: https://github.com/swiftzilla/skills/blob/main/skills/swift_style/references/functions.md

Use a base name that conveys the action and external labels to form grammatical phrases. The example shows a function that inserts an element at an index, with usage reading like a sentence.

```swift
/// Inserts `newElement` at `index` within the collection.
func insert(_ newElement: Element, at index: Int) {
    // implementation
}

// Usage reads like a sentence
array.insert(42, at: 2)
```

--------------------------------

### DropFirst operator

Source: https://github.com/swiftzilla/skills/blob/main/skills/swift_combine/references/operators.md

Ignores the first n values from a publisher. In this example, it drops the first 3 values.

```swift
publisher
    .dropFirst(3)
```

--------------------------------

### Xcode-clickable output for swift-deep-insight

Source: https://github.com/swiftzilla/skills/blob/main/skills/swift_deep_insight/SKILL.md

Outputs results in Xcode-compatible format (file:line:column:) for easy navigation.

```bash
swift run swift-deep-insight --project-path . --xcode-format
```

--------------------------------

### Map operator

Source: https://github.com/swiftzilla/skills/blob/main/skills/swift_combine/references/operators.md

Transforms each value from a publisher using a closure. In this example, the closure uppercases each string value.

```swift
publisher
    .map { value in
        value.uppercased()
    }
```

--------------------------------

### Tag pre-release versions with git

Source: https://github.com/swiftzilla/skills/blob/main/skills/swift_package_manager/references/publishing.md

Commands to tag pre-release versions such as beta and release candidate.

```bash
# Beta
git tag 1.0.0-beta.1

# Release Candidate
git tag 1.0.0-rc.1

```

--------------------------------

### FlatMap operator

Source: https://github.com/swiftzilla/skills/blob/main/skills/swift_combine/references/operators.md

Flattens nested publishers into a single publisher. In this example, it flattens a publisher of publishers and prints each value.

```swift
// Flattens nested publishers
publishersOfPublishers
    .flatMap { $0 }
    .sink { value in
        print(value)
    }
```

--------------------------------

### Create Basic Publishers with Combine

Source: https://github.com/swiftzilla/skills/blob/main/skills/swift_combine/SKILL.md

Create a basic publisher using @Published, CurrentValueSubject, PassthroughSubject, Just, and Future. Requires iOS 13+ or macOS 10.15+.

```swift
import Combine

// Published property
@Published var username: String = ""

// CurrentValueSubject
let subject = CurrentValueSubject<String, Never>("initial")

// PassthroughSubject
let passthrough = PassthroughSubject<Int, Never>()

// Just publisher
let just = Just("value")

// Future publisher
let future = Future<String, Error> { promise in
    promise(.success("result"))
}
```

--------------------------------

### Working with Indices in Swift

Source: https://github.com/swiftzilla/skills/blob/main/skills/swift_structure/references/strings.md

Shows how to use String.Index for offset, finding, and iterating over indices.

```swift
let greeting = "Guten Tag!"

// String indices are not integers!
let index = greeting.index(greeting.startIndex, offsetBy: 7)
greeting[index]             // "a"

// Finding indices
if let comma = greeting.firstIndex(of: ",") {
    print(greeting[greeting.startIndex..<comma])
}

// Iterating
for index in greeting.indices {
    print(greeting[index])
}
```

--------------------------------

### Basic Dictionary Operations

Source: https://github.com/swiftzilla/skills/blob/main/skills/swift_structure/references/collections_dictionary.md

Demonstrates key existence testing, safe access with a default value, and value mutation.

```swift
var scores: [String: Int] = ["alice": 10, "bob": 12, "carol": 8]

// Fast key existence test
if scores.keys.contains("bob") {
    print("Bob is in the dictionary")
}

// Safe access with default
let daveScore = scores["dave", default: 0]   // 0

// Mutate value
scores["alice"] = 15
```

--------------------------------

### Autoclosure Example

Source: https://github.com/swiftzilla/skills/blob/main/skills/swift_structure/references/closures.md

Shows an autoclosure that delays evaluation of an expression until the closure is called. The expression is passed directly without braces.

```swift
func log(_ message: @autoclosure () -> String) {
    print("Log: \(message())")
}

// Can pass expression directly
log("Value is \(5 * 2)")
```

--------------------------------

### Accessing Resources

Source: https://github.com/swiftzilla/skills/blob/main/skills/swift_package_manager/references/package_structure.md

Accessing a bundled resource at runtime using Bundle.module.

```swift
// In code
if let url = Bundle.module.url(forResource: "data", withExtension: "json") {
    let data = try Data(contentsOf: url)
}
```

--------------------------------

### Run context sync to rebuild the semantic index

Source: https://github.com/swiftzilla/skills/blob/main/skills/swiftzilla/references/context.md

Rebuilds the encrypted semantic index. Run this when no corresponding .bin file exists in ~/.swiftzilla/cache, when the project is newer than the cache file, or when query returns unexpected results after a refactor.

```bash
./swiftzilla context sync --path <PROJECT_ROOT>
```

--------------------------------

### Reduce - Accumulate Values

Source: https://github.com/swiftzilla/skills/blob/main/skills/swift_combine/references/operators.md

Use .reduce() to accumulate values into a single result. The example sums an array of integers, printing 10.

```swift
[1, 2, 3, 4].publisher
    .reduce(0) { $0 + $1 }
    .sink { print($0) }  // 10
```

--------------------------------

### Required file structure for a Swift package

Source: https://github.com/swiftzilla/skills/blob/main/skills/swift_package_manager/references/publishing.md

Shows the required file structure for a Swift package before publishing. README.md and LICENSE are required for open source distribution.

```text
MyPackage/
├── Package.swift
├── README.md          # Required
├── LICENSE            # Required for open source
├── Sources/
└── Tests/

```

--------------------------------

### Protocol Composition and Existential

Source: https://github.com/swiftzilla/skills/blob/main/skills/swift_style/references/protocols.md

Demonstrates two advanced protocol techniques: using the `some` keyword for opaque parameter types that must conform to multiple protocols (composition), and utilizing `any` for existential collections that can hold heterogeneous types conforming to a protocol.

```swift
// Composition
func use(item: some ProtocolA & ProtocolB) { }
```

```swift
// Existential
let items: [any Drawable] = [...]
```

--------------------------------

### Migration from completion handler to async/await

Source: https://github.com/swiftzilla/skills/blob/main/skills/swift_concurrency/references/async_await.md

Shows the before and after of converting a function from a completion handler to async/await. The before version uses a completion handler with Result type, while the after version uses async throws.

```swift
// Before (completion handler)
func fetchUser(completion: @escaping (Result<User, Error>) -> Void) {
    // ...
}

// After (async/await)
func fetchUser() async throws -> User {
    // ...
}
```

--------------------------------

### MeasureInterval - Measure Time Between Events

Source: https://github.com/swiftzilla/skills/blob/main/skills/swift_combine/references/operators.md

Use .measureInterval(using:) to measure the time interval between consecutive events. The example uses DispatchQueue.main as the scheduler.

```swift
publisher
    .measureInterval(using: DispatchQueue.main)
```

--------------------------------

### CompactMap operator

Source: https://github.com/swiftzilla/skills/blob/main/skills/swift_combine/references/operators.md

Transforms each value and removes nil results. In this example, it converts strings to integers and prints only the non-nil results (1 and 2).

```swift
// Removes nil values
["1", "a", "2", "b"].publisher
    .compactMap { Int($0) }
    .sink { print($0) }  // 1, 2
```

--------------------------------

### TryMap operator

Source: https://github.com/swiftzilla/skills/blob/main/skills/swift_combine/references/operators.md

Transforms each value from a publisher and can throw an error. In this example, it attempts to convert a string to an integer and throws ConversionError.invalid if the conversion fails.

```swift
publisher
    .tryMap { value in
        guard let number = Int(value) else {
            throw ConversionError.invalid
        }
        return number
    }
```

--------------------------------

### @StateObject - Owned Reference

Source: https://github.com/swiftzilla/skills/blob/main/skills/swift_swiftui/references/property_wrappers.md

Use @StateObject to own a reference-type model that conforms to ObservableObject. The example shows a view that creates and owns its ViewModel instance.

```swift
struct PersistentView: View {
    @StateObject private var viewModel = ViewModel()
    
    var body: some View {
        VStack {
            Text("Count: \(viewModel.count)")
            Button("Increment") {
                viewModel.increment()
            }
        }
    }
}
```

--------------------------------

### Basic Assertions with #expect

Source: https://github.com/swiftzilla/skills/blob/main/skills/swift_testing/references/test_basics.md

Demonstrates common #expect assertions for equality, inequality, comparison, Boolean conditions, nil checks, and type checking.

```swift
@Test
func basicAssertions() {
    let value = 42
    
    // Equality
    #expect(value == 42)
    
    // Inequality
    #expect(value != 0)
    
    // Comparison
    #expect(value > 0)
    #expect(value < 100)
    
    // Boolean
    #expect(value.isMultiple(of: 2))
    
    // Nil/Non-nil
    let optional: String? = "hello"
    #expect(optional != nil)
    
    // Type checking
    let anyValue: Any = "string"
    #expect(anyValue is String)
}
```

--------------------------------

### Scan current directory with swift-deep-insight

Source: https://github.com/swiftzilla/skills/blob/main/skills/swift_deep_insight/SKILL.md

Runs the analyzer from the project root. Requires the project to be built first to generate the index store.

```bash
swift run swift-deep-insight --project-path .
```

--------------------------------

### Max - Maximum Value

Source: https://github.com/swiftzilla/skills/blob/main/skills/swift_combine/references/operators.md

Use .max() to emit the maximum value, optionally with a comparator. The example shows both the default and a custom comparator using .max(by:).

```swift
publisher
    .max()
    .max(by: { $0 < $1 })
```

--------------------------------

### Protocol Extension with Default Implementation

Source: https://github.com/swiftzilla/skills/blob/main/skills/swift_style/references/protocols.md

Shows how to provide a default implementation for a protocol method in an extension. This allows conforming types to inherit the default behavior unless they provide their own specific implementation.

```swift
// Extension with default implementation
extension MyProtocol {
    func method() -> Int { return 42 }
}
```

--------------------------------

### Running Tests with swift test Commands

Source: https://github.com/swiftzilla/skills/blob/main/skills/swift_testing/SKILL.md

Shows common swift test commands: run all tests, filter by test name, run by tag, and enable verbose output. Each command is a separate invocation.

```bash
# Run all tests
swift test

# Run specific test
swift test --filter addition

# Run tests by tag
swift test --tag unit

# Run with verbose output
swift test --verbose
```

--------------------------------

### Swift Package Manager command-line usage

Source: https://github.com/swiftzilla/skills/blob/main/skills/swift_package_manager/SKILL.md

Common SPM commands for initializing, resolving, updating, building, testing, and generating an Xcode project. Run these in a terminal within a Swift package directory.

```bash
# Initialize new package
swift package init --type library
swift package init --type executable

# Resolve dependencies
swift package resolve

# Update dependencies
swift package update

# Build
swift build

# Test
swift test

# Generate Xcode project
swift package generate-xcodeproj
```

--------------------------------

### Package.swift Structure

Source: https://github.com/swiftzilla/skills/blob/main/skills/swift_package_manager/references/package_structure.md

Basic Package.swift template with swift-tools-version 5.9, platform minimums, and empty products, dependencies, and targets arrays.

```swift
// swift-tools-version:5.9
import PackageDescription

let package = Package(
    name: "PackageName",
    platforms: [.iOS(.v15), .macOS(.v13), .watchOS(.v9), .tvOS(.v16)],
    products: [
        // Products define executables and libraries
    ],
    dependencies: [
        // Dependencies on other packages
    ],
    targets: [
        // Targets are basic building blocks
    ],
    swiftLanguageVersions: [.v5]
)
```

--------------------------------

### Mocking Async Code

Source: https://github.com/swiftzilla/skills/blob/main/skills/swift_testing/references/async_testing.md

Illustrates how to isolate tests by creating a mock implementation of a protocol that returns predefined data or throws errors.

```swift
protocol APIProtocol {
    func fetchUser(id: Int) async throws -> User
}

struct MockAPI: APIProtocol {
    var mockUser: User?
    var shouldThrow: Error?
    
    func fetchUser(id: Int) async throws -> User {
        if let error = shouldThrow {
            throw error
        }
        return try #require(mockUser)
    }
}

@Test
func testWithMock() async throws {
    let mockAPI = MockAPI(
        mockUser: User(id: 1, name: "Test")
    )
    
    let user = try await mockAPI.fetchUser(id: 1)
    #expect(user.name == "Test")
}
```

--------------------------------

### Breakpoint - Conditional Breakpoint Operators

Source: https://github.com/swiftzilla/skills/blob/main/skills/swift_combine/references/operators.md

Use .breakpointOnError() to trigger a breakpoint on error, and .breakpoint(receiveOutput:) to trigger on a condition. The example shows breaking when output is greater than 100.

```swift
publisher
    .breakpointOnError()
    .breakpoint(receiveOutput: { $0 > 100 })
```

--------------------------------

### Protocol Extension with Default Implementation

Source: https://github.com/swiftzilla/skills/blob/main/skills/swift_style/references/protocols.md

Shows how to provide a default implementation for a protocol method via an extension. The conforming type can omit the method, and the extension's version is used.

```swift
protocol Square {
    var side: Double { get set }
    func area() -> Double
}

extension Square {
    func area() -> Double {
        return side * side
    }
}

struct MySquare: Square {
    var side: Double = 1.0
    // area() provided by extension
}

let s = MySquare(side: 5)
print(s.area())   // 25.0
```

--------------------------------

### @Environment - Shared Values

Source: https://github.com/swiftzilla/skills/blob/main/skills/swift_swiftui/references/property_wrappers.md

Use @Environment to read values from the view's environment, such as colorScheme, dismiss, and managedObjectContext. The example shows how to access these common environment values.

```swift
struct EnvironmentView: View {
    @Environment(\.colorScheme) var colorScheme
    @Environment(\.dismiss) var dismiss
    @Environment(\.managedObjectContext) var context
    
    var body: some View {
        VStack {
            Text(colorScheme == .dark ? "Dark Mode" : "Light Mode")
            Button("Dismiss") {
                dismiss()
            }
        }
    }
}
```

--------------------------------

### Nil Coalescing with Default Values

Source: https://github.com/swiftzilla/skills/blob/main/skills/swift_structure/references/optionals.md

Use the `??` operator to provide a default value when an optional is nil. The example shows fallback for a nil input and for a missing dictionary key.

```swift
let input: String? = nil
let number = Int(input) ?? 0          // 0

// Dictionary fallback
let config: [String: Int] = ["threshold": 5]
let threshold = config["missing"] ?? 10   // 10
```

--------------------------------

### Generic Stack

Source: https://github.com/swiftzilla/skills/blob/main/skills/swift_structure/references/generics.md

Defines a generic Stack struct with push, pop, count, isEmpty, and top properties. The usage example shows creating stacks of Int and String.

```swift
struct Stack<Element> {
    private var items: [Element] = []
    
    mutating func push(_ item: Element) {
        items.append(item)
    }
    
    mutating func pop() -> Element? {
        return items.popLast()
    }
    
    var count: Int { items.count }
    var isEmpty: Bool { items.isEmpty }
    var top: Element? { items.last }
}

// Usage
var intStack = Stack<Int>()
intStack.push(1)
intStack.push(2)
print(intStack.pop() ?? 0)  // 2

var stringStack = Stack<String>()
stringStack.push("Hello")
stringStack.push("World")
```

--------------------------------

### Avoid Overloading on Return Type

Source: https://github.com/swiftzilla/skills/blob/main/skills/swift_style/references/functions.md

Differentiate functions by parameter list, not return type. The example shows ambiguous overloads and a better approach using parameters to distinguish them.

```swift
// Bad - ambiguous
func fetch() -> Data
func fetch() -> String

// Good - differentiate by parameters
func fetch(asData: Bool) -> Data
func fetch(asString: Bool) -> String
```

--------------------------------

### Linker Settings

Source: https://github.com/swiftzilla/skills/blob/main/skills/swift_package_manager/references/package_structure.md

Linker settings: linked frameworks, libraries, and unsafe flags.

```swift
linkerSettings: [
    .linkedFramework("UIKit"),
    .linkedFramework("CoreData", .when(platforms: [.iOS, .macOS])),
    .linkedLibrary("z"),
    .unsafeFlags(["-L/path/to/lib"]),
]
```

--------------------------------

### Organizing Code with Extensions

Source: https://github.com/swiftzilla/skills/blob/main/skills/swift_structure/references/extensions.md

Shows how to organize a view controller by separating protocol conformance into extensions. The class declares the main implementation, then extensions add UITableViewDataSource and UITableViewDelegate methods, using MARK comments for clarity.

```swift
class MyViewController: UIViewController {
    // Main class implementation
}

// MARK: - UITableViewDataSource
extension MyViewController: UITableViewDataSource {
    func tableView(_ tableView: UITableView, numberOfRowsInSection section: Int) -> Int {
        return items.count
    }
    
    func tableView(_ tableView: UITableView, cellForRowAt indexPath: IndexPath) -> UITableViewCell {
        // ...
    }
}

// MARK: - UITableViewDelegate
extension MyViewController: UITableViewDelegate {
    func tableView(_ tableView: UITableView, didSelectRowAt indexPath: IndexPath) {
        // ...
    }
}
```

--------------------------------

### Generic Subscripts

Source: https://github.com/swiftzilla/skills/blob/main/skills/swift_structure/references/generics.md

Defines a generic Matrix struct with a subscript that allows getting and setting elements by row and column. The initializer takes a default value to fill the grid.

```swift
struct Matrix<T> {
    let rows: Int, columns: Int
    private var grid: [T]
    
    init(rows: Int, columns: Int, defaultValue: T) {
        self.rows = rows
        self.columns = columns
        self.grid = Array(repeating: defaultValue, count: rows * columns)
    }
    
    subscript(row: Int, column: Int) -> T {
        get {
            return grid[(row * columns) + column]
        }
        set {
            grid[(row * columns) + column] = newValue
        }
    }
}
```

--------------------------------

### Subscription lifecycle diagram

Source: https://github.com/swiftzilla/skills/blob/main/skills/swift_combine/references/publishers_subscribers.md

ASCII diagram showing the flow from publisher to subscriber, subscription creation, demand, value sending, and completion or cancellation.

```text
Publisher → Subscriber
     ↓
Subscription created
     ↓
Subscriber requests values (demand)
     ↓
Publisher sends values
     ↓
Completion or Cancellation
```

--------------------------------

### @ObservedObject - External State

Source: https://github.com/swiftzilla/skills/blob/main/skills/swift_swiftui/references/property_wrappers.md

Use @ObservedObject to observe an external reference-type model that conforms to ObservableObject. The example shows a ViewModel with @Published properties and a view that updates when the model changes.

```swift
class ViewModel: ObservableObject {
    @Published var count = 0
    @Published var message = ""
    
    func increment() {
        count += 1
    }
}

struct ContentView: View {
    @ObservedObject var viewModel: ViewModel
    
    var body: some View {
        VStack {
            Text("Count: \(viewModel.count)")
            Button("Increment") {
                viewModel.increment()
            }
        }
    }
}
```

--------------------------------

### @Suite Named Suite

Source: https://github.com/swiftzilla/skills/blob/main/skills/swift_testing/references/organization.md

Shows how to provide a display name for a test suite using the @Suite macro with a string argument.

```swift
@Suite("Calculator Operations")
struct CalculatorTests {
    // Tests...
}
```
Tokens:
Raw