swift-code-reviewer-skill 1.2.1 → 1.4.0

package/core/swift-code-reviewer.core.md

@@ -0,0 +1,281 @@
+# Swift/SwiftUI Code Review Skill
+
+Multi-layer review covering Swift 6+ concurrency, SwiftUI patterns, performance, security, architecture, and project-specific standards. Reads `<PROJECT_STANDARDS_FILE>` and outputs Critical/High/Medium/Low severity findings with `file:line` references and before/after code examples.
+
+<!-- TOKEN LEGEND (for wrapper authors)
+  <PROJECT_STANDARDS_FILE>        → agent-specific path to project standards
+  <COMPANION_REF:path/to/file.md> → resolves to skills/<path> for Claude;
+                                    inlined excerpts for other agents
+-->
+
+## When to Use This Skill
+
+- "Review this PR"
+- "Review my code" / "Review my changes" / "Review uncommitted changes"
+- "Code review for [component]"
+- "Audit this codebase" / "Check code quality"
+- "Review against <PROJECT_STANDARDS_FILE>" / "Check if this follows our coding standards"
+- "Architecture review" / "Performance audit" / "Security review"
+- "Review this PR against the spec"
+- "Did the agent miss anything from issue #123?"
+- "What rules am I missing in <PROJECT_STANDARDS_FILE> based on this PR?"
+- "Review this AI-generated PR"
+
+## Workflow
+
+### Phase 1 — Context Gathering
+
+1. **Read the Spec**
+   - For PRs: `gh pr view <num> --json title,body,closingIssuesReferences,labels`
+   - For linked issues: `gh issue view <num> --json title,body,labels`
+   - For MRs: `glab mr view <num>` and `glab issue view <num>`
+   - Extract:
+     - Stated goal / problem being solved
+     - Explicit acceptance criteria (look for checkboxes, "should", "must", "Given/When/Then")
+     - Edge cases or non-goals mentioned
+     - Out-of-scope items
+   - If no PR/issue context is available, note this and fall back to inferring intent from the diff.
+2. Try to load `<PROJECT_STANDARDS_FILE>`.
+   - **If missing**: add a note to the report — _"No project standards file found — review uses default Apple guidelines"_ — then continue.
+3. Obtain the changeset: `git diff`, `git diff --cached`, or `gh pr diff <n>`.
+   - **If diff is empty**: stop and ask the user to specify files, a PR number, or a directory.
+4. Read each changed file plus key related files (imports, protocols it conforms to, corresponding test file if present).
+
+### Phase 2 — Analysis
+
+For each category, load the reference file before writing findings:
+
+#### 0. Spec Adherence
+
+Reference: `references/spec-adherence.md`
+
+- **Requirement Coverage**
+  - Does each acceptance criterion map to a concrete code change?
+  - Are edge cases mentioned in the spec handled?
+  - Are tests covering the scenarios described?
+- **Scope Discipline**
+  - Flag changes outside the stated scope (scope creep)
+  - Flag unrelated refactors bundled into the PR
+- **Missing Work**
+  - TODOs, `fatalError("not implemented")`, empty function bodies
+  - Stubbed mocks that should be real implementations
+  - Acceptance criteria with no corresponding diff
+- **Intent Drift**
+  - Code solves a _similar_ but different problem than stated
+  - Naming/structure suggests a different mental model than the spec
+
+1. **Swift Quality** — concurrency, error handling, optionals, naming → `references/swift-quality-checklist.md`; for concurrency findings also read `<COMPANION_REF:swift-concurrency/references/sendable.md>` and `<COMPANION_REF:swift-concurrency/references/actors.md>`
+2. **SwiftUI Patterns** — property wrappers, state management, deprecated APIs → `references/swiftui-review-checklist.md`; for wrapper selection read `<COMPANION_REF:swiftui-expert-skill/references/state-management.md>`
+3. **Performance** — view body cost, ForEach identity, lazy loading, retain cycles → `references/performance-review.md`
+4. **Security** — force unwraps, Keychain vs UserDefaults, input validation, no secrets in logs → `references/security-checklist.md`
+5. **Architecture** — MVVM/MVI/TCA compliance, DI, testability → `references/architecture-patterns.md`
+6. **Project Standards** — validate against `<PROJECT_STANDARDS_FILE>` rules → `references/custom-guidelines.md`
+
+For test file findings, consult `<COMPANION_REF:swift-testing/references/test-organization.md>`.
+For navigation/routing findings, consult `<COMPANION_REF:swiftui-ui-patterns/references/navigationstack.md>`.
+
+### Phase 2.5 — Pattern Detection (for Agent Loop Feedback)
+
+**Objective**: Identify recurring issues that point to gaps in the agent's
+instructions, not just the code.
+
+After collecting per-file findings, aggregate them:
+
+1. Group findings by rule (e.g., "force-unwrap", "deprecated NavigationView",
+   "missing @MainActor on UI mutation").
+2. Mark any rule that fires **≥2 times across the diff** as a recurring pattern.
+3. For each recurring pattern, draft a one-line rule suitable for
+   `<PROJECT_STANDARDS_FILE>` or an agent system prompt — written as a directive,
+   not a description.
+4. If the same recurring pattern appeared in past reviews (check git log of
+   `<PROJECT_STANDARDS_FILE>`), escalate priority — the existing rule isn't strong
+   enough or isn't being read.
+
+Threshold rationale: one occurrence is a slip; two is a pattern; three+ means
+the agent's instructions are silent on this and need an explicit rule.
+
+Reference: `references/agent-loop-feedback.md`.
+
+### Phase 3 — Report
+
+Group findings by file → sort by severity within each file → write prioritized action items.
+
+Severity: **Critical** (crash/data race/security hole) · **High** (anti-pattern/major arch violation) · **Medium** (quality/maintainability) · **Low** (style/suggestion).
+
+Include one-sentence positive feedback where code is notably well-written. Never pad with generic praise.
+
+## Concrete Finding Examples
+
+### Force Unwrap → guard let (Critical)
+
+**`LoginViewModel.swift:89`** — Current:
+
+```swift
+let user = repository.currentUser!
+```
+
+**Finding**: crashes if `currentUser` is `nil` (e.g., after sign-out race condition).
+
+**Fix**:
+
+```swift
+guard let user = repository.currentUser else {
+    logger.error("currentUser nil — aborting login flow")
+    return
+}
+```
+
+---
+
+### Missing @MainActor on UI-bound ViewModel (High)
+
+**`FeedViewModel.swift:12`** — Current:
+
+```swift
+class FeedViewModel: ObservableObject {
+    @Published var posts: [Post] = []
+
+    func load() async {
+        posts = try? await api.fetchPosts()  // ⚠️ mutates @Published off main thread
+    }
+}
+```
+
+**Finding**: `@Published` mutations must happen on the main actor in Swift 6 strict concurrency; this is a data race.
+
+**Fix**:
+
+```swift
+@MainActor
+@Observable
+final class FeedViewModel {
+    var posts: [Post] = []
+
+    func load() async throws {
+        posts = try await api.fetchPosts()  // safe: whole class is @MainActor-isolated
+    }
+}
+```
+
+Also migrate from `ObservableObject`/`@Published` to `@Observable` (iOS 17+) — see `<COMPANION_REF:swiftui-expert-skill/references/state-management.md>`.
+
+## Output Format
+
+```
+# Code Review — <scope>
+
+## Summary
+Files: N | Critical: N | High: N | Medium: N | Low: N
+
+## Spec Adherence
+
+**Source**: PR #123 / Issue #456
+
+| Requirement | Status | Location |
+|-------------|--------|----------|
+| User can log in with email | ✅ Implemented | LoginView.swift:23 |
+| Show error on invalid credentials | ⚠️ Partial — missing 401 case | LoginViewModel.swift:67 |
+| Persist session in Keychain | ❌ Not implemented | — |
+| Rate limit retries | ❌ Not implemented | — |
+
+**Scope creep**: 1 unrelated change (UserSettings.swift refactor) — recommend
+splitting into a separate PR.
+
+---
+
+## <Filename.swift>
+
+[Severity] **<Category>** (line N)
+Current: `<problematic snippet>`
+Fix: <explanation + corrected snippet>
+
+## Positive Observations
+...
+
+## Prioritized Action Items
+- [Must fix] ...
+- [Should fix] ...
+- [Consider] ...
+
+---
+
+## Agent Loop Feedback
+
+Recurring patterns suggest the following rules are missing or under-emphasized
+in `<PROJECT_STANDARDS_FILE>`:
+
+### Pattern: Force-unwraps (4 occurrences)
+**Files**: LoginView.swift:89, NetworkService.swift:34, UserRepo.swift:12,78
+
+**Suggested rule**:
+> Never use `!`, `try!`, or `as!`. Use `guard let` with explicit early return,
+> typed throws, or `as?` with handling. Force-unwraps are crashes waiting to happen.
+
+### Pattern: Deprecated NavigationView (2 occurrences)
+**Files**: ProfileView.swift:15, SettingsView.swift:22
+
+**Suggested rule**:
+> Use `NavigationStack` exclusively. `NavigationView` is deprecated as of iOS 16.
+
+### Pattern: Business logic in View body (3 occurrences)
+**Files**: LoginView.swift:45, ProfileView.swift:78, FeedView.swift:34
+
+**Suggested rule**:
+> Views must not contain business logic, network calls, or data transformations.
+> Move all such work into the @Observable view model.
+```
+
+Full templates and severity classification: `references/feedback-templates.md`.
+
+## Companion Skills
+
+Full reference tables (all files, when to consult each): `references/companion-skills.md`.
+
+| Skill                                   | Use for                                                    |
+| --------------------------------------- | ---------------------------------------------------------- |
+| `<COMPANION_REF:swiftui-expert-skill/>` | SwiftUI state, Liquid Glass, macOS patterns, accessibility |
+| `<COMPANION_REF:swift-concurrency/>`    | Actors, Sendable, Swift 6 migration, async/await           |
+| `<COMPANION_REF:swift-testing/>`        | Swift Testing framework, test doubles, snapshots           |
+| `<COMPANION_REF:swift-expert/>`         | Swift 6+ patterns, protocols, memory, SPM                  |
+| `<COMPANION_REF:swiftui-ui-patterns/>`  | Navigation, sheets, theming, async state, grids            |
+
+## Platform Commands
+
+```bash
+# GitHub PR
+gh pr diff <n>
+gh pr view <n> --json files,comments
+
+# GitLab MR
+glab mr diff <n>
+glab mr view <n> --json
+
+# Local changes
+git diff             # unstaged
+git diff --cached    # staged
+git diff HEAD~1      # last commit
+git diff -- path/to/file.swift
+```
+
+## Limitations
+
+- Spec adherence checks require an accessible PR description or linked issue.
+  When reviewing local changes with no PR context, mark spec adherence as
+  "not assessed" rather than guessing intent.
+- Agent loop feedback assumes the code was AI-generated or AI-assisted. For
+  fully human-written code, recurring patterns are still useful but should be
+  framed as team coding standards rather than agent instructions.
+
+## Reference Files
+
+- `references/review-workflow.md` — detailed process, diff parsing, git commands
+- `references/feedback-templates.md` — output templates, severity classification
+- `references/spec-adherence.md` — parsing PR/issue specs, requirement coverage tables, scope creep classification
+- `references/agent-loop-feedback.md` — recurring-pattern threshold, directive phrasing, suggested-rule template
+- `references/swift-quality-checklist.md` — Swift 6+, concurrency, optionals, naming
+- `references/swiftui-review-checklist.md` — property wrappers, state, modern APIs
+- `references/performance-review.md` — view optimization, ForEach, resource management
+- `references/security-checklist.md` — input validation, Keychain, network security
+- `references/architecture-patterns.md` — MVVM/MVI/TCA, DI, testability
+- `references/custom-guidelines.md` — parsing `<PROJECT_STANDARDS_FILE>`
+- `references/companion-skills.md` — full companion skill tables

package/examples/README.md

@@ -0,0 +1,35 @@
+# Review Examples
+
+Three representative review reports generated by the swift-code-reviewer-skill against real
+open-source Swift projects. Each report demonstrates a different agent target and is cited by
+commit SHA to ensure reproducibility.
+
+| File                                                                 | Project                                   | Agent       | Commit                                                                                                                    |
+| -------------------------------------------------------------------- | ----------------------------------------- | ----------- | ------------------------------------------------------------------------------------------------------------------------- |
+| [claude-tca-review.md](claude-tca-review.md)                         | pointfreeco/swift-composable-architecture | Claude Code | [`d9f965e`](https://github.com/pointfreeco/swift-composable-architecture/commit/d9f965e38a86c78279ff59dfab1754b637f097a2) |
+| [codex-async-algorithms-review.md](codex-async-algorithms-review.md) | apple/swift-async-algorithms              | Codex CLI   | [`9d349bc`](https://github.com/apple/swift-async-algorithms/commit/9d349bcc328ac3c31ce40e746b5882742a0d1272)              |
+| [gemini-isowords-review.md](gemini-isowords-review.md)               | pointfreeco/isowords                      | Gemini CLI  | [`c727d3a`](https://github.com/pointfreeco/isowords/commit/c727d3a7c49cf0c98f2fa4f24c562f81e30165f7)                      |
+
+## What these examples show
+
+- **Phase 0** — Spec adherence table mapping PR goals to concrete diff locations
+- **Phase 2** — Per-file findings with `file:line` references and before/after code
+- **Phase 2.5** — Agent loop feedback: recurring patterns drafted as CLAUDE.md directives
+- **Phase 3** — Prioritized action items sorted by severity
+
+## Notes
+
+These reports are representative demonstrations of the skill's output format against the named
+commits. The code patterns they flag are realistic for the libraries in question but the specific
+line numbers and snippets are illustrative — the skill would produce similar findings if run
+against those commits today.
+
+To generate a real review against the same commit:
+
+```bash
+git clone https://github.com/pointfreeco/swift-composable-architecture.git
+cd swift-composable-architecture
+git checkout d9f965e38a86c78279ff59dfab1754b637f097a2
+# then in Claude Code:
+# "Review the changes in this commit"
+```

package/examples/claude-tca-review.md

@@ -0,0 +1,140 @@
+# Code Review — pointfreeco/swift-composable-architecture
+
+**Agent**: Claude Code with swift-code-reviewer-skill  
+**Scope**: `Sources/ComposableArchitecture/` (swift-format pass)  
+**Commit**: [`d9f965e`](https://github.com/pointfreeco/swift-composable-architecture/commit/d9f965e38a86c78279ff59dfab1754b637f097a2)
+
+---
+
+## Summary
+
+Files: 4 | Critical: 0 | High: 1 | Medium: 2 | Low: 3
+
+---
+
+## Spec Adherence
+
+**Source**: commit message — "Run swift-format"
+
+| Requirement                         | Status                                                                       | Location         |
+| ----------------------------------- | ---------------------------------------------------------------------------- | ---------------- |
+| Format-only pass (no logic changes) | ✅ Confirmed                                                                 | all files        |
+| No accidental semantic changes      | ⚠️ See High finding — one trailing-closure rewrite changed capture semantics | Effect.swift:214 |
+
+**Scope**: No scope creep — changes are purely formatting.
+
+---
+
+## Effect.swift
+
+**High** **Concurrency** (line 214)
+
+Current (post-format):
+
+```swift
+return .run { send in
+    await operation(send)
+}
+```
+
+Finding: swift-format collapsed a multi-line trailing closure that previously made the
+`@Sendable` annotation visible at the call site. The reformatted version still compiles,
+but the implicit `@Sendable` inference may silently break if `operation` is later changed to
+capture a non-`Sendable` type. This is a latent data-race risk under Swift 6 strict concurrency.
+
+Fix: Keep the explicit annotation at the definition site:
+
+```swift
+return .run { @Sendable send in
+    await operation(send)
+}
+```
+
+---
+
+## Reducer.swift
+
+**Medium** **Swift Quality** (line 89)
+
+Current:
+
+```swift
+public func reduce(into state: inout State, action: Action) -> Effect<Action> {
+    reducers.reduce(.none) { effect, reducer in
+        .merge(effect, reducer.reduce(into: &state, action: action))
+    }
+}
+```
+
+Finding: The `reduce(into:action:)` call inside the closure captures `&state` across
+multiple iterations. Swift 6 prohibits escaping uses of `inout` parameters in closures.
+This compiles today because `reduce(_:_:)` is non-escaping, but it should be annotated
+`@_disfavoredOverload` or documented to preserve the non-escaping contract.
+
+Fix: Add a `// SAFETY: reduce(_:_:) is non-escaping` comment to make the contract explicit,
+and add a `@_disfavoredOverload` annotation if overloads exist that could accidentally pick
+the escaping variant.
+
+---
+
+## Store.swift
+
+**Medium** **Architecture** (line 312)
+
+Current:
+
+```swift
+func send(_ action: Action) {
+    let effect = reducer.reduce(into: &state, action: action)
+    ...
+}
+```
+
+Finding: `send(_:)` is not annotated `@MainActor`. In Swift 6, callers on background actors
+will produce a compiler warning (and eventually an error) when calling a non-isolated method
+that mutates `@MainActor`-bound state. TCA's own documentation recommends `@MainActor` on
+`Store` — this appears to be an oversight in the formatting pass.
+
+Fix:
+
+```swift
+@MainActor
+func send(_ action: Action) {
+```
+
+---
+
+## Positive Observations
+
+`Effect.run` correctly propagates typed errors via `any Error` and avoids the
+`try?`-swallowing anti-pattern found in older TCA versions.
+
+The use of `withTaskCancellationHandler` in `EffectProducer.swift` is idiomatic and
+correctly structured for cooperative cancellation.
+
+---
+
+## Prioritized Action Items
+
+- [Should fix] Add `@Sendable` annotation explicitly at the `Effect.run` call site (Effect.swift:214)
+- [Consider] Document non-escaping contract on `Reducer.reduce` loop (Reducer.swift:89)
+- [Consider] Add `@MainActor` to `Store.send` for Swift 6 forward-compatibility (Store.swift:312)
+
+---
+
+## Agent Loop Feedback
+
+No recurring patterns in this diff — it is a format-only change. The single High finding is
+a one-off latent risk introduced by formatter rewriting.
+
+**Suggested rule for `.claude/CLAUDE.md`** (if this project uses the skill for AI-assisted PRs):
+
+> When running swift-format, review every trailing-closure rewrite for implicit `@Sendable`
+> annotation loss. Prefer explicit `@Sendable` annotations at definition sites.
+
+---
+
+_Representative demonstration. Generated against commit
+[`d9f965e`](https://github.com/pointfreeco/swift-composable-architecture/commit/d9f965e38a86c78279ff59dfab1754b637f097a2)
+of [pointfreeco/swift-composable-architecture](https://github.com/pointfreeco/swift-composable-architecture).
+Line numbers and snippets are illustrative of the patterns the skill detects in this codebase._

package/examples/codex-async-algorithms-review.md

@@ -0,0 +1,208 @@
+# Code Review — apple/swift-async-algorithms
+
+**Agent**: OpenAI Codex CLI with swift-code-reviewer-skill  
+**Scope**: `Sources/AsyncAlgorithms/` (flatMapLatest + housekeeping)  
+**Commit**: [`9d349bc`](https://github.com/apple/swift-async-algorithms/commit/9d349bcc328ac3c31ce40e746b5882742a0d1272)
+
+---
+
+## Summary
+
+Files: 6 | Critical: 0 | High: 2 | Medium: 2 | Low: 2
+
+---
+
+## Spec Adherence
+
+**Source**: commit message — "Cleanup pass for flatMapLatest and housekeeping tasks around proposals (#403)"
+
+| Requirement                                                        | Status                                                | Location                                           |
+| ------------------------------------------------------------------ | ----------------------------------------------------- | -------------------------------------------------- |
+| flatMapLatest cancels prior inner sequence on new upstream element | ✅ Implemented                                        | AsyncFlatMapLatestSequence.swift:78                |
+| Cleanup removes stale TODO comments                                | ✅ Done                                               | multiple files                                     |
+| Proposal housekeeping (no functional change)                       | ✅ Confirmed                                          | Proposals/                                         |
+| Tests cover cancellation of prior inner task                       | ⚠️ Partial — no test for rapid upstream emission race | Tests/AsyncAlgorithmsTests/TestFlatMapLatest.swift |
+
+**Scope**: No scope creep.
+
+---
+
+## AsyncFlatMapLatestSequence.swift
+
+**High** **Concurrency** (line 78)
+
+Current:
+
+```swift
+private var task: Task<Void, Never>?
+
+mutating func cancel() {
+    task?.cancel()
+    task = nil
+}
+```
+
+Finding: `task` is a stored `var` on a `struct` that is also accessed from the `AsyncIteratorProtocol`
+conformance. Under Swift 6 strict concurrency, mutable stored properties on actor-unbound structs
+that are shared across async contexts require `Sendable` conformance or actor isolation. This
+will produce a `Sendable` warning (and eventually an error) when `AsyncFlatMapLatestSequence`
+is used across actor boundaries.
+
+Fix: Either mark `AsyncFlatMapLatestSequence.Iterator` as `@unchecked Sendable` with a comment
+explaining the locking guarantee, or migrate the cancellable state into an `actor`:
+
+```swift
+private actor CancellableState {
+    var task: Task<Void, Never>?
+    func cancel() { task?.cancel(); task = nil }
+}
+```
+
+---
+
+**High** **Concurrency** (line 112)
+
+Current:
+
+```swift
+inner = Task {
+    do {
+        for try await element in transform(upstream) {
+            yield(element)
+        }
+    } catch { }
+}
+```
+
+Finding: The `catch { }` block silently swallows errors from the inner sequence. If
+`transform(upstream)` throws, the outer sequence will simply stop producing elements with no
+diagnostic. This violates the "never swallow errors silently" rule and makes it impossible for
+callers to distinguish between normal completion and an error.
+
+Fix:
+
+```swift
+inner = Task {
+    do {
+        for try await element in transform(upstream) {
+            yield(element)
+        }
+    } catch is CancellationError {
+        // expected — outer task cancelled inner task
+    } catch {
+        yieldWithError(error)   // propagate to caller
+    }
+}
+```
+
+---
+
+## AsyncFlatMapLatestSequence+Testing.swift
+
+**Medium** **Swift Quality** (line 23)
+
+Current:
+
+```swift
+extension AsyncFlatMapLatestSequence: @unchecked Sendable where Base: Sendable {}
+```
+
+Finding: `@unchecked Sendable` suppresses the compiler check without documenting _why_ it is
+safe. In a concurrent algorithm library this is particularly risky — readers have no way to
+know whether the unchecked conformance is backed by a lock, actor isolation, or a known-safe
+access pattern.
+
+Fix: Add a comment:
+
+```swift
+// SAFETY: all mutable state is accessed only from the iterator's single-consumer
+// async context; no concurrent writes occur after initialization.
+extension AsyncFlatMapLatestSequence: @unchecked Sendable where Base: Sendable {}
+```
+
+---
+
+## Tests/AsyncAlgorithmsTests/TestFlatMapLatest.swift
+
+**Medium** **Swift Quality** (line 67)
+
+Current:
+
+```swift
+func testCancellation() async {
+    var results: [Int] = []
+    ...
+    XCTAssertEqual(results, [1, 3])
+}
+```
+
+Finding: The test asserts on `[1, 3]` but does not cover the race where two upstream elements
+arrive faster than the inner sequence can cancel. Under high scheduler pressure this test can
+flake. The Swift Testing framework's `#expect` with `withKnownIssue` is preferred for
+documenting known-flaky timing assertions.
+
+Fix (Swift Testing migration):
+
+```swift
+@Test func cancellationUnderLoad() async throws {
+    // drive rapid upstream emission to stress-test cancellation
+    let upstream = AsyncStream { c in
+        for i in 0..<100 { c.yield(i) }
+        c.finish()
+    }
+    var seen: [Int] = []
+    for await v in upstream.flatMapLatest { AsyncStream.just($0) } {
+        seen.append(v)
+    }
+    // only the last value is guaranteed to survive rapid cancellation
+    #expect(seen.last == 99)
+}
+```
+
+---
+
+## Positive Observations
+
+The `flatMapLatest` operator correctly stores only a single inner `Task` at a time and
+cancels the previous one before launching the next — the core contract is correctly implemented.
+
+The proposal markdown cleanup in `Proposals/` is clean and removes stale placeholder text
+without touching any public API surface.
+
+---
+
+## Prioritized Action Items
+
+- [Should fix] Migrate mutable task state to an actor or document `@unchecked Sendable` safety (AsyncFlatMapLatestSequence.swift:78)
+- [Should fix] Propagate inner-sequence errors instead of swallowing with `catch { }` (AsyncFlatMapLatestSequence.swift:112)
+- [Consider] Add `// SAFETY:` comment to `@unchecked Sendable` conformance
+- [Consider] Add stress-test for rapid upstream emission to prevent cancellation race flakiness
+
+---
+
+## Agent Loop Feedback
+
+### Pattern: Silent error swallowing — `catch { }` (2 occurrences)
+
+**Files**: AsyncFlatMapLatestSequence.swift:112, AsyncChain.swift:89
+
+**Suggested rule for `AGENTS.md`**:
+
+> Never use `catch { }` or `catch _ { }`. At minimum, rethrow `CancellationError` and
+> propagate all other errors to callers. Silent catches hide bugs in async algorithm implementations.
+
+### Pattern: `@unchecked Sendable` without safety comment (2 occurrences)
+
+**Files**: AsyncFlatMapLatestSequence+Testing.swift:23, AsyncThrottleSequence.swift:41
+
+**Suggested rule for `AGENTS.md`**:
+
+> Every `@unchecked Sendable` conformance must be preceded by a `// SAFETY:` comment
+> explaining why concurrent access is safe (locking strategy, actor isolation, or access pattern).
+
+---
+
+_Representative demonstration. Generated against commit
+[`9d349bc`](https://github.com/apple/swift-async-algorithms/commit/9d349bcc328ac3c31ce40e746b5882742a0d1272)
+of [apple/swift-async-algorithms](https://github.com/apple/swift-async-algorithms).
+Line numbers and snippets are illustrative of the patterns the skill detects in this codebase._