[{"data":1,"prerenderedAt":-1},["ShallowReactive",2],{"skill:01M6E5X2J4V1THHDCH2F4T366E":3,"skill-same:01M6E5X2J4V1THHDCH2F4T366E":87},{"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":27,"linkOnly":28,"markdownContent":29,"markdownBody":30,"frontMatter":31,"refName":32,"commitSha":33,"skillDirectory":34,"forksCount":35,"repositoryHtmlUrl":36,"repositoryHomepageUrl":37,"ownerHtmlUrl":38,"ownerBlogUrl":6,"ownerDescription":39,"updatedAt":40,"install":41,"resources":54},"01M6E5X2J4V1THHDCH2F4T366E","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.","ComeOnOliver\u002Fskillshub","ComeOnOliver","https:\u002F\u002Favatars.githubusercontent.com\u002Fu\u002F43215937?v=4","01M6E5JNFECJAAVFE0W7SMWWD2","Haoran Shu","01M6E5JNNDQS7AJZDYFQ8TPZCK",67,"MIT","https:\u002F\u002Fgithub.com\u002FComeOnOliver\u002Fskillshub\u002Fblob\u002Fmain\u002Fskills\u002FAaronontheweb\u002Fdotnet-skills\u002Fcsharp-concurrency-patterns\u002FSKILL.md",[],[19,20,21,22,23,24,25,26],"csharp","concurrency","patterns","csharp concurrency patterns","synchronization","management","async","false","2026-11-10 10:12:30",false,"---\nname: csharp-concurrency-patterns\ndescription: 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.\ninvocable: false\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\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\n",{"name":5,"invocable":28,"description":7},"main","def8531e65114c0fca8fb8551c1871ee0eed705c","skills\u002FAaronontheweb\u002Fdotnet-skills\u002Fcsharp-concurrency-patterns",24,"https:\u002F\u002Fgithub.com\u002FComeOnOliver\u002Fskillshub","https:\u002F\u002Fskillshub.wtf","https:\u002F\u002Fgithub.com\u002FComeOnOliver","AI & Blockchain Engineer\r\n","2026-06-24 22:07:19",{"source":8,"skillName":5,"commands":42,"prompt":52,"zipAvailable":53},[43,46,49],{"tool":44,"command":45},"npx","npx skills add ComeOnOliver\u002Fskillshub --skill csharp-concurrency-patterns",{"tool":47,"command":48},"bunx","bunx skills add ComeOnOliver\u002Fskillshub --skill csharp-concurrency-patterns",{"tool":50,"command":51},"pnpm","pnpm dlx skills add ComeOnOliver\u002Fskillshub --skill csharp-concurrency-patterns","安装技能，技能地址：https:\u002F\u002Fgithub.com\u002FComeOnOliver\u002Fskillshub\u002Fblob\u002Fmain\u002Fskills\u002FAaronontheweb\u002Fdotnet-skills\u002Fcsharp-concurrency-patterns\u002FSKILL.md",true,[55,61,65,69,73,77,83],{"path":56,"resourceType":57,"resourceTypeDesc":58,"sizeBytes":59,"sourceHtmlUrl":60},"scripts\u002Fframe-template.html","SCRIPT","脚本",8094,"https:\u002F\u002Fgithub.com\u002FdevelopAgent\u002Fbmad-start\u002Fblob\u002Fmain\u002F.agents\u002Fskills\u002Fbrainstorming\u002Fscripts\u002Fframe-template.html",{"path":62,"resourceType":57,"resourceTypeDesc":58,"sizeBytes":63,"sourceHtmlUrl":64},"scripts\u002Fhelper.js",5615,"https:\u002F\u002Fgithub.com\u002FdevelopAgent\u002Fbmad-start\u002Fblob\u002Fmain\u002F.agents\u002Fskills\u002Fbrainstorming\u002Fscripts\u002Fhelper.js",{"path":66,"resourceType":57,"resourceTypeDesc":58,"sizeBytes":67,"sourceHtmlUrl":68},"scripts\u002Fserver.cjs",25693,"https:\u002F\u002Fgithub.com\u002FdevelopAgent\u002Fbmad-start\u002Fblob\u002Fmain\u002F.agents\u002Fskills\u002Fbrainstorming\u002Fscripts\u002Fserver.cjs",{"path":70,"resourceType":57,"resourceTypeDesc":58,"sizeBytes":71,"sourceHtmlUrl":72},"scripts\u002Fstart-server.sh",6908,"https:\u002F\u002Fgithub.com\u002FdevelopAgent\u002Fbmad-start\u002Fblob\u002Fmain\u002F.agents\u002Fskills\u002Fbrainstorming\u002Fscripts\u002Fstart-server.sh",{"path":74,"resourceType":57,"resourceTypeDesc":58,"sizeBytes":75,"sourceHtmlUrl":76},"scripts\u002Fstop-server.sh",3263,"https:\u002F\u002Fgithub.com\u002FdevelopAgent\u002Fbmad-start\u002Fblob\u002Fmain\u002F.agents\u002Fskills\u002Fbrainstorming\u002Fscripts\u002Fstop-server.sh",{"path":78,"resourceType":79,"resourceTypeDesc":80,"sizeBytes":81,"sourceHtmlUrl":82},"spec-document-reviewer-prompt.md","REFERENCE","参考文档",1747,"https:\u002F\u002Fgithub.com\u002FdevelopAgent\u002Fbmad-start\u002Fblob\u002Fmain\u002F.agents\u002Fskills\u002Fbrainstorming\u002Fspec-document-reviewer-prompt.md",{"path":84,"resourceType":79,"resourceTypeDesc":80,"sizeBytes":85,"sourceHtmlUrl":86},"visual-companion.md",13298,"https:\u002F\u002Fgithub.com\u002FdevelopAgent\u002Fbmad-start\u002Fblob\u002Fmain\u002F.agents\u002Fskills\u002Fbrainstorming\u002Fvisual-companion.md",[88,102,112,121,127,134],{"skillNo":89,"name":90,"nameZh":6,"description":6,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":91,"categories":92,"keywords":98,"publishedAt":27},"01M6FKJN13GMG4KY57J3QD8GY5","model-hierarchy-skill","https:\u002F\u002Fgithub.com\u002FComeOnOliver\u002Fskillshub\u002Fblob\u002Fmain\u002Fskills\u002Fzscole\u002Fmodel-hierarchy-skill\u002Fmodel-hierarchy-skill\u002FSKILL.md",[93],{"categoryNo":94,"categoryName":95,"taxonomyType":96,"taxonomyTypeDesc":97},"01JBSEEDCAT000000000000023","Skill与智能体开发","SCENARIO","使用场景",[99,100,101],"model","model hierarchy","model hierarchy skill",{"skillNo":103,"name":104,"nameZh":6,"description":6,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":105,"categories":106,"keywords":108,"publishedAt":27},"01M6FKJJJ6GCAMR4PPPRD12M5X","zoom-mcp","https:\u002F\u002Fgithub.com\u002FComeOnOliver\u002Fskillshub\u002Fblob\u002Fmain\u002Fskills\u002Fzoom\u002Fskills\u002Fzoom-mcp\u002FSKILL.md",[107],{"categoryNo":94,"categoryName":95,"taxonomyType":96,"taxonomyTypeDesc":97},[109,110,111],"MCP","zoom","zoom mcp",{"skillNo":113,"name":114,"nameZh":6,"description":6,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":115,"categories":116,"keywords":117,"publishedAt":27},"01M6FKJE3KYT3KPEZMEEHYKA6K","zoom-apps-sdk","https:\u002F\u002Fgithub.com\u002FComeOnOliver\u002Fskillshub\u002Fblob\u002Fmain\u002Fskills\u002Fzoom\u002Fskills\u002Fzoom-apps-sdk\u002FSKILL.md",[],[118,119,120,110],"sdk","zoom apps sdk","apps",{"skillNo":122,"name":123,"nameZh":6,"description":6,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":124,"categories":125,"keywords":126,"publishedAt":27},"01M6FKJ9EDH9Q5VWDF8HAJRSP0","windows","https:\u002F\u002Fgithub.com\u002FComeOnOliver\u002Fskillshub\u002Fblob\u002Fmain\u002Fskills\u002Fzoom\u002Fskills\u002Fwindows\u002FSKILL.md",[],[123],{"skillNo":128,"name":129,"nameZh":6,"description":6,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":130,"categories":131,"keywords":133,"publishedAt":27},"01M6FKJ666BEEFC3AE9GJ72Q93","whiteboard","https:\u002F\u002Fgithub.com\u002FComeOnOliver\u002Fskillshub\u002Fblob\u002Fmain\u002Fskills\u002Fzoom\u002Fskills\u002Fwhiteboard\u002FSKILL.md",[132],{"categoryNo":94,"categoryName":95,"taxonomyType":96,"taxonomyTypeDesc":97},[129],{"skillNo":135,"name":136,"nameZh":6,"description":6,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":137,"categories":138,"keywords":139,"publishedAt":27},"01M6FKJ21WFCDGTJQ2Q91T9DVW","websockets","https:\u002F\u002Fgithub.com\u002FComeOnOliver\u002Fskillshub\u002Fblob\u002Fmain\u002Fskills\u002Fzoom\u002Fskills\u002Fwebsockets\u002FSKILL.md",[],[136]]