swift-concurrency

Übersicht über den swift-concurrency-Skill

Was dieser Skill macht

Der swift-concurrency-Skill hilft dir, Swift-Concurrency-Probleme mit weniger Rätselraten zu lösen: Refactorings mit async/await, Actor-Isolation, Sendable, Task-Struktur, Warnungen durch strikte Concurrency-Prüfungen und Migrationsfragen rund um Swift 6. Er ist besonders passend, wenn du praktische Review-Hilfe brauchst und nicht nur Definitionen.

Für wen er am besten geeignet ist

Nutze den swift-concurrency-Skill, wenn du:

• Code auf Swift 6 oder strengere Compiler-Prüfungen migrierst
• Data Races, Fehler bei der Actor-Isolation oder Sendable-Warnungen behebst
• Callbacks durch async/await ersetzt
• zwischen @MainActor, eigenen Actors, nonisolated oder Task Groups abwägst
• vor dem Release prüfen willst, ob Code concurrency-sicher ist

Was ihn anders macht

Dieser swift-concurrency-Skill ist auf Entscheidungen ausgerichtet. Er legt den Fokus auf die Isolationsgrenze, strukturierte Concurrency und die Compiler-Einstellungen, die Diagnosemeldungen verändern. Das ist wichtig, weil derselbe Code je nach Sprachmodus und Toolchain gültig, verrauscht oder kaputt sein kann.

Wann er eher nicht passt

Wenn du nur eine schnelle Auffrischung der Syntax brauchst, reicht oft schon ein allgemeiner Prompt. Der swift-concurrency-Skill ist vor allem dann nützlich, wenn die Antwort vom Projektkontext, vom Compilerverhalten oder von einem konkreten Migrationspfad abhängt.

So verwendest du den swift-concurrency-Skill

Im richtigen Repo-Kontext installieren

Nutze für dein Skills-Setup den swift-concurrency install-Ablauf und wende den Skill dann dort an, wo du Swift-Code bearbeitest. Ein typischer Installationsbefehl ist:

npx skills add Joannis/claude-skills --skill swift-concurrency

Wenn deine Umgebung einen anderen Skills-Manager verwendet, behalte denselben Skill-Slug bei und verweise trotzdem auf das Repository Joannis/claude-skills.

Die richtige Eingabeform geben

Starke Nutzung von swift-concurrency beginnt mit einem konkreten Codeziel, nicht mit einem vagen Thema. Gib an:

• welche Datei oder welchen Typ du ändern willst
• den Compilerfehler oder die Warnung im Wortlaut
• ob das Ziel Swift 5.x oder Swift 6 ist
• die relevante Isolationsgrenze, falls bekannt
• ob UI-Code, Server-Code oder gemeinsam genutzter Model-Code betroffen ist

Guter Prompt:

Refaktoriere diesen callback-basierten Networking-Code auf async/await, aber halte UI-Updates nur dort auf @MainActor, wo sie wirklich nötig sind. Wir sind auf Swift 6 und der Compiler warnt wegen Sendable-Captures.

Schwacher Prompt:

Hilfe mit Swift Concurrency.

Zuerst die richtigen Dateien lesen

Für schnellere und sicherere Ergebnisse solltest du zuerst SKILL.md prüfen und dann die wichtigsten Referenzen:

• references/glossary.md für Begriffe
• references/async-await-basics.md für Konvertierungsmuster
• references/actors.md für Isolation und Actor-Zugriff
• references/sendable.md für Capture- und Transfer-Probleme
• references/performance.md für Parallelität und Contention

Wenn du an Produktionsarchitektur oder Tests arbeitest, schau außerdem in references/production-patterns.md und references/testing.md.

Workflow, der meist funktioniert

1. Den genauen Warnhinweis, Fehler oder Refactor-Ziel identifizieren.
2. Die Isolationsdomäne bestimmen: Main Actor, eigener Actor oder nonisolated.
3. Entscheiden, ob es sich um strukturelle Concurrency handelt und nicht nur um Syntax-Politur.
4. Zuerst nach der kleinsten sicheren Korrektur fragen.
5. Danach einen zweiten Durchgang für Performance, Testbarkeit oder Swift-6-Bereinigung anfordern.

FAQ zum swift-concurrency-Skill

Ist das nur ein besserer Prompt für Swift Concurrency?

Nein. Der swift-concurrency-Skill ist ein wiederverwendbarer Leitfaden mit repo-basierten Konventionen für Isolation, Sendable und Migrationsentscheidungen. Er ist deutlich besser als ein allgemeiner Prompt, wenn die Antwort vom Compiler-Modus oder von der Struktur von Tasks und Actors abhängt.

Muss ich async/await schon kennen?

Nein. Der Skill hilft auch Einsteigern, ist aber am nützlichsten, wenn du den Code und den Fehler teilen kannst. Wenn du nur das gewünschte Verhalten kennst, gib ein Minimalbeispiel an und lass den Skill das Concurrency-Modell ausarbeiten.

Funktioniert er für Server-Swift und App-Code?

Ja. Er passt für beides, aber die Empfehlung sollte unterschiedlich ausfallen. UI-Code braucht oft @MainActor; Server- oder Library-Code braucht meist engere Isolation und mehr Sorgfalt bei Sendable und der Task-Struktur.

Wann sollte ich ihn nicht verwenden?

Verwende swift-concurrency nicht für unrelated Async-APIs in anderen Sprachen und nicht dann, wenn das Problem rein in der Business-Logik liegt, ohne Actor-, Task- oder Compiler-Concurrency-Bezug. Er passt auch schlecht, wenn du nicht genug Kontext teilen kannst, um die Isolationsgrenze zu erkennen.

So verbesserst du den swift-concurrency-Skill

Die Compiler-Fakten gleich am Anfang nennen

Der größte Qualitätssprung entsteht, wenn du dem Skill sagst, welchen Sprachmodus und welche Toolchain du verwendest. Swift 5.10, Swift 6 und strikte Concurrency-Einstellungen können zu unterschiedlichen Antworten führen. Nenne nach Möglichkeit den exakten Warntext.

Die Grenze zeigen, nicht nur das Symptom

Der Skill arbeitet besser, wenn du sagst, wo der Zustand lebt und wer darauf zugreift. Zum Beispiel:

• „Dieser Cache wird von mehreren Request-Tasks gemeinsam genutzt“
• „Dieses ViewModel aktualisiert UIKit-State“
• „Dieser Parser soll nicht auf dem Main Actor laufen“

Das hilft dem swift-concurrency-Skill, zwischen Actor-Isolation, nonisolated, @MainActor oder Task-Gruppierung zu wählen.

Zuerst die kleinste sichere Änderung anfragen

Eine gute Anfrage an den swift-concurrency guide zielt auf die am wenigsten invasive Korrektur, die sauber kompiliert. Wenn du später tiefer einsteigen musst, frage in einem zweiten Schritt nach Performance, Cancellation oder Architektur. So vermeidest du Überkorrekturen mit pauschalem @MainActor oder unnötigem Task.detached.

Mit der nächsten Warnung iterieren, nicht mit einem Rewrite

Gib nach der ersten Antwort die nächste Compiler-Diagnose oder die nächste Laufzeit-Sorge zurück. Die besten Workflows für swift-concurrency for Code Editing sind inkrementell: ein Isolationsthema beheben, neu kompilieren und dann Sendable, Cancellation oder die Task-Struktur anhand der neuen Ausgabe weiter verfeinern.