AgentRules.org
RulesStacksClientsAuditorPrunerSelf-HealRFCsBenchmarkCLICI/CDAuthorsSubmit
This specification is maintained by the AgentRules Working Group. Have enhancements or want to claim maintainership?Submit Specification →
mobilecritical PriorityID: kmp-skie-coroutines-swift-concurrency-standard

Kotlin Multiplatform SKIE Coroutines & Swift Concurrency Invariant Standard

Enforces strict cooperative cancellation, structured concurrency lifecycles, and bounded dispatcher execution across the Touchlab SKIE interop bridge. Prohibits orphaned Kotlin coroutines, thread pool exhaustion, and unmanaged background tasks caused by detached or non-cooperative Swift Task execution.

Prohibited Anti-Pattern: Orphaned Kotlin Coroutines and Dispatcher Exhaustion via Unstructured Swift Concurrency

Export Ready-to-Drop Configuration

Select format below to copy code or download file directly.

---
description: Kotlin Multiplatform SKIE Coroutines & Swift Concurrency Invariant Standard - Enforces strict cooperative cancellation, structured concurrency lifecycles, and bounded dispatcher execution across the Touchlab SKIE interop bridge. Prohibits orphaned Kotlin coroutines, thread pool exhaustion, and unmanaged background tasks caused by detached or non-cooperative Swift Task execution.
globs: iosApp/**/*.swift, shared/src/**/*.kt, **/*.swift, **/*.kt
alwaysApply: true
verified_by: "agentrules.org"
license: "CC-BY-4.0"
source: "https://agentrules.org/rules/kmp-skie-coroutines-swift-concurrency-standard"
---

# Kotlin Multiplatform SKIE Coroutines & Swift Concurrency Invariant Standard

> **Severity**: CRITICAL | **Category**: mobile
> **Anti-Pattern Warning**: Orphaned Kotlin Coroutines and Dispatcher Exhaustion via Unstructured Swift Concurrency

## System Constraints
You are a Principal Mobile Architect enforcing the Kotlin Multiplatform SKIE Coroutine-Swift Concurrency Standard. Mandate that all asynchronous interop across Swift and Kotlin leverages cooperative cancellation, strict structured concurrency lifecycles, bounded dispatchers, and proper Flow collection termination to prevent thread exhaustion and memory leaks.

## Strict Guidelines
- Engineers MUST ALWAYS bind SKIE-generated Swift async calls to structured concurrency lifecycles (e.g., SwiftUI .task modifier or structured async let/withTaskCancellationHandler).
- Engineers MUST NOT invoke bridged Kotlin suspend functions or collect SkieSwiftFlow from unbounded Task.detached or unmanaged Task blocks without retaining a cancellable handle.
- Code SHOULD explicitly configure SKIE coroutine cancellation in Gradle build scripts to ensure bidirectional propagation of Swift Task cancellation to Kotlin Job cancellation.
- Services MUST ensure Kotlin suspend functions exposed across the bridge handle cooperative cancellation properly by never swallowing CancellationException with generic catch blocks.
- Components NEVER terminate SkieSwiftFlow iteration in Swift without properly cancelling the wrapping Task, ensuring the upstream Kotlin CoroutineScope cancels its active flow emission.

## Bad vs Good Implementations
### Consuming SKIE Kotlin Flow in Swift Concurrency

#### Bad Antipattern (AI Common Hallucination)
> **Why it fails**: Using Task.detached inside .onAppear bypasses SwiftUI's view lifecycle. When the view disappears, the Swift Task is not cancelled, the SKIE bridge retains the underlying Kotlin Coroutine collector on Dispatchers.Default, leaking memory and exhausting the thread pool.
```swift
// BAD: Launching unmanaged Task in SwiftUI onAppear without lifecycle tracking
// Swallowing cancellation in Swift and leaving Kotlin Coroutine collector running permanently
struct DataView: View {
    @StateObject private var viewModel = ObservableDataViewModel()
    
    var body: some View {
        Text(viewModel.status)
            .onAppear {
                Task.detached {
                    do {
                        // SKIE generates SkieSwiftFlow for Kotlin StateFlow
                        for await item in viewModel.repository.observeItems() {
                            await MainActor.run {
                                viewModel.status = item.title
                            }
                        }
                    } catch {
                        print("Stream error: \(error)")
                    }
                }
            }
    }
}
```

#### Production Standard (Correct)
> **Standard**: Using SwiftUI's .task modifier ties the async stream to the view lifecycle. When DataView dismisses, the Swift Task cancels cooperatively, which SKIE bridges directly to cancel the Kotlin CoroutineScope Job and tear down the flow collector.
```swift
// GOOD: Structured concurrency via SwiftUI .task modifier with automatic cooperative cancellation
struct DataView: View {
    @StateObject private var viewModel = ObservableDataViewModel()
    
    var body: some View {
        Text(viewModel.status)
            .task {
                do {
                    // Automatically cancelled when DataView disappears
                    for await item in viewModel.repository.observeItems() {
                        viewModel.status = item.title
                    }
                } catch is CancellationError {
                    // Cooperative cancellation successfully propagated to Kotlin Job
                } catch {
                    viewModel.handleError(error)
                }
            }
    }
}
```
Recommended MCP Servers (mcp-serverlist.com)

Equip agent with system tools to verify code for this stack.

Xcode Build & Diagnostic Server
Inspects iOS build errors, Swift Concurrency warnings, and Task lifecycle diagnostics.
Recommended Agent Skills (askills.dev)

Ready-to-use executable skill functions tailored to this stack.

Gradle CLI Helper
Validates KMP multiplatform build configurations, SKIE compiler plugins, and coroutine dependencies.
Architectural Specification & Invariant Rationale

Architectural Invariant Design: Kotlin Multiplatform SKIE Coroutines & Swift Concurrency Invariant Standard

Kotlin Multiplatform SKIE Coroutines & Swift Concurrency Invariant Standard defines an industrial-grade behavioral standard for mobile engineering. Enforces strict cooperative cancellation, structured concurrency lifecycles, and bounded dispatcher execution across the Touchlab SKIE interop bridge. Prohibits orphaned Kotlin coroutines, thread pool exhaustion, and unmanaged background tasks caused by detached or non-cooperative Swift Task execution. Modern software architectures require strict adherence to deterministic patterns to guarantee high availability, maintainability, and zero security vulnerabilities.

Framework Paradigm Shift & Drift MechanicsLLMs are trained on millions of open-source repositories containing outdated code, legacy idioms, and unpatched antipatterns. When coding assistants generate implementations for this stack, they default to common statistical tokens: Orphaned Kotlin Coroutines and Dispatcher Exhaustion via Unstructured Swift Concurrency Without an explicit system instruction file, developers spend hours debugging silent failures.
Failure Modes & Production Blast Radius

Hazard Analysis: What Breaks Without This Rule

The following failure modes have been cataloged from hundreds of hours of production code reviews where AI assistants produced non-compliant implementations:

Failure ModeAI Symptom (The Anti-Pattern)SeverityProduction Impact & Remedy
AI Hallucination & Deprecation DriftOrphaned Kotlin Coroutines and Dispatcher Exhaustion via Unstructured Swift ConcurrencyCritical
Violating this industrial standard introduces regression bugs, security risks, and unexpected runtime failures in production.
Enforce explicit behavioral system directives across all AI coding assistants in your repository.
Silent Architecture InconsistencyAI assistants produce mixed paradigms across files, creating fragmented codebase conventions.Medium
Increases cognitive load during code reviews and leads to maintenance debt across engineering teams.
Pin project conventions in .cursor/rules, CLAUDE.md, and AGENTS.md so all team agents follow identical guardrails.
Architectural Directives in Detail

Step-by-Step Production Directives

Each rule constraint below is injected into the AI agent's system prompt to establish deterministic boundaries:

1

Engineers MUST ALWAYS bind SKIE-generated Swift async calls to structured concurrency lifecycles (e.g., SwiftUI .task modifier or structured async let/withTaskCancellationHandler).

Engineers MUST ALWAYS bind SKIE-generated Swift async calls to structured concurrency lifecycles (e.g., SwiftUI .task modifier or structured async let/withTaskCancellationHandler).

Rationale:AI models frequently generate unconstrained code here because statistical language distributions lack project-specific architectural context. Mandating this directive ensures that generated code adheres to verified industrial production requirements.
Enforcement:Integrated into the Agent Pack rule file. When Cursor, Claude Code, or Codex processes this prompt, it applies this constraint before emitting syntax.
2

Engineers MUST NOT invoke bridged Kotlin suspend functions or collect SkieSwiftFlow from unbounded Task.detached or unmanaged Task blocks without retaining a cancellable handle.

Engineers MUST NOT invoke bridged Kotlin suspend functions or collect SkieSwiftFlow from unbounded Task.detached or unmanaged Task blocks without retaining a cancellable handle.

Rationale:AI models frequently generate unconstrained code here because statistical language distributions lack project-specific architectural context. Mandating this directive ensures that generated code adheres to verified industrial production requirements.
Enforcement:Integrated into the Agent Pack rule file. When Cursor, Claude Code, or Codex processes this prompt, it applies this constraint before emitting syntax.
3

Code SHOULD explicitly configure SKIE coroutine cancellation in Gradle build scripts to ensure bidirectional propagation of Swift Task cancellation to Kotlin Job cancellation.

Code SHOULD explicitly configure SKIE coroutine cancellation in Gradle build scripts to ensure bidirectional propagation of Swift Task cancellation to Kotlin Job cancellation.

Rationale:AI models frequently generate unconstrained code here because statistical language distributions lack project-specific architectural context. Mandating this directive ensures that generated code adheres to verified industrial production requirements.
Enforcement:Integrated into the Agent Pack rule file. When Cursor, Claude Code, or Codex processes this prompt, it applies this constraint before emitting syntax.
4

Services MUST ensure Kotlin suspend functions exposed across the bridge handle cooperative cancellation properly by never swallowing CancellationException with generic catch blocks.

Services MUST ensure Kotlin suspend functions exposed across the bridge handle cooperative cancellation properly by never swallowing CancellationException with generic catch blocks.

Rationale:AI models frequently generate unconstrained code here because statistical language distributions lack project-specific architectural context. Mandating this directive ensures that generated code adheres to verified industrial production requirements.
Enforcement:Integrated into the Agent Pack rule file. When Cursor, Claude Code, or Codex processes this prompt, it applies this constraint before emitting syntax.
5

Components NEVER terminate SkieSwiftFlow iteration in Swift without properly cancelling the wrapping Task, ensuring the upstream Kotlin CoroutineScope cancels its active flow emission.

Components NEVER terminate SkieSwiftFlow iteration in Swift without properly cancelling the wrapping Task, ensuring the upstream Kotlin CoroutineScope cancels its active flow emission.

Rationale:AI models frequently generate unconstrained code here because statistical language distributions lack project-specific architectural context. Mandating this directive ensures that generated code adheres to verified industrial production requirements.
Enforcement:Integrated into the Agent Pack rule file. When Cursor, Claude Code, or Codex processes this prompt, it applies this constraint before emitting syntax.
Technical Questions & Answers

Frequently Asked Technical Questions

Common questions developers face when configuring AI coding assistants for this stack:

Q:Why is Kotlin Multiplatform SKIE Coroutines & Swift Concurrency Invariant Standard critical for AI coding assistants?

Enforces strict cooperative cancellation, structured concurrency lifecycles, and bounded dispatcher execution across the Touchlab SKIE interop bridge. Prohibits orphaned Kotlin coroutines, thread pool exhaustion, and unmanaged background tasks caused by detached or non-cooperative Swift Task execution. Without explicit behavioral boundaries, AI coding assistants (Cursor, Claude Code, Windsurf, Codex) rely on training data averages, which frequently produce deprecated, inefficient, or vulnerable code patterns.

Q:How does adopting this rule prevent AI hallucinations?

This rule explicitly declares what the AI must avoid (Orphaned Kotlin Coroutines and Dispatcher Exhaustion via Unstructured Swift Concurrency) and prescribes verified positive examples. Grounding the LLM with negative and positive pairs eliminates guesswork.

Q:Which AI coding environments are supported?

This specification is multi-platform compatible: Cursor (.cursor/rules/*.mdc & .cursorrules), Anthropic Claude Code (CLAUDE.md), Windsurf (.windsurfrules), Codex / Cline (AGENTS.md), and GitHub Copilot (.github/copilot-instructions.md).

Q:Can I combine this rule with other technology stacks?

Yes. Use the Interactive Stack Builder or download an Agent Pack to merge this rule with other frontend, backend, database, security, and DevOps rules without syntax collision.

Open Specification · CC BY 4.0·Free for Personal, Team & Commercial In-Repo Use

Citation & Open Source Attribution Guidelines

This specification is licensed under Creative Commons Attribution 4.0 International (CC BY 4.0). You are completely free to adapt and share this rule in your workspace. If citing, including in public AI benchmark datasets, or redistributing, attribution to AgentRules.org is required.

Related MOBILE Rules

View all rules →
mobile
106

Tauri 2.0 Mobile IPC & Capabilities Permissions Matrix Standard

Tauri v2 introduces a capability-driven permissions system replacing legacy v1 allowlists across iOS and Android runtimes. Failure to constrain IPC command handlers with typed schemas and explicit mobile capability definitions exposes native mobile OS surfaces to arbitrary code execution, permission leakage, and silent serialization failures. Production mobile deployments require strictly typed IPC boundary validation, granular capability scopes, and graceful permission degradation.

mobile
70

Capacitor 7 Native Bridge, Biometric Auth & Android 15 Lifecycle Production Standard

Capacitor 7 enforces strict bridge lifecycle contracts, asynchronous native plugin interop, and mandatory Android 15 edge-to-edge window inset handling. Storing sensitive authentication tokens in unencrypted web storage or failing to bind biometric authentication directly to hardware-backed Keystore or Secure Enclave mechanisms compromises app integrity and causes fatal crash or viewport occlusion issues on modern mobile operating systems.

mobile
58

Tauri 2.0 Mobile IPC Isolation and Capabilities Permission Scoping

Enforces strict capability permission boundaries, payload validation, and secure IPC invoke scoping for Tauri v2 Android and iOS environments. Prevents arbitrary IPC command execution, excessive native privilege granting, and deserialization vulnerabilities across the mobile webview-native boundary.

1 Rule in Stack

Kotlin