[{"data":1,"prerenderedAt":-1},["ShallowReactive",2],{"skill:01M751FT75EZGRXQQZQ2Z2018N":3,"skill-same:01M751FT75EZGRXQQZQ2Z2018N":49},{"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":26,"commitSha":27,"skillDirectory":28,"forksCount":29,"repositoryHtmlUrl":30,"repositoryHomepageUrl":31,"ownerHtmlUrl":32,"ownerBlogUrl":31,"ownerDescription":33,"updatedAt":34,"install":35,"resources":48},"01M751FT75EZGRXQQZQ2Z2018N","python-async",null,"Writes and reviews correct asyncio code - structured concurrency with TaskGroup, gather vs create_task decisions, cancellation and timeout handling, bridging blocking code with to_thread, and bounded parallelism - with good\u002Fbad pairs for the pitfalls that silently freeze the event loop. Use when someone asks \"why is my async code slow\", \"gather or create_task\", \"how do I run these requests concurrently\", \"my FastAPI endpoint blocks everything\", or is converting sync Python to asyncio. Do NOT use for general pandas or data-analysis performance - use pandas-expert instead - and do NOT use for API endpoint design itself - use api-design instead.","SkillMedev\u002Fskills","SkillMedev","https:\u002F\u002Favatars.githubusercontent.com\u002Fu\u002F298078254?v=4","01M74ZSGTQ918CB0VXW4EG3RMX","SkillMe","01M74ZSGVBT497NA95CBT8JTY4",25,"MIT","https:\u002F\u002Fgithub.com\u002FSkillMedev\u002Fskills\u002Fblob\u002Fmain\u002Fskills\u002Fpython-async\u002FSKILL.md",[],[],"2026-11-11 18:15:31",false,"---\nname: python-async\ndescription: Writes and reviews correct asyncio code - structured concurrency with TaskGroup, gather vs create_task decisions, cancellation and timeout handling, bridging blocking code with to_thread, and bounded parallelism - with good\u002Fbad pairs for the pitfalls that silently freeze the event loop. Use when someone asks \"why is my async code slow\", \"gather or create_task\", \"how do I run these requests concurrently\", \"my FastAPI endpoint blocks everything\", or is converting sync Python to asyncio. Do NOT use for general pandas or data-analysis performance - use pandas-expert instead - and do NOT use for API endpoint design itself - use api-design instead.\nmetadata:\n  title: \"Python Async\"\n---\n\n# Python Async\n\nAsyncio gives one thread the throughput of hundreds of connections, but only if nothing on the event loop ever blocks - a single stray `time.sleep` or `requests.get` freezes every coroutine in the process. The costly mistakes this skill prevents are the silent ones: code that runs correctly but sequentially (awaiting in a loop), tasks that vanish mid-flight (un-referenced fire-and-forget), and a \"fast\" service whose p99 collapses because one handler does CPU work on the loop.\n\n## Mental model\n\nOne event loop runs many coroutines cooperatively on a single thread. `await` is the only place control can switch; between awaits, your code has an exclusive lock on the whole process. Concurrency comes from running tasks, not from awaiting sequentially - `await a(); await b()` is exactly as slow as sync code.\n\n## Operating procedure\n\n### Step 1: Gather inputs\n\n1. Python version - 3.11+ unlocks `TaskGroup` and `asyncio.timeout`; below that, use `gather` and `wait_for`.\n2. The workload type per operation: network I\u002FO (async-friendly), disk\u002Fblocking-library I\u002FO (needs `to_thread`), or CPU-bound (needs a process pool).\n3. Every library on the I\u002FO path, checked for an async API: `httpx`\u002F`aiohttp` not `requests`, `asyncpg` not `psycopg2`, `asyncio.sleep` not `time.sleep`. If unsure whether a call blocks, treat it as blocking.\n4. The concurrency target and the downstream limits (DB pool size, API rate limits).\n\n### Step 2: Choose the concurrency primitive\n\n- Known, finite set of operations that should all complete or all fail together: `asyncio.TaskGroup` (3.11+). It cancels siblings on failure and propagates exceptions as a group - the structured default.\n- Need the list of results in order, possibly tolerating individual failures: `asyncio.gather(..., return_exceptions=True)`, then check each result for an exception.\n- Background work that outlives the current function (consumers, listeners): `asyncio.create_task`, and store the reference - the loop holds tasks weakly, so an unreferenced task can be garbage-collected mid-flight. Keep a set, add a done-callback that logs exceptions and discards the task.\n- Decision rule: `gather`\u002F`TaskGroup` when the caller waits for the results here; `create_task` only when the work genuinely detaches from the current scope.\n\n```python\nimport asyncio\n\nasync def main():\n    async with asyncio.TaskGroup() as tg:\n        t1 = tg.create_task(fetch(url1))\n        t2 = tg.create_task(fetch(url2))\n    # both done here; any failure cancelled the sibling and raised\n\nasyncio.run(main())\n```\n\n### Step 3: Bound the parallelism\n\nUnbounded fan-out is a self-inflicted DDoS on your own database or a partner API.\n\n- `asyncio.Semaphore(n)` around the operation, with n sized to the bottleneck (e.g. DB pool size minus headroom, or the API's rate limit).\n- For pipelines, a bounded `asyncio.Queue(maxsize=...)` between producer and consumers - the maxsize is your backpressure.\n\n### Step 4: Keep blocking work off the loop\n\n- Blocking I\u002FO (sync drivers, file reads, DNS in odd libraries): `await asyncio.to_thread(blocking_fn, arg)`.\n- CPU-bound work (parsing, crypto, image processing): `ProcessPoolExecutor` via `loop.run_in_executor` - threads don't help CPU work under the GIL.\n- Rule of thumb: anything that could hold the loop for more than ~50ms doesn't belong on it.\n- Call async from sync only at the top level via `asyncio.run`; never nest event loops.\n\n### Step 5: Handle cancellation and timeouts deliberately\n\n- Every external await gets a timeout: `async with asyncio.timeout(5):` (3.11+) or `asyncio.wait_for`. Untimed awaits are where services hang forever.\n- Cancellation raises `CancelledError` at the next await point. Never swallow it - catch, clean up in `try\u002Ffinally`, re-raise.\n- `asyncio.shield` only for genuinely must-finish work (e.g. committing a payment record), and sparingly - shielded work outlives its caller.\n\n### Step 6: Verify under the debug loop\n\nRun tests with `PYTHONASYNCIODEBUG=1` (or `loop.set_debug(True)`): it reports coroutines never awaited and callbacks that held the loop longer than 100ms - the two failure classes that are invisible in normal runs. Use `async with`\u002F`async for` for async context managers and iterators; a bare `with` around an async resource leaks it.\n\n## Worked artifact: the three classic bugs, bad\u002Fgood\n\nBad - sequential awaits masquerading as concurrency; blocking call on the loop; lost task:\n\n```python\nasync def handler(urls):\n    results = []\n    for u in urls:                      # runs one at a time\n        results.append(await fetch(u))\n    data = requests.get(META_URL)       # freezes the entire event loop\n    asyncio.create_task(audit_log(data))  # unreferenced: may vanish silently\n    return results\n```\n\nGood:\n\n```python\nimport asyncio, httpx\n\n_background: set[asyncio.Task] = set()\n\ndef spawn(coro):\n    t = asyncio.create_task(coro)\n    _background.add(t)\n    t.add_done_callback(lambda t: (_background.discard(t),\n        t.exception() and log.error(\"bg task failed\", exc_info=t.exception())))\n    return t\n\nasync def handler(urls, client: httpx.AsyncClient):\n    sem = asyncio.Semaphore(10)         # bounded fan-out\n    async def bounded(u):\n        async with sem:\n            async with asyncio.timeout(5):\n                return await fetch(client, u)\n    async with asyncio.TaskGroup() as tg:\n        tasks = [tg.create_task(bounded(u)) for u in urls]\n    data = await client.get(META_URL)   # async client, not requests\n    spawn(audit_log(data))              # referenced, exceptions logged\n    return [t.result() for t in tasks]\n```\n\n## Deliverable\n\nProduce working async code (or a review) in which every concurrent operation uses the right primitive with a one-line justification, every external await has a timeout, fan-out is bounded with a number tied to the downstream limit, no blocking call runs on the loop, and background tasks are referenced with exception logging.\n\n## Do NOT\n\n- Do not call blocking I\u002FO (`requests`, `time.sleep`, sync DB drivers) inside a coroutine - one call stalls every request in the process.\n- Do not await in a loop when the operations are independent; that is sync code with extra syntax.\n- Do not fire-and-forget with a bare `create_task` - hold the reference and log its exceptions.\n- Do not swallow `CancelledError`; it breaks timeouts and shutdown for everything above you.\n- Do not use threads for CPU-bound work - the GIL makes that a no-op; use a process pool.\n- Do not create event loops manually or nest `asyncio.run`; one loop, entered once at the top.\n- Do not fan out unbounded to a database or API; size a semaphore to the real limit.\n\n## Quality bar\n\n- Every `await` on an external system sits under an explicit timeout.\n- `gather` vs `TaskGroup` vs `create_task` choice is justified per call site.\n- Grep for `requests.`, `time.sleep`, and sync DB drivers inside `async def` comes back empty.\n- Concurrency bounds are numbers with a stated source, not defaults.\n- The test suite passes with `PYTHONASYNCIODEBUG=1` and no slow-callback warnings.\n\n## Escalation\n\nFor the HTTP API's shape rather than its concurrency, use api-design. For rate-limit handling strategy against third parties, pair with rate-limit-handler. Queue-based cross-service pipelines belong to kafka-pipelines.\n","# Python Async\n\nAsyncio gives one thread the throughput of hundreds of connections, but only if nothing on the event loop ever blocks - a single stray `time.sleep` or `requests.get` freezes every coroutine in the process. The costly mistakes this skill prevents are the silent ones: code that runs correctly but sequentially (awaiting in a loop), tasks that vanish mid-flight (un-referenced fire-and-forget), and a \"fast\" service whose p99 collapses because one handler does CPU work on the loop.\n\n## Mental model\n\nOne event loop runs many coroutines cooperatively on a single thread. `await` is the only place control can switch; between awaits, your code has an exclusive lock on the whole process. Concurrency comes from running tasks, not from awaiting sequentially - `await a(); await b()` is exactly as slow as sync code.\n\n## Operating procedure\n\n### Step 1: Gather inputs\n\n1. Python version - 3.11+ unlocks `TaskGroup` and `asyncio.timeout`; below that, use `gather` and `wait_for`.\n2. The workload type per operation: network I\u002FO (async-friendly), disk\u002Fblocking-library I\u002FO (needs `to_thread`), or CPU-bound (needs a process pool).\n3. Every library on the I\u002FO path, checked for an async API: `httpx`\u002F`aiohttp` not `requests`, `asyncpg` not `psycopg2`, `asyncio.sleep` not `time.sleep`. If unsure whether a call blocks, treat it as blocking.\n4. The concurrency target and the downstream limits (DB pool size, API rate limits).\n\n### Step 2: Choose the concurrency primitive\n\n- Known, finite set of operations that should all complete or all fail together: `asyncio.TaskGroup` (3.11+). It cancels siblings on failure and propagates exceptions as a group - the structured default.\n- Need the list of results in order, possibly tolerating individual failures: `asyncio.gather(..., return_exceptions=True)`, then check each result for an exception.\n- Background work that outlives the current function (consumers, listeners): `asyncio.create_task`, and store the reference - the loop holds tasks weakly, so an unreferenced task can be garbage-collected mid-flight. Keep a set, add a done-callback that logs exceptions and discards the task.\n- Decision rule: `gather`\u002F`TaskGroup` when the caller waits for the results here; `create_task` only when the work genuinely detaches from the current scope.\n\n```python\nimport asyncio\n\nasync def main():\n    async with asyncio.TaskGroup() as tg:\n        t1 = tg.create_task(fetch(url1))\n        t2 = tg.create_task(fetch(url2))\n    # both done here; any failure cancelled the sibling and raised\n\nasyncio.run(main())\n```\n\n### Step 3: Bound the parallelism\n\nUnbounded fan-out is a self-inflicted DDoS on your own database or a partner API.\n\n- `asyncio.Semaphore(n)` around the operation, with n sized to the bottleneck (e.g. DB pool size minus headroom, or the API's rate limit).\n- For pipelines, a bounded `asyncio.Queue(maxsize=...)` between producer and consumers - the maxsize is your backpressure.\n\n### Step 4: Keep blocking work off the loop\n\n- Blocking I\u002FO (sync drivers, file reads, DNS in odd libraries): `await asyncio.to_thread(blocking_fn, arg)`.\n- CPU-bound work (parsing, crypto, image processing): `ProcessPoolExecutor` via `loop.run_in_executor` - threads don't help CPU work under the GIL.\n- Rule of thumb: anything that could hold the loop for more than ~50ms doesn't belong on it.\n- Call async from sync only at the top level via `asyncio.run`; never nest event loops.\n\n### Step 5: Handle cancellation and timeouts deliberately\n\n- Every external await gets a timeout: `async with asyncio.timeout(5):` (3.11+) or `asyncio.wait_for`. Untimed awaits are where services hang forever.\n- Cancellation raises `CancelledError` at the next await point. Never swallow it - catch, clean up in `try\u002Ffinally`, re-raise.\n- `asyncio.shield` only for genuinely must-finish work (e.g. committing a payment record), and sparingly - shielded work outlives its caller.\n\n### Step 6: Verify under the debug loop\n\nRun tests with `PYTHONASYNCIODEBUG=1` (or `loop.set_debug(True)`): it reports coroutines never awaited and callbacks that held the loop longer than 100ms - the two failure classes that are invisible in normal runs. Use `async with`\u002F`async for` for async context managers and iterators; a bare `with` around an async resource leaks it.\n\n## Worked artifact: the three classic bugs, bad\u002Fgood\n\nBad - sequential awaits masquerading as concurrency; blocking call on the loop; lost task:\n\n```python\nasync def handler(urls):\n    results = []\n    for u in urls:                      # runs one at a time\n        results.append(await fetch(u))\n    data = requests.get(META_URL)       # freezes the entire event loop\n    asyncio.create_task(audit_log(data))  # unreferenced: may vanish silently\n    return results\n```\n\nGood:\n\n```python\nimport asyncio, httpx\n\n_background: set[asyncio.Task] = set()\n\ndef spawn(coro):\n    t = asyncio.create_task(coro)\n    _background.add(t)\n    t.add_done_callback(lambda t: (_background.discard(t),\n        t.exception() and log.error(\"bg task failed\", exc_info=t.exception())))\n    return t\n\nasync def handler(urls, client: httpx.AsyncClient):\n    sem = asyncio.Semaphore(10)         # bounded fan-out\n    async def bounded(u):\n        async with sem:\n            async with asyncio.timeout(5):\n                return await fetch(client, u)\n    async with asyncio.TaskGroup() as tg:\n        tasks = [tg.create_task(bounded(u)) for u in urls]\n    data = await client.get(META_URL)   # async client, not requests\n    spawn(audit_log(data))              # referenced, exceptions logged\n    return [t.result() for t in tasks]\n```\n\n## Deliverable\n\nProduce working async code (or a review) in which every concurrent operation uses the right primitive with a one-line justification, every external await has a timeout, fan-out is bounded with a number tied to the downstream limit, no blocking call runs on the loop, and background tasks are referenced with exception logging.\n\n## Do NOT\n\n- Do not call blocking I\u002FO (`requests`, `time.sleep`, sync DB drivers) inside a coroutine - one call stalls every request in the process.\n- Do not await in a loop when the operations are independent; that is sync code with extra syntax.\n- Do not fire-and-forget with a bare `create_task` - hold the reference and log its exceptions.\n- Do not swallow `CancelledError`; it breaks timeouts and shutdown for everything above you.\n- Do not use threads for CPU-bound work - the GIL makes that a no-op; use a process pool.\n- Do not create event loops manually or nest `asyncio.run`; one loop, entered once at the top.\n- Do not fan out unbounded to a database or API; size a semaphore to the real limit.\n\n## Quality bar\n\n- Every `await` on an external system sits under an explicit timeout.\n- `gather` vs `TaskGroup` vs `create_task` choice is justified per call site.\n- Grep for `requests.`, `time.sleep`, and sync DB drivers inside `async def` comes back empty.\n- Concurrency bounds are numbers with a stated source, not defaults.\n- The test suite passes with `PYTHONASYNCIODEBUG=1` and no slow-callback warnings.\n\n## Escalation\n\nFor the HTTP API's shape rather than its concurrency, use api-design. For rate-limit handling strategy against third parties, pair with rate-limit-handler. Queue-based cross-service pipelines belong to kafka-pipelines.\n",{"name":5,"metadata":24,"description":7},{"title":25},"Python Async","main","97a13607d669157a4a16d5ba79b77f208319f7b9","skills\u002Fpython-async",3,"https:\u002F\u002Fgithub.com\u002FSkillMedev\u002Fskills","https:\u002F\u002Fskillme.dev","https:\u002F\u002Fgithub.com\u002FSkillMedev","MCP-native catalog of Claude Agent Skills. Browse, recommend, install, and auto-apply skills in chat. Open source, every skill free and clonable on GitHub.","2026-10-14 03:19:31",{"source":8,"skillName":5,"commands":36,"prompt":46,"zipAvailable":47},[37,40,43],{"tool":38,"command":39},"npx","npx skills add SkillMedev\u002Fskills --skill python-async",{"tool":41,"command":42},"bunx","bunx skills add SkillMedev\u002Fskills --skill python-async",{"tool":44,"command":45},"pnpm","pnpm dlx skills add SkillMedev\u002Fskills --skill python-async","安装技能，技能地址：https:\u002F\u002Fgithub.com\u002FSkillMedev\u002Fskills\u002Fblob\u002Fmain\u002Fskills\u002Fpython-async\u002FSKILL.md",true,[],[50,60,67,74,81,88],{"skillNo":51,"name":52,"nameZh":53,"description":54,"descriptionZh":55,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":56,"categories":57,"keywords":58,"publishedAt":59},"01M75271B256DF3FX2VG5VRYEE","zone-2-cardio-plan","有氧运动计划","Use when someone asks to build a steady-state cardio plan, train an aerobic base or Zone 2, structure easy or endurance weekly cardio, train by heart-rate zones, or improve resting heart rate, VO2, or endurance. Builds a heart-rate-zone aerobic training block with session structure, modality choice, and progression. General fitness guidance, not medical advice. Do NOT use to design a strength or lifting program (use Strength Training Plan), high-intensity interval conditioning, HIIT, or circuits (use Conditioning & HIIT Program), or a mobility\u002Fflexibility routine (use Mobility Routine).","当有人要求制定稳态有氧训练计划、进行有氧基础训练或达到第二区间、安排轻松或耐力型的每周有氧训练、按心率区间训练，或提高静息心率、最大摄氧量或耐力时，可以使用此方案。该方案构建了一个包含训练计划结构、训练方式选择和进度安排的心率区间有氧训练模块。本方案仅提供一般健身指导，不构成医疗建议。请勿用于设计力量或举重训练计划（请使用力量训练计划）、高强度间歇训练 (HIIT) 或循环训练（请使用体能训练和 HIIT 计划），或灵活性\u002F柔韧性训练（请使用灵活性训练计划）。","https:\u002F\u002Fgithub.com\u002FSkillMedev\u002Fskills\u002Fblob\u002Fmain\u002Fskills\u002Fzone-2-cardio-plan\u002FSKILL.md",[],[],"2026-11-11 18:27:18",{"skillNo":61,"name":62,"nameZh":6,"description":63,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":64,"categories":65,"keywords":66,"publishedAt":59},"01M7526VP1QBBKYBE17S1WR86Y","youtube-script-writer","Writes retention-engineered long-form YouTube scripts on a hook\u002Fbody\u002Fpayoff architecture - a first-30-seconds hook that survives the retention cliff, a beat-sheet body with mini-hooks and bridges, timed pattern interrupts, and a payoff that over-delivers - with B-roll and editing cues marked inline. Use when someone says \"script my next video\", \"my retention graph dies at the start\", \"tighten this draft\", or \"outline a video on X\". Do NOT use for the 3-second opener of TikTok, Reels, or Shorts - use video-hook-writer instead; do NOT use for spoken voiceover synced to on-screen tutorial actions - use narration-script instead; do NOT use for a sales demo built on a buyer's discovery notes - use demo-script instead; do NOT use to design the thumbnail and title - use thumbnail-concept instead.","https:\u002F\u002Fgithub.com\u002FSkillMedev\u002Fskills\u002Fblob\u002Fmain\u002Fskills\u002Fyoutube-script-writer\u002FSKILL.md",[],[],{"skillNo":68,"name":69,"nameZh":6,"description":70,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":71,"categories":72,"keywords":73,"publishedAt":59},"01M7526P2T0WKMHDXS4Q58237T","win-back-campaign","Designs segmented win-back email sequences for dormant users - dormancy tiers, a three-beat sequence with a single proportional incentive, and a suppression rule - and measures success by re-activation, not opens. Use when someone says \"our users went quiet\", \"design a win-back campaign\", \"how do I re-engage lapsed customers\", \"should we email people who haven't logged in for months\", or lifecycle messaging has stopped landing with a lapsed segment. Do NOT use for recovering an unfinished checkout - use abandoned-cart-sequence instead. Do NOT use for diagnosing and fixing why active customers cancel - use churn-reduction instead. Do NOT use for building always-on onboarding or nurture flows - use email-drip-builder instead.","https:\u002F\u002Fgithub.com\u002FSkillMedev\u002Fskills\u002Fblob\u002Fmain\u002Fskills\u002Fwin-back-campaign\u002FSKILL.md",[],[],{"skillNo":75,"name":76,"nameZh":6,"description":77,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":78,"categories":79,"keywords":80,"publishedAt":59},"01M7526HF2RCDJ50P93WRZRHVV","wikipedia-style","Writes neutral, verifiable, encyclopedic prose following Wikipedia's core content policies and manual of style - NPOV, inline citations, notability-backed claims, and a strict ban on promotional language. Use when someone asks \"write this like a Wikipedia article\", \"draft a Wikipedia page for this company or person\", \"make this neutral and encyclopedic\", or \"why does my article draft keep getting rejected\". Do NOT use for persuasive or opinion writing - use op-ed-writer instead; for thesis-driven academic papers, use academic-essay; for verifying claims in existing text, use fact-checker.","https:\u002F\u002Fgithub.com\u002FSkillMedev\u002Fskills\u002Fblob\u002Fmain\u002Fskills\u002Fwikipedia-style\u002FSKILL.md",[],[],{"skillNo":82,"name":83,"nameZh":6,"description":84,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":85,"categories":86,"keywords":87,"publishedAt":59},"01M7526D43CTGRKGKNQ2GB0KVX","whitepapers","Structures and writes authoritative B2B whitepapers - a standalone executive summary, a data-sized problem statement, methodology, evidence-driven findings, recommendations, and a soft call to action - flagging every claim that needs a real citation. Use when a marketer asks \"write a whitepaper on this topic\", \"turn our research into a lead-gen asset\", \"make this credible enough for executives\", or a draft reads like a product pitch instead of analysis. Do NOT use for customer-story-driven proof - use case-study-builder instead; for policy audiences, use policy-brief.","https:\u002F\u002Fgithub.com\u002FSkillMedev\u002Fskills\u002Fblob\u002Fmain\u002Fskills\u002Fwhitepapers\u002FSKILL.md",[],[],{"skillNo":89,"name":90,"nameZh":6,"description":91,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":92,"categories":93,"keywords":94,"publishedAt":59},"01M75268423Y3K50SY5WC2NX2G","white-space-analysis","Finds unmet market gaps by ranking jobs-to-be-done on importance versus satisfaction, overlaying them against current solutions and workarounds, and validating that each gap is real, winnable, and worth winning. Use when someone asks \"where are the gaps in this market\", \"what's underserved here\", \"where should we play next\", or is hunting for product, feature, or market-entry opportunities. Do NOT use for profiling competitors and building battle cards - use competitive-intelligence instead; for putting a dollar figure on an identified opportunity - use market-sizing instead; for extracting jobs-to-be-done from raw customer interviews - use jtbd-extractor instead.","https:\u002F\u002Fgithub.com\u002FSkillMedev\u002Fskills\u002Fblob\u002Fmain\u002Fskills\u002Fwhite-space-analysis\u002FSKILL.md",[],[]]