[{"data":1,"prerenderedAt":-1},["ShallowReactive",2],{"skill:01M79X9XJMQ8HGSYFX1ED09KVS":3,"skill-same:01M79X9XJMQ8HGSYFX1ED09KVS":53},{"skillNo":4,"name":5,"nameZh":6,"description":7,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":16,"categories":17,"keywords":18,"publishedAt":19,"linkOnly":20,"markdownContent":21,"markdownBody":22,"frontMatter":23,"refName":24,"commitSha":25,"skillDirectory":26,"forksCount":27,"repositoryHtmlUrl":28,"repositoryHomepageUrl":6,"ownerHtmlUrl":29,"ownerBlogUrl":30,"ownerDescription":31,"updatedAt":32,"install":33,"resources":46},"01M79X9XJMQ8HGSYFX1ED09KVS","deniz-dotnet-general.csharp-concurrency-patterns",null,"Choosing the right concurrency abstraction in .NET - from async\u002Fawait for I\u002FO to Channels for producer\u002Fconsumer to Akka.NET for stateful entity management. Avoid locks and manual synchronization unless absolutely necessary.","Blind-Striker\u002Fagent-skills-and-plugins","Blind-Striker","https:\u002F\u002Favatars.githubusercontent.com\u002Fu\u002F1965259?v=4","01M79WFXTE5PH0C1VB7B54ANMN","Deniz İrgin","01M79WFXV5KZ5GST1K8G035DM5",1,"MIT","https:\u002F\u002Fgithub.com\u002FBlind-Striker\u002Fagent-skills-and-plugins\u002Fblob\u002Fmaster\u002Fopencode\u002Fdeniz-dotnet-general\u002Fskills\u002Fdeniz-dotnet-general.csharp-concurrency-patterns\u002FSKILL.md",[],[],"2026-11-15 14:19:17",false,"---\nname: deniz-dotnet-general.csharp-concurrency-patterns\ndescription: Choosing the right concurrency abstraction in .NET - from\n  async\u002Fawait for I\u002FO to Channels for producer\u002Fconsumer to Akka.NET for stateful\n  entity management. Avoid locks and manual synchronization unless absolutely\n  necessary.\n---\n\n# .NET Concurrency: Choosing the Right Tool\n\n## When to Use This Skill\n\nUse this skill when:\n- Deciding how to handle concurrent operations in .NET\n- Evaluating whether to use async\u002Fawait, Channels, Akka.NET, or other abstractions\n- Tempted to use locks, semaphores, or other synchronization primitives\n- Need to process streams of data with backpressure, batching, or debouncing\n- Managing state across multiple concurrent entities\n\n## Reference Files\n\n- [advanced-concurrency.md](advanced-concurrency.md): Akka.NET Streams, Reactive Extensions, Akka.NET Actors (entity-per-actor, state machines, cluster sharding), and async local function patterns\n\n## The Philosophy\n\n**Start simple, escalate only when needed.**\n\nMost concurrency problems can be solved with `async\u002Fawait`. Only reach for more sophisticated tools when you have a specific need that async\u002Fawait can't address cleanly.\n\n**Try to avoid shared mutable state.** The best way to handle concurrency is to design it away. Immutable data, message passing, and isolated state (like actors) eliminate entire categories of bugs.\n\n**Locks should be the exception, not the rule.** When you can't avoid shared mutable state:\n1. **First choice:** Redesign to avoid it (immutability, message passing, actor isolation)\n2. **Second choice:** Use `System.Collections.Concurrent` (ConcurrentDictionary, etc.)\n3. **Third choice:** Use `Channel\u003CT>` to serialize access through message passing\n4. **Last resort:** Use `lock` for simple, short-lived critical sections\n\n---\n\n## Decision Tree\n\n```\nWhat are you trying to do?\n│\n├─► Wait for I\u002FO (HTTP, database, file)?\n│   └─► Use async\u002Fawait\n│\n├─► Process a collection in parallel (CPU-bound)?\n│   └─► Use Parallel.ForEachAsync\n│\n├─► Producer\u002Fconsumer pattern (work queue)?\n│   └─► Use System.Threading.Channels\n│\n├─► UI event handling (debounce, throttle, combine)?\n│   └─► Use Reactive Extensions (Rx)\n│\n├─► Server-side stream processing (backpressure, batching)?\n│   └─► Use Akka.NET Streams\n│\n├─► State machines with complex transitions?\n│   └─► Use Akka.NET Actors (Become pattern)\n│\n├─► Manage state for many independent entities?\n│   └─► Use Akka.NET Actors (entity-per-actor)\n│\n├─► Coordinate multiple async operations?\n│   └─► Use Task.WhenAll \u002F Task.WhenAny\n│\n└─► None of the above fits?\n    └─► Ask yourself: \"Do I really need shared mutable state?\"\n        ├─► Yes → Consider redesigning to avoid it\n        └─► Truly unavoidable → Use Channels or Actors to serialize access\n```\n\n---\n\n## Level 1: async\u002Fawait (Default Choice)\n\n**Use for:** I\u002FO-bound operations, non-blocking waits, most everyday concurrency.\n\n```csharp\n\u002F\u002F Simple async I\u002FO\npublic async Task\u003COrder> GetOrderAsync(string orderId, CancellationToken ct)\n{\n    var order = await _database.GetAsync(orderId, ct);\n    var customer = await _customerService.GetAsync(order.CustomerId, ct);\n    return order with { Customer = customer };\n}\n\n\u002F\u002F Parallel async operations (when independent)\npublic async Task\u003CDashboard> LoadDashboardAsync(string userId, CancellationToken ct)\n{\n    var ordersTask = _orderService.GetRecentOrdersAsync(userId, ct);\n    var notificationsTask = _notificationService.GetUnreadAsync(userId, ct);\n    var statsTask = _statsService.GetUserStatsAsync(userId, ct);\n\n    await Task.WhenAll(ordersTask, notificationsTask, statsTask);\n\n    return new Dashboard(\n        Orders: await ordersTask,\n        Notifications: await notificationsTask,\n        Stats: await statsTask);\n}\n```\n\n**Key principles:** Always accept `CancellationToken`. Use `ConfigureAwait(false)` in library code. Don't block on async code.\n\n---\n\n## Level 2: Parallel.ForEachAsync (CPU-Bound Parallelism)\n\n**Use for:** Processing collections in parallel when work is CPU-bound or you need controlled concurrency.\n\n```csharp\npublic async Task ProcessOrdersAsync(\n    IEnumerable\u003COrder> orders,\n    CancellationToken ct)\n{\n    await Parallel.ForEachAsync(\n        orders,\n        new ParallelOptions\n        {\n            MaxDegreeOfParallelism = Environment.ProcessorCount,\n            CancellationToken = ct\n        },\n        async (order, token) =>\n        {\n            await ProcessOrderAsync(order, token);\n        });\n}\n```\n\n**When NOT to use:** Pure I\u002FO operations, when order matters, when you need backpressure.\n\n---\n\n## Level 3: System.Threading.Channels (Producer\u002FConsumer)\n\n**Use for:** Work queues, producer\u002Fconsumer patterns, decoupling producers from consumers.\n\n```csharp\npublic class OrderProcessor\n{\n    private readonly Channel\u003COrder> _channel;\n\n    public OrderProcessor()\n    {\n        _channel = Channel.CreateBounded\u003COrder>(new BoundedChannelOptions(100)\n        {\n            FullMode = BoundedChannelFullMode.Wait\n        });\n    }\n\n    \u002F\u002F Producer\n    public async Task EnqueueOrderAsync(Order order, CancellationToken ct)\n    {\n        await _channel.Writer.WriteAsync(order, ct);\n    }\n\n    \u002F\u002F Consumer (run as background task)\n    public async Task ProcessOrdersAsync(CancellationToken ct)\n    {\n        await foreach (var order in _channel.Reader.ReadAllAsync(ct))\n        {\n            await ProcessOrderAsync(order, ct);\n        }\n    }\n\n    public void Complete() => _channel.Writer.Complete();\n}\n```\n\n**Channels are good for:** Decoupling speed, buffering with backpressure, fan-out to workers, background queues.\n\n**Channels are NOT good for:** Complex stream operations (batching, windowing), stateful per-entity processing, sophisticated supervision.\n\n---\n\n## Level 4+: Akka.NET Streams, Reactive Extensions, Actors\n\nFor advanced scenarios requiring stream processing, UI event composition, or stateful entity management, see [advanced-concurrency.md](advanced-concurrency.md).\n\n**Akka.NET Streams** excel at server-side batching, throttling, and backpressure. **Reactive Extensions** are ideal for UI event composition. **Akka.NET Actors** handle entity-per-actor patterns, state machines with `Become()`, and distributed systems via Cluster Sharding.\n\n---\n\n## Anti-Patterns: What to Avoid\n\n### Locks for Business Logic\n\n```csharp\n\u002F\u002F BAD: Using locks to protect shared state\nprivate readonly object _lock = new();\nprivate Dictionary\u003Cstring, Order> _orders = new();\n\npublic void UpdateOrder(string id, Action\u003COrder> update)\n{\n    lock (_lock) { if (_orders.TryGetValue(id, out var order)) update(order); }\n}\n\n\u002F\u002F GOOD: Use an actor or Channel to serialize access\n```\n\n### Manual Thread Management\n\n```csharp\n\u002F\u002F BAD: Creating threads manually\nvar thread = new Thread(() => ProcessOrders());\nthread.Start();\n\n\u002F\u002F GOOD: Use Task.Run or better abstractions\n_ = Task.Run(() => ProcessOrdersAsync(cancellationToken));\n```\n\n### Blocking in Async Code\n\n```csharp\n\u002F\u002F BAD: Blocking on async - deadlock risk!\nvar result = GetDataAsync().Result;\n\n\u002F\u002F GOOD: Async all the way\nvar result = await GetDataAsync();\n```\n\n### Shared Mutable State Without Protection\n\n```csharp\n\u002F\u002F BAD: Multiple tasks mutating shared state\nvar results = new List\u003CResult>();\nawait Parallel.ForEachAsync(items, async (item, ct) =>\n{\n    var result = await ProcessAsync(item, ct);\n    results.Add(result); \u002F\u002F Race condition!\n});\n\n\u002F\u002F GOOD: Use ConcurrentBag\nvar results = new ConcurrentBag\u003CResult>();\n```\n\n---\n\n## Quick Reference: Which Tool When?\n\n| Need | Tool | Example |\n|------|------|---------|\n| Wait for I\u002FO | `async\u002Fawait` | HTTP calls, database queries |\n| Parallel CPU work | `Parallel.ForEachAsync` | Image processing, calculations |\n| Work queue | `Channel\u003CT>` | Background job processing |\n| UI events with debounce\u002Fthrottle | Reactive Extensions | Search-as-you-type, auto-save |\n| Server-side batching\u002Fthrottling | Akka.NET Streams | Event aggregation, rate limiting |\n| State machines | Akka.NET Actors | Payment flows, order lifecycles |\n| Entity state management | Akka.NET Actors | Order management, user sessions |\n| Fire multiple async ops | `Task.WhenAll` | Loading dashboard data |\n| Race multiple async ops | `Task.WhenAny` | Timeout with fallback |\n| Periodic work | `PeriodicTimer` | Health checks, polling |\n\n---\n\n## The Escalation Path\n\n```\nasync\u002Fawait (start here)\n    │\n    ├─► Need parallelism? → Parallel.ForEachAsync\n    │\n    ├─► Need producer\u002Fconsumer? → Channel\u003CT>\n    │\n    ├─► Need UI event composition? → Reactive Extensions\n    │\n    ├─► Need server-side stream processing? → Akka.NET Streams\n    │\n    └─► Need state machines or entity management? → Akka.NET Actors\n```\n\n**Only escalate when you have a concrete need.** Don't reach for actors or streams \"just in case\".\n","# .NET Concurrency: Choosing the Right Tool\n\n## When to Use This Skill\n\nUse this skill when:\n- Deciding how to handle concurrent operations in .NET\n- Evaluating whether to use async\u002Fawait, Channels, Akka.NET, or other abstractions\n- Tempted to use locks, semaphores, or other synchronization primitives\n- Need to process streams of data with backpressure, batching, or debouncing\n- Managing state across multiple concurrent entities\n\n## Reference Files\n\n- [advanced-concurrency.md](advanced-concurrency.md): Akka.NET Streams, Reactive Extensions, Akka.NET Actors (entity-per-actor, state machines, cluster sharding), and async local function patterns\n\n## The Philosophy\n\n**Start simple, escalate only when needed.**\n\nMost concurrency problems can be solved with `async\u002Fawait`. Only reach for more sophisticated tools when you have a specific need that async\u002Fawait can't address cleanly.\n\n**Try to avoid shared mutable state.** The best way to handle concurrency is to design it away. Immutable data, message passing, and isolated state (like actors) eliminate entire categories of bugs.\n\n**Locks should be the exception, not the rule.** When you can't avoid shared mutable state:\n1. **First choice:** Redesign to avoid it (immutability, message passing, actor isolation)\n2. **Second choice:** Use `System.Collections.Concurrent` (ConcurrentDictionary, etc.)\n3. **Third choice:** Use `Channel\u003CT>` to serialize access through message passing\n4. **Last resort:** Use `lock` for simple, short-lived critical sections\n\n---\n\n## Decision Tree\n\n```\nWhat are you trying to do?\n│\n├─► Wait for I\u002FO (HTTP, database, file)?\n│   └─► Use async\u002Fawait\n│\n├─► Process a collection in parallel (CPU-bound)?\n│   └─► Use Parallel.ForEachAsync\n│\n├─► Producer\u002Fconsumer pattern (work queue)?\n│   └─► Use System.Threading.Channels\n│\n├─► UI event handling (debounce, throttle, combine)?\n│   └─► Use Reactive Extensions (Rx)\n│\n├─► Server-side stream processing (backpressure, batching)?\n│   └─► Use Akka.NET Streams\n│\n├─► State machines with complex transitions?\n│   └─► Use Akka.NET Actors (Become pattern)\n│\n├─► Manage state for many independent entities?\n│   └─► Use Akka.NET Actors (entity-per-actor)\n│\n├─► Coordinate multiple async operations?\n│   └─► Use Task.WhenAll \u002F Task.WhenAny\n│\n└─► None of the above fits?\n    └─► Ask yourself: \"Do I really need shared mutable state?\"\n        ├─► Yes → Consider redesigning to avoid it\n        └─► Truly unavoidable → Use Channels or Actors to serialize access\n```\n\n---\n\n## Level 1: async\u002Fawait (Default Choice)\n\n**Use for:** I\u002FO-bound operations, non-blocking waits, most everyday concurrency.\n\n```csharp\n\u002F\u002F Simple async I\u002FO\npublic async Task\u003COrder> GetOrderAsync(string orderId, CancellationToken ct)\n{\n    var order = await _database.GetAsync(orderId, ct);\n    var customer = await _customerService.GetAsync(order.CustomerId, ct);\n    return order with { Customer = customer };\n}\n\n\u002F\u002F Parallel async operations (when independent)\npublic async Task\u003CDashboard> LoadDashboardAsync(string userId, CancellationToken ct)\n{\n    var ordersTask = _orderService.GetRecentOrdersAsync(userId, ct);\n    var notificationsTask = _notificationService.GetUnreadAsync(userId, ct);\n    var statsTask = _statsService.GetUserStatsAsync(userId, ct);\n\n    await Task.WhenAll(ordersTask, notificationsTask, statsTask);\n\n    return new Dashboard(\n        Orders: await ordersTask,\n        Notifications: await notificationsTask,\n        Stats: await statsTask);\n}\n```\n\n**Key principles:** Always accept `CancellationToken`. Use `ConfigureAwait(false)` in library code. Don't block on async code.\n\n---\n\n## Level 2: Parallel.ForEachAsync (CPU-Bound Parallelism)\n\n**Use for:** Processing collections in parallel when work is CPU-bound or you need controlled concurrency.\n\n```csharp\npublic async Task ProcessOrdersAsync(\n    IEnumerable\u003COrder> orders,\n    CancellationToken ct)\n{\n    await Parallel.ForEachAsync(\n        orders,\n        new ParallelOptions\n        {\n            MaxDegreeOfParallelism = Environment.ProcessorCount,\n            CancellationToken = ct\n        },\n        async (order, token) =>\n        {\n            await ProcessOrderAsync(order, token);\n        });\n}\n```\n\n**When NOT to use:** Pure I\u002FO operations, when order matters, when you need backpressure.\n\n---\n\n## Level 3: System.Threading.Channels (Producer\u002FConsumer)\n\n**Use for:** Work queues, producer\u002Fconsumer patterns, decoupling producers from consumers.\n\n```csharp\npublic class OrderProcessor\n{\n    private readonly Channel\u003COrder> _channel;\n\n    public OrderProcessor()\n    {\n        _channel = Channel.CreateBounded\u003COrder>(new BoundedChannelOptions(100)\n        {\n            FullMode = BoundedChannelFullMode.Wait\n        });\n    }\n\n    \u002F\u002F Producer\n    public async Task EnqueueOrderAsync(Order order, CancellationToken ct)\n    {\n        await _channel.Writer.WriteAsync(order, ct);\n    }\n\n    \u002F\u002F Consumer (run as background task)\n    public async Task ProcessOrdersAsync(CancellationToken ct)\n    {\n        await foreach (var order in _channel.Reader.ReadAllAsync(ct))\n        {\n            await ProcessOrderAsync(order, ct);\n        }\n    }\n\n    public void Complete() => _channel.Writer.Complete();\n}\n```\n\n**Channels are good for:** Decoupling speed, buffering with backpressure, fan-out to workers, background queues.\n\n**Channels are NOT good for:** Complex stream operations (batching, windowing), stateful per-entity processing, sophisticated supervision.\n\n---\n\n## Level 4+: Akka.NET Streams, Reactive Extensions, Actors\n\nFor advanced scenarios requiring stream processing, UI event composition, or stateful entity management, see [advanced-concurrency.md](advanced-concurrency.md).\n\n**Akka.NET Streams** excel at server-side batching, throttling, and backpressure. **Reactive Extensions** are ideal for UI event composition. **Akka.NET Actors** handle entity-per-actor patterns, state machines with `Become()`, and distributed systems via Cluster Sharding.\n\n---\n\n## Anti-Patterns: What to Avoid\n\n### Locks for Business Logic\n\n```csharp\n\u002F\u002F BAD: Using locks to protect shared state\nprivate readonly object _lock = new();\nprivate Dictionary\u003Cstring, Order> _orders = new();\n\npublic void UpdateOrder(string id, Action\u003COrder> update)\n{\n    lock (_lock) { if (_orders.TryGetValue(id, out var order)) update(order); }\n}\n\n\u002F\u002F GOOD: Use an actor or Channel to serialize access\n```\n\n### Manual Thread Management\n\n```csharp\n\u002F\u002F BAD: Creating threads manually\nvar thread = new Thread(() => ProcessOrders());\nthread.Start();\n\n\u002F\u002F GOOD: Use Task.Run or better abstractions\n_ = Task.Run(() => ProcessOrdersAsync(cancellationToken));\n```\n\n### Blocking in Async Code\n\n```csharp\n\u002F\u002F BAD: Blocking on async - deadlock risk!\nvar result = GetDataAsync().Result;\n\n\u002F\u002F GOOD: Async all the way\nvar result = await GetDataAsync();\n```\n\n### Shared Mutable State Without Protection\n\n```csharp\n\u002F\u002F BAD: Multiple tasks mutating shared state\nvar results = new List\u003CResult>();\nawait Parallel.ForEachAsync(items, async (item, ct) =>\n{\n    var result = await ProcessAsync(item, ct);\n    results.Add(result); \u002F\u002F Race condition!\n});\n\n\u002F\u002F GOOD: Use ConcurrentBag\nvar results = new ConcurrentBag\u003CResult>();\n```\n\n---\n\n## Quick Reference: Which Tool When?\n\n| Need | Tool | Example |\n|------|------|---------|\n| Wait for I\u002FO | `async\u002Fawait` | HTTP calls, database queries |\n| Parallel CPU work | `Parallel.ForEachAsync` | Image processing, calculations |\n| Work queue | `Channel\u003CT>` | Background job processing |\n| UI events with debounce\u002Fthrottle | Reactive Extensions | Search-as-you-type, auto-save |\n| Server-side batching\u002Fthrottling | Akka.NET Streams | Event aggregation, rate limiting |\n| State machines | Akka.NET Actors | Payment flows, order lifecycles |\n| Entity state management | Akka.NET Actors | Order management, user sessions |\n| Fire multiple async ops | `Task.WhenAll` | Loading dashboard data |\n| Race multiple async ops | `Task.WhenAny` | Timeout with fallback |\n| Periodic work | `PeriodicTimer` | Health checks, polling |\n\n---\n\n## The Escalation Path\n\n```\nasync\u002Fawait (start here)\n    │\n    ├─► Need parallelism? → Parallel.ForEachAsync\n    │\n    ├─► Need producer\u002Fconsumer? → Channel\u003CT>\n    │\n    ├─► Need UI event composition? → Reactive Extensions\n    │\n    ├─► Need server-side stream processing? → Akka.NET Streams\n    │\n    └─► Need state machines or entity management? → Akka.NET Actors\n```\n\n**Only escalate when you have a concrete need.** Don't reach for actors or streams \"just in case\".\n",{"name":5,"description":7},"master","b30b1c1908dbc56a8184128f18803053d762ccb5","opencode\u002Fdeniz-dotnet-general\u002Fskills\u002Fdeniz-dotnet-general.csharp-concurrency-patterns",0,"https:\u002F\u002Fgithub.com\u002FBlind-Striker\u002Fagent-skills-and-plugins","https:\u002F\u002Fgithub.com\u002FBlind-Striker","denizirgin.com","VP of Engineering - \r\n@armutcom @homeruntech @prontopro\r\n |  Speaker \r\n@CodeFiction\r\n, http:\u002F\u002Fcodefiction.tech | Developer, gamer, blogger, maiden iron fan","2026-11-13 00:23:18",{"source":8,"skillName":5,"commands":34,"prompt":44,"zipAvailable":45},[35,38,41],{"tool":36,"command":37},"npx","npx skills add Blind-Striker\u002Fagent-skills-and-plugins --skill deniz-dotnet-general.csharp-concurrency-patterns",{"tool":39,"command":40},"bunx","bunx skills add Blind-Striker\u002Fagent-skills-and-plugins --skill deniz-dotnet-general.csharp-concurrency-patterns",{"tool":42,"command":43},"pnpm","pnpm dlx skills add Blind-Striker\u002Fagent-skills-and-plugins --skill deniz-dotnet-general.csharp-concurrency-patterns","安装技能，技能地址：https:\u002F\u002Fgithub.com\u002FBlind-Striker\u002Fagent-skills-and-plugins\u002Fblob\u002Fmaster\u002Fopencode\u002Fdeniz-dotnet-general\u002Fskills\u002Fdeniz-dotnet-general.csharp-concurrency-patterns\u002FSKILL.md",true,[47],{"path":48,"resourceType":49,"resourceTypeDesc":50,"sizeBytes":51,"sourceHtmlUrl":52},"advanced-concurrency.md","REFERENCE","参考文档",11135,"https:\u002F\u002Fgithub.com\u002FBlind-Striker\u002Fagent-skills-and-plugins\u002Fblob\u002Fmaster\u002Fopencode\u002Fdeniz-dotnet-general\u002Fskills\u002Fdeniz-dotnet-general.csharp-concurrency-patterns\u002Fadvanced-concurrency.md",[54,61,68,75,82,89],{"skillNo":55,"name":56,"nameZh":6,"description":57,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":58,"categories":59,"keywords":60,"publishedAt":19},"01M79YGWBJ52PHMSTKJ3RJ3AWR","writing-tunit-tests","Write tests in TUnit — the attributes, the async assertion model, data-driven cases, lifecycle hooks, and the parallelism rules. USE FOR writing or fixing a test in a TUnit project, translating a test idea into TUnit syntax, or reviewing TUnit test code for API mistakes. DO NOT USE FOR deciding what to test, judging whether a test is any good, or running tests.","https:\u002F\u002Fgithub.com\u002FBlind-Striker\u002Fagent-skills-and-plugins\u002Fblob\u002Fmaster\u002Fskills\u002Fdeniz-dotnet-general\u002Fwriting-tunit-tests\u002FSKILL.md",[],[],{"skillNo":62,"name":63,"nameZh":6,"description":64,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":65,"categories":66,"keywords":67,"publishedAt":19},"01M79YGR3Y9RCRS6TD71D0KKP8","dotnet-walls","Walls for a .NET change in a repository without its own quality gates — pinned, ephemeral analyzer, format, clone and scanner commands for the verify step, their identity ratchet, and the build traps. Use during a walls preflight, or when a worker's verify step needs .NET quality gates.","https:\u002F\u002Fgithub.com\u002FBlind-Striker\u002Fagent-skills-and-plugins\u002Fblob\u002Fmaster\u002Fskills\u002Fdeniz-dotnet-general\u002Fdotnet-walls\u002FSKILL.md",[],[],{"skillNo":69,"name":70,"nameZh":6,"description":71,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":72,"categories":73,"keywords":74,"publishedAt":19},"01M79YGFNJBST7D803NQW3SBYM","csharp-15","Write, review and modernize C# 15 (.NET 11) code correctly. Covers every C# 15 feature - collection expression arguments (`[with(...), ...]`), union types (`union`, `[Union]`, `IUnion`, custom unions), closed class hierarchies (`closed`), extension indexers, labeled `break`\u002F`continue`, non-virtual static interface members on runtimes without default interface methods, and the preview memory-safety model (`unsafe(expr)`, `safe`, requires-unsafe members). Use when code targets net11.0 or LangVersion 15\u002Fpreview, when the user mentions any of these features, when replacing marker interfaces, OneOf-style results, `goto`\u002Fflag loop exits or capacity\u002Fcomparer boilerplate, or when the build reports CS8121, CS8509, CS8655, CS8510, CS0121\u002FCS0411 on a `with(...)` element, CS9370, CS9380 or CS9363.","https:\u002F\u002Fgithub.com\u002FBlind-Striker\u002Fagent-skills-and-plugins\u002Fblob\u002Fmaster\u002Fskills\u002Fdeniz-dotnet-general\u002Fcsharp-15\u002FSKILL.md",[],[],{"skillNo":76,"name":77,"nameZh":6,"description":78,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":79,"categories":80,"keywords":81,"publishedAt":19},"01M79YGAV031473HSX6FN87ENH","verified-waves","Run one task as verified multi-agent waves. Plans the fan-out, sends findings to fresh skeptics, keeps a ledger, and reports N of M done; small tasks stay solo.","https:\u002F\u002Fgithub.com\u002FBlind-Striker\u002Fagent-skills-and-plugins\u002Fblob\u002Fmaster\u002Fskills\u002Fdeniz-coordination\u002Fverified-waves\u002FSKILL.md",[],[],{"skillNo":83,"name":84,"nameZh":6,"description":85,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":86,"categories":87,"keywords":88,"publishedAt":19},"01M79YG6QXNND4WRPP3GATSY8J","harness","The bundled dispatch harness, which runs a task file on worker models through OpenCode or Codex, fences their writes, escalates their asks to the operator, settles each result from git and its verify commands, and records every step in a ledger. Its commands, task file, modes and write fence, configuration, runs and their recovery, ledger and exit codes.","https:\u002F\u002Fgithub.com\u002FBlind-Striker\u002Fagent-skills-and-plugins\u002Fblob\u002Fmaster\u002Fskills\u002Fdeniz-coordination\u002Fharness\u002FSKILL.md",[],[],{"skillNo":90,"name":91,"nameZh":6,"description":92,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":93,"categories":94,"keywords":95,"publishedAt":19},"01M79YG2P5S91SDTA5912XJ4FV","delegating-to-worker-models","Use when you hand off implementation, a plan, research a decision will rely on, or a review, and you brief the worker and check what comes back. A subagent that searches, reads in parallel, or keeps your context small is ordinary tool use. Covers what stays with you, the mechanism, assigning work by strength, the walls preflight, prompts without contradictions, the worker contract and model profiles, evidence from your own run, review, and the fix-up loop.","https:\u002F\u002Fgithub.com\u002FBlind-Striker\u002Fagent-skills-and-plugins\u002Fblob\u002Fmaster\u002Fskills\u002Fdeniz-coordination\u002Fdelegating-to-worker-models\u002FSKILL.md",[],[]]