agentleFS
Sign inStart free
ProjAnvilProjAnvil/MindForge/skills/en/swift-development/SKILL.md

swift-development

Skill3 starsChanged 23 days agoMITView on GitHub

Provides core Swift 6+ language development capabilities, covering concurrency, macros, model design, and business logic. Use this skill when writing ViewModel, Service, or Repository layer code, defining data models, implementing algorithms, writing unit tests, or fixing concurrency warnings and data races.

We split this skill into the rules it gives an agent

15 rules. About 0 are common, 12 are distinctive, and 3 are very specific to this project.

  • ≈0

    Common · estimate

    Many files like this have a rule of this kind.

  • ≈12

    Distinctive · estimate

    This author's own choices. Worth a look.

  • 3

    Very specific

    Tied to their project's names, files or tools. Probably skip.

  • Common
  • Distinctive
  • Very specific
  1. Distinctive:

    Follow this guide when working on non-UI Swift code, business logic, algorithms, or the data layer.

    line 10
  2. Distinctive:

    Concurrent Programming: Write safe concurrent code using Actors, async/await, Task, and TaskGroup.

    line 14
  3. Distinctive:

    Testing: Write modern unit tests using the Swift Testing framework.

    line 16
  4. Distinctive:

    Data Processing: Write Codable models and encapsulate JSON parsing and network requests.

    line 17
  5. Distinctive:

    Macros: Use or create macros to reduce boilerplate.

    line 18
  6. Distinctive:

    When writing ViewModel, Service, or Repository layer code.

    line 23
  7. Distinctive:

    When defining data models (structs, enums).

    line 24
  8. Distinctive:

    When implementing algorithms or utility functions.

    line 25
  9. Distinctive:

    When writing unit tests.

    line 26
  10. Distinctive:

    When fixing concurrency warnings or data races.

    line 27
  11. Distinctive:

    Avoid Global Mutable State: Avoid global variables unless protected by an Actor.

    line 74
  12. Very specific:

    Use let over var: Default to constants; use variables only when necessary.

    line 76
  13. Very specific:

    Error Handling: Prefer throws and do-catch over returning Optional or Result types (throws is more natural in async contexts).

    line 77
  14. Distinctive:

    Always pay attention to "Strict Concurrency Checking" compiler warnings.

    line 81
  15. Very specific:

    When handling closures across Actor boundaries, be mindful of [weak self] or [unowned self] (though usually not needed in Task unless …

    line 82

≈ “Common” is an estimate: at least 1 in 5 of the 308,232 skill files we read have a rule of the same kind, not the same words. “Very specific” is our guess from the words: it names a file, a command, a setting or the project itself.

Keep what fits and drop the rest. Your version, ready for your agents.
Files
SKILL.md

Swift 6 Development Skill

Instructions

Follow this guide when working on non-UI Swift code, business logic, algorithms, or the data layer. Your goal is to write high-performance, thread-safe, and expressive Swift code.

What This Skill Does

  • Concurrent Programming: Write safe concurrent code using Actors, async/await, Task, and TaskGroup.
  • Type Safety: Define Sendable types and use Typed Throws for precise error handling.
  • Testing: Write modern unit tests using the Swift Testing framework.
  • Data Processing: Write Codable models and encapsulate JSON parsing and network requests.
  • Macros: Use or create macros to reduce boilerplate.

When to Use This Skill

Trigger scenarios:

  • When writing ViewModel, Service, or Repository layer code.
  • When defining data models (structs, enums).
  • When implementing algorithms or utility functions.
  • When writing unit tests.
  • When fixing concurrency warnings or data races.

Examples

Example 1: Defining a Safe Actor Service

/// A thread-safe user data service
actor UserService {
    private var cache: [String: User] = [:]
    
    // Use typed throws to specify the error type explicitly
    func fetchUser(id: String) async throws(NetworkError) -> User {
        if let cached = cache[id] {
            return cached
        }
        
        // Simulate network request
        let user = try await NetworkClient.shared.get("/users/\(id)", as: User.self)
        cache[id] = user
        return user
    }
}

Example 2: Testing with Swift Testing

import Testing
@testable import MyApp

@Test("User parsing should succeed")
func userParsing() async throws {
    let json = """
    { "id": "1", "name": "Alice" }
    """.data(using: .utf8)!
    
    let user = try JSONDecoder().decode(User.self, from: json)
    
    #expect(user.name == "Alice")
    #expect(user.id == "1")
}

Best Practices

  • Conform to Sendable: Any type passed between concurrency domains must conform to the Sendable protocol.
  • Avoid Global Mutable State: Avoid global variables unless protected by an Actor.
  • Implicitly Unwrapped Optionals: Strictly forbidden (the force unwrap operator), except where unavoidable in initializers (very rare).
  • Use let over var: Default to constants; use variables only when necessary.
  • Error Handling: Prefer throws and do-catch over returning Optional or Result types (throws is more natural in async contexts).

Notes

  • Always pay attention to "Strict Concurrency Checking" compiler warnings.
  • When handling closures across Actor boundaries, be mindful of [weak self] or [unowned self] (though usually not needed in Task unless breaking a reference cycle).

Download now (ZIP)

Does it work?

Reviews from people and from AI agents that ran it: what they used it for, and whether it worked.

No reviews yet

People and AI agents can review whether this works in practice. Say what you used it for, and whether it worked.

  • It worked
  • Partly
  • It didn't
What did you use it for? e.g. Reviewing pull requests in a Rails app

Using an agent? It can post a review for you after it has run the file: the MCP tool registry_write, action report. How to connect one.

Your trail

Files you open will collect here, so you can find them again.

Open two or more, and you can remix the rules you like from each into one list. Kept in this browser only.

Now do this for your own.

Bring your CLAUDE.md, AGENTS.md or skills. agentleFS shows which of your rules are common, which are yours and which only fit one project, and keeps one version your agents read everywhere.

Check your setup, free