CtrlK
BlogDocsLog inGet started
Tessl Logo
SkillPublic

swift-concurrency

Resolve Swift concurrency compiler errors, adopt approachable concurrency (SE-0466), and write data-race-safe async code. Use when fixing Sendable conformance errors, actor isolation warnings, or strict concurrency diagnostics; when adopting default MainActor isolation, @concurrent, nonisolated(nonsending), or Task.immediate; when designing actor-based architectures, structured concurrency with TaskGroup, or background work offloading; or when migrating from @preconcurrency to full Swift 6 strict concurrency.

Quality

87%

Does it follow best practices?

Run evals on this skill

Adds up to 20 points to the overall score

View guide
SecuritybySnyk

Passed

No findings from the security scan

The canonical home for this skill is dpearson2699/swift-ios-skills

SKILL.md
Quality
Evals
Security

Quality

Content

67%Weight 40%Scale 1-5

Reviews the quality of instructions and guidance provided to agents. Good implementation is clear, handles edge cases, and produces reliable results.

A strong, well-structured skill body: concrete triage workflow with a verify step, situation→fix mapping, executable Swift 6.2+ examples, and a genuine, verified one-level-deep reference bundle. The main costs are token slack — duplicated Task.immediate content, restated basics, and dense patch-note paragraphs that overlap existing reference files — plus a missing `sending` syntax example.

Suggestions

Delete the duplicate Task.immediate entry under Structured Concurrency Patterns (lines 313-317) — it repeats the SE-0472 subsection including the identical code sample.

Add a minimal `sending` parameter example: the rule "Use `sending` parameters (SE-0430) for finer control" appears twice as a recommended fix but the syntax is never demonstrated.

Move the dense prose at the end of Synchronization Primitives (NSLock/@unchecked guidance) and Common Mistakes #11 into references/synchronization-primitives.md and references/bridging-interop.md respectively, leaving a one-line rule inline, to cut body tokens and reduce overlap with the reference files.

DimensionReasoningScore

Conciseness

Mostly efficient (rules, tables, code; no conceptual padding), but noticeably loose in places: the SE-0472 Task.immediate subsection is repeated verbatim under Structured Concurrency Patterns; basics Claude already knows are restated ("Cancellation is cooperative", async let vs TaskGroup, "Resume exactly once"); and the Synchronization Primitives tail and Common Mistakes #11 are dense run-on paragraphs that read like accumulated patch notes. Version numbers (Swift 6.2/6.3/6.4, iOS 16/18/27, Xcode 26.5/27) are scattered inline rather than consolidated. This fits anchor 3 ("could be tightened") better than 4 ("minor instances").

3 / 5

Actionability

The Situation→Recommended-fix table, numbered @concurrent offloading steps, and mostly compilable snippets give executable guidance, and the References section delegates diagnostics to a lookup file. Minor gaps keep it below 5: several snippets carry "// ..." elided bodies, and `sending` parameters (SE-0430) are recommended twice as a fix but never shown syntactically — a newer feature where an example earns its place.

4 / 5

Workflow Clarity

The Triage Workflow is a clear 3-step sequence (capture context → smallest safe fix → verify) with explicit checkpoints ("Rebuild and confirm the diagnostic is resolved", "Check for new warnings introduced by the fix", no unjustified @unchecked) plus a Review Checklist. Not 5: there is no explicit error-recovery loop (e.g., "if the diagnostic persists or new warnings appear, re-triage") — the feedback loop is implied by "rebuild and confirm" rather than stated.

4 / 5

Progressive Disclosure

All 7 referenced files exist, are one level deep, well-signaled (dedicated References section with one-line descriptions, plus anchored in-text deep links that resolve), and detail is appropriately deferred ("See references/synchronization-primitives.md for full API details"). Not 5: the ~480-line body is more manual than overview, with the Swift 6.2 Language Changes section overlapping references/approachable-concurrency.md and the long Synchronization Primitives prose overlapping its own reference file — some inline content belongs in those files.

4 / 5

Total

15

/

20

Passed

Description

100%Weight 40%Scale 1-5

Based on the skill's description, can an agent find and select it at the right time? Clear, specific descriptions lead to better discovery.

An exemplar description: concrete capabilities, a rich four-clause "Use when" whose trigger terms mirror real compiler diagnostics, and a distinct Swift-concurrency niche with essentially no conflict risk. Only nitpick is length (~90 words), but every clause is a distinct trigger rather than padding.

DimensionReasoningScore

Specificity

Lists multiple concrete actions — "Resolve Swift concurrency compiler errors", "adopt approachable concurrency (SE-0466)", "write data-race-safe async code" — covering the fix/adopt/write/migrate lifecycle comprehensively within the stated niche. Not 4: no coverage gaps within that scope; each action names a concrete technical object.

5 / 5

Completeness

Explicitly answers both: a three-verb "what" up front, then a four-clause "Use when..." covering fixing diagnostics, adopting specific features (SE-0466, @concurrent, nonisolated(nonsending), Task.immediate), designing architectures, and migrating from @preconcurrency. Matches the anchor-5 structure with concrete trigger phrases.

5 / 5

Trigger Term Quality

Trigger phrases are exactly what users say when hitting these diagnostics: "Sendable conformance errors", "actor isolation warnings", "strict concurrency diagnostics", "default MainActor isolation", "Task.immediate", "TaskGroup", "background work offloading", "@preconcurrency" — with synonyms (data-race-safe, strict concurrency, actor-based architectures) covered.

5 / 5

Distinctiveness Conflict Risk

Clear niche (Swift 6 strict concurrency) with SE-proposal-numbered and attribute-specific triggers that would not fire for general Swift, code-review, or architecture skills. Third-person voice throughout; no over-claims.

5 / 5

Total

20

/

20

Passed

Validation

100%

Checks the skill against the spec for correct structure and formatting. All validation checks must pass before discovery and implementation can be scored.

Validation — 16 / 16 Passed

Validation for skill structure

No warnings or errors.

Repository

dpearson2699/swift-ios-skills

Path

skills/swift-concurrency/SKILL.md

Reviewed

Table of Contents

Is this your skill?

If you maintain this skill, you can claim it as your own. Once claimed, you can manage eval scenarios, bundle related skills, attach documentation or rules, and ensure cross-agent compatibility.