[{"data":1,"prerenderedAt":-1},["ShallowReactive",2],{"skill:01M7BX6PSJ41JM8D95MDABZ69B":3,"skill-same:01M7BX6PSJ41JM8D95MDABZ69B":51},{"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":6,"ownerDescription":6,"updatedAt":30,"install":31,"resources":44},"01M7BX6PSJ41JM8D95MDABZ69B","workload-balancing",null,"Optimize workload distribution across workers, processes, or nodes for efficient parallel execution. Use when asked to balance work distribution, improve parallel efficiency, reduce stragglers, implement load balancing, or optimize task scheduling. Covers static\u002Fdynamic partitioning, work stealing, and adaptive load balancing strategies.","linyouxue\u002Fskill-repair-benchmark","linyouxue","https:\u002F\u002Favatars.githubusercontent.com\u002Fu\u002F216151464?v=4","01M7BJEVCXKD74KH6FG9CBVSQB","林宥学","01M7BJEVE02NP217V93BKZFC0J",0,"Apache-2.0","https:\u002F\u002Fgithub.com\u002Flinyouxue\u002Fskill-repair-benchmark\u002Fblob\u002Fmain\u002Fevaluation\u002Fresults\u002FOpus47-OriginalSkill-79Tasks-20260920\u002Fruns\u002Fopus47-original-skill\u002Fparallel-tfidf-search-opus47-original-skill-r001\u002Finputs\u002Fskills\u002Fworkload-balancing\u002FSKILL.md",[],[],"2026-11-15 14:19:17",false,"---\nname: workload-balancing\ndescription: Optimize workload distribution across workers, processes, or nodes for efficient parallel execution. Use when asked to balance work distribution, improve parallel efficiency, reduce stragglers, implement load balancing, or optimize task scheduling. Covers static\u002Fdynamic partitioning, work stealing, and adaptive load balancing strategies.\n---\n\n# Workload Balancing Skill\n\nDistribute work efficiently across parallel workers to maximize throughput and minimize completion time.\n\n## Workflow\n\n1. **Characterize** the workload (uniform vs. variable task times)\n2. **Identify** bottlenecks (stragglers, uneven distribution)\n3. **Select** balancing strategy based on workload characteristics\n4. **Implement** partitioning and scheduling logic\n5. **Monitor** and adapt to runtime conditions\n\n## Load Balancing Decision Tree\n\n```\nWhat's the workload characteristic?\n\nUniform task times:\n├── Known count → Static partitioning (equal chunks)\n├── Streaming input → Round-robin distribution\n└── Large items → Size-aware partitioning\n\nVariable task times:\n├── Predictable variance → Weighted distribution\n├── Unpredictable → Dynamic scheduling \u002F work stealing\n└── Long-tail distribution → Work stealing + time limits\n\nResource constraints:\n├── Memory-bound workers → Memory-aware assignment\n├── Heterogeneous workers → Capability-based routing\n└── Network costs → Locality-aware placement\n```\n\n## Balancing Strategies\n\n### Strategy 1: Static Chunking (Uniform Workloads)\n\nBest for: predictable, similar-sized tasks\n\n```python\nfrom concurrent.futures import ProcessPoolExecutor\nimport numpy as np\n\ndef static_balanced_process(items, num_workers=4):\n    \"\"\"Divide work into equal chunks upfront.\"\"\"\n    chunks = np.array_split(items, num_workers)\n\n    with ProcessPoolExecutor(max_workers=num_workers) as executor:\n        results = list(executor.map(process_chunk, chunks))\n\n    return [item for chunk_result in results for item in chunk_result]\n```\n\n### Strategy 2: Dynamic Task Queue (Variable Workloads)\n\nBest for: unpredictable task durations\n\n```python\nfrom concurrent.futures import ProcessPoolExecutor, as_completed\nfrom queue import Queue\n\ndef dynamic_balanced_process(items, num_workers=4):\n    \"\"\"Workers pull tasks dynamically as they complete.\"\"\"\n    results = []\n\n    with ProcessPoolExecutor(max_workers=num_workers) as executor:\n        # Submit one task per worker initially\n        futures = {executor.submit(process_item, item): item\n                   for item in items[:num_workers]}\n        pending = list(items[num_workers:])\n\n        while futures:\n            done, _ = wait(futures, return_when=FIRST_COMPLETED)\n\n            for future in done:\n                results.append(future.result())\n                del futures[future]\n\n                # Submit next task if available\n                if pending:\n                    next_item = pending.pop(0)\n                    futures[executor.submit(process_item, next_item)] = next_item\n\n    return results\n```\n\n### Strategy 3: Work Stealing (Long-Tail Tasks)\n\nBest for: when some tasks take much longer than others\n\n```python\nimport asyncio\nfrom collections import deque\n\nclass WorkStealingPool:\n    def __init__(self, num_workers):\n        self.queues = [deque() for _ in range(num_workers)]\n        self.num_workers = num_workers\n\n    def distribute(self, items):\n        \"\"\"Initial round-robin distribution.\"\"\"\n        for i, item in enumerate(items):\n            self.queues[i % self.num_workers].append(item)\n\n    async def worker(self, worker_id, process_fn):\n        \"\"\"Process own queue, steal from others when empty.\"\"\"\n        while True:\n            # Try own queue first\n            if self.queues[worker_id]:\n                item = self.queues[worker_id].popleft()\n            else:\n                # Steal from busiest queue\n                item = self._steal_work(worker_id)\n                if item is None:\n                    break\n\n            await process_fn(item)\n\n    def _steal_work(self, worker_id):\n        \"\"\"Steal from the queue with most items.\"\"\"\n        busiest = max(range(self.num_workers),\n                      key=lambda i: len(self.queues[i]) if i != worker_id else 0)\n        if self.queues[busiest]:\n            return self.queues[busiest].pop()  # Steal from end\n        return None\n```\n\n### Strategy 4: Weighted Distribution\n\nBest for: when task costs are known or estimable\n\n```python\ndef weighted_partition(items, weights, num_workers):\n    \"\"\"Partition items to balance total weight per worker.\"\"\"\n    # Sort by weight descending (largest first fit)\n    sorted_items = sorted(zip(items, weights), key=lambda x: -x[1])\n\n    worker_loads = [0] * num_workers\n    worker_items = [[] for _ in range(num_workers)]\n\n    for item, weight in sorted_items:\n        # Assign to least loaded worker\n        min_worker = min(range(num_workers), key=lambda i: worker_loads[i])\n        worker_items[min_worker].append(item)\n        worker_loads[min_worker] += weight\n\n    return worker_items\n```\n\n### Strategy 5: Async Semaphore Balancing (I\u002FO Workloads)\n\nBest for: limiting concurrent I\u002FO operations\n\n```python\nimport asyncio\n\nasync def semaphore_balanced_fetch(urls, max_concurrent=10):\n    \"\"\"Limit concurrent operations while processing queue.\"\"\"\n    semaphore = asyncio.Semaphore(max_concurrent)\n\n    async def bounded_fetch(url):\n        async with semaphore:\n            return await fetch(url)\n\n    return await asyncio.gather(*[bounded_fetch(url) for url in urls])\n```\n\n## Partitioning Strategies\n\n| Strategy | Best For | Implementation |\n|----------|----------|----------------|\n| Equal chunks | Uniform tasks | `np.array_split(items, n)` |\n| Round-robin | Streaming | `items[i::n_workers]` |\n| Size-weighted | Known sizes | Bin packing algorithm |\n| Hash-based | Consistent routing | `hash(key) % n_workers` |\n| Range-based | Sorted\u002Fordered data | Contiguous ranges |\n\n## Handling Stragglers\n\nTechniques to mitigate slow workers:\n\n```python\n# 1. Timeout with fallback\nfrom concurrent.futures import TimeoutError\n\ntry:\n    result = future.result(timeout=30)\nexcept TimeoutError:\n    result = fallback_value\n\n# 2. Speculative execution (backup tasks)\nasync def speculative_execute(task, timeout=10):\n    primary = asyncio.create_task(execute(task))\n    try:\n        return await asyncio.wait_for(primary, timeout)\n    except asyncio.TimeoutError:\n        backup = asyncio.create_task(execute(task))  # Retry\n        done, pending = await asyncio.wait(\n            [primary, backup], return_when=asyncio.FIRST_COMPLETED\n        )\n        for p in pending:\n            p.cancel()\n        return done.pop().result()\n\n# 3. Dynamic rebalancing\ndef rebalance_on_straggler(futures, threshold_ratio=2.0):\n    \"\"\"Redistribute work if one worker falls behind.\"\"\"\n    avg_completion = statistics.mean(completion_times)\n    for future, worker_id in futures.items():\n        if future.running() and elapsed(future) > threshold_ratio * avg_completion:\n            # Cancel and redistribute\n            remaining_work = cancel_and_get_remaining(future)\n            redistribute(remaining_work, fast_workers)\n```\n\n## Monitoring Metrics\n\nTrack these for balanced execution:\n\n| Metric | Calculation | Target |\n|--------|-------------|--------|\n| Load imbalance | `max(load) \u002F avg(load)` | \u003C 1.2 |\n| Straggler ratio | `max(time) \u002F median(time)` | \u003C 2.0 |\n| Worker utilization | `busy_time \u002F total_time` | > 90% |\n| Queue depth variance | `std(queue_lengths)` | Low |\n\n## Anti-Patterns\n\n| Problem | Cause | Fix |\n|---------|-------|-----|\n| Starvation | Large tasks block queue | Break into subtasks |\n| Thundering herd | All workers wake at once | Jittered scheduling |\n| Hot spots | Uneven key distribution | Better hash function |\n| Convoy effect | Workers wait on same resource | Fine-grained locking |\n| Over-partitioning | Too many small tasks | Batch small items |\n\n## Verification Checklist\n\nBefore finalizing balanced code:\n\n- [ ] Work distribution is roughly even (measure completion times)\n- [ ] No starvation (all workers stay busy)\n- [ ] Stragglers are handled (timeout\u002Fretry logic)\n- [ ] Overhead is acceptable (partitioning cost vs. task cost)\n- [ ] Results are complete and correct\n- [ ] Resource utilization is high across workers\n","# Workload Balancing Skill\n\nDistribute work efficiently across parallel workers to maximize throughput and minimize completion time.\n\n## Workflow\n\n1. **Characterize** the workload (uniform vs. variable task times)\n2. **Identify** bottlenecks (stragglers, uneven distribution)\n3. **Select** balancing strategy based on workload characteristics\n4. **Implement** partitioning and scheduling logic\n5. **Monitor** and adapt to runtime conditions\n\n## Load Balancing Decision Tree\n\n```\nWhat's the workload characteristic?\n\nUniform task times:\n├── Known count → Static partitioning (equal chunks)\n├── Streaming input → Round-robin distribution\n└── Large items → Size-aware partitioning\n\nVariable task times:\n├── Predictable variance → Weighted distribution\n├── Unpredictable → Dynamic scheduling \u002F work stealing\n└── Long-tail distribution → Work stealing + time limits\n\nResource constraints:\n├── Memory-bound workers → Memory-aware assignment\n├── Heterogeneous workers → Capability-based routing\n└── Network costs → Locality-aware placement\n```\n\n## Balancing Strategies\n\n### Strategy 1: Static Chunking (Uniform Workloads)\n\nBest for: predictable, similar-sized tasks\n\n```python\nfrom concurrent.futures import ProcessPoolExecutor\nimport numpy as np\n\ndef static_balanced_process(items, num_workers=4):\n    \"\"\"Divide work into equal chunks upfront.\"\"\"\n    chunks = np.array_split(items, num_workers)\n\n    with ProcessPoolExecutor(max_workers=num_workers) as executor:\n        results = list(executor.map(process_chunk, chunks))\n\n    return [item for chunk_result in results for item in chunk_result]\n```\n\n### Strategy 2: Dynamic Task Queue (Variable Workloads)\n\nBest for: unpredictable task durations\n\n```python\nfrom concurrent.futures import ProcessPoolExecutor, as_completed\nfrom queue import Queue\n\ndef dynamic_balanced_process(items, num_workers=4):\n    \"\"\"Workers pull tasks dynamically as they complete.\"\"\"\n    results = []\n\n    with ProcessPoolExecutor(max_workers=num_workers) as executor:\n        # Submit one task per worker initially\n        futures = {executor.submit(process_item, item): item\n                   for item in items[:num_workers]}\n        pending = list(items[num_workers:])\n\n        while futures:\n            done, _ = wait(futures, return_when=FIRST_COMPLETED)\n\n            for future in done:\n                results.append(future.result())\n                del futures[future]\n\n                # Submit next task if available\n                if pending:\n                    next_item = pending.pop(0)\n                    futures[executor.submit(process_item, next_item)] = next_item\n\n    return results\n```\n\n### Strategy 3: Work Stealing (Long-Tail Tasks)\n\nBest for: when some tasks take much longer than others\n\n```python\nimport asyncio\nfrom collections import deque\n\nclass WorkStealingPool:\n    def __init__(self, num_workers):\n        self.queues = [deque() for _ in range(num_workers)]\n        self.num_workers = num_workers\n\n    def distribute(self, items):\n        \"\"\"Initial round-robin distribution.\"\"\"\n        for i, item in enumerate(items):\n            self.queues[i % self.num_workers].append(item)\n\n    async def worker(self, worker_id, process_fn):\n        \"\"\"Process own queue, steal from others when empty.\"\"\"\n        while True:\n            # Try own queue first\n            if self.queues[worker_id]:\n                item = self.queues[worker_id].popleft()\n            else:\n                # Steal from busiest queue\n                item = self._steal_work(worker_id)\n                if item is None:\n                    break\n\n            await process_fn(item)\n\n    def _steal_work(self, worker_id):\n        \"\"\"Steal from the queue with most items.\"\"\"\n        busiest = max(range(self.num_workers),\n                      key=lambda i: len(self.queues[i]) if i != worker_id else 0)\n        if self.queues[busiest]:\n            return self.queues[busiest].pop()  # Steal from end\n        return None\n```\n\n### Strategy 4: Weighted Distribution\n\nBest for: when task costs are known or estimable\n\n```python\ndef weighted_partition(items, weights, num_workers):\n    \"\"\"Partition items to balance total weight per worker.\"\"\"\n    # Sort by weight descending (largest first fit)\n    sorted_items = sorted(zip(items, weights), key=lambda x: -x[1])\n\n    worker_loads = [0] * num_workers\n    worker_items = [[] for _ in range(num_workers)]\n\n    for item, weight in sorted_items:\n        # Assign to least loaded worker\n        min_worker = min(range(num_workers), key=lambda i: worker_loads[i])\n        worker_items[min_worker].append(item)\n        worker_loads[min_worker] += weight\n\n    return worker_items\n```\n\n### Strategy 5: Async Semaphore Balancing (I\u002FO Workloads)\n\nBest for: limiting concurrent I\u002FO operations\n\n```python\nimport asyncio\n\nasync def semaphore_balanced_fetch(urls, max_concurrent=10):\n    \"\"\"Limit concurrent operations while processing queue.\"\"\"\n    semaphore = asyncio.Semaphore(max_concurrent)\n\n    async def bounded_fetch(url):\n        async with semaphore:\n            return await fetch(url)\n\n    return await asyncio.gather(*[bounded_fetch(url) for url in urls])\n```\n\n## Partitioning Strategies\n\n| Strategy | Best For | Implementation |\n|----------|----------|----------------|\n| Equal chunks | Uniform tasks | `np.array_split(items, n)` |\n| Round-robin | Streaming | `items[i::n_workers]` |\n| Size-weighted | Known sizes | Bin packing algorithm |\n| Hash-based | Consistent routing | `hash(key) % n_workers` |\n| Range-based | Sorted\u002Fordered data | Contiguous ranges |\n\n## Handling Stragglers\n\nTechniques to mitigate slow workers:\n\n```python\n# 1. Timeout with fallback\nfrom concurrent.futures import TimeoutError\n\ntry:\n    result = future.result(timeout=30)\nexcept TimeoutError:\n    result = fallback_value\n\n# 2. Speculative execution (backup tasks)\nasync def speculative_execute(task, timeout=10):\n    primary = asyncio.create_task(execute(task))\n    try:\n        return await asyncio.wait_for(primary, timeout)\n    except asyncio.TimeoutError:\n        backup = asyncio.create_task(execute(task))  # Retry\n        done, pending = await asyncio.wait(\n            [primary, backup], return_when=asyncio.FIRST_COMPLETED\n        )\n        for p in pending:\n            p.cancel()\n        return done.pop().result()\n\n# 3. Dynamic rebalancing\ndef rebalance_on_straggler(futures, threshold_ratio=2.0):\n    \"\"\"Redistribute work if one worker falls behind.\"\"\"\n    avg_completion = statistics.mean(completion_times)\n    for future, worker_id in futures.items():\n        if future.running() and elapsed(future) > threshold_ratio * avg_completion:\n            # Cancel and redistribute\n            remaining_work = cancel_and_get_remaining(future)\n            redistribute(remaining_work, fast_workers)\n```\n\n## Monitoring Metrics\n\nTrack these for balanced execution:\n\n| Metric | Calculation | Target |\n|--------|-------------|--------|\n| Load imbalance | `max(load) \u002F avg(load)` | \u003C 1.2 |\n| Straggler ratio | `max(time) \u002F median(time)` | \u003C 2.0 |\n| Worker utilization | `busy_time \u002F total_time` | > 90% |\n| Queue depth variance | `std(queue_lengths)` | Low |\n\n## Anti-Patterns\n\n| Problem | Cause | Fix |\n|---------|-------|-----|\n| Starvation | Large tasks block queue | Break into subtasks |\n| Thundering herd | All workers wake at once | Jittered scheduling |\n| Hot spots | Uneven key distribution | Better hash function |\n| Convoy effect | Workers wait on same resource | Fine-grained locking |\n| Over-partitioning | Too many small tasks | Batch small items |\n\n## Verification Checklist\n\nBefore finalizing balanced code:\n\n- [ ] Work distribution is roughly even (measure completion times)\n- [ ] No starvation (all workers stay busy)\n- [ ] Stragglers are handled (timeout\u002Fretry logic)\n- [ ] Overhead is acceptable (partitioning cost vs. task cost)\n- [ ] Results are complete and correct\n- [ ] Resource utilization is high across workers\n",{"name":5,"description":7},"main","cdcb6d230f3b15c3c33f8a2bdd16439f43602cbe","evaluation\u002Fresults\u002FOpus47-OriginalSkill-79Tasks-20260920\u002Fruns\u002Fopus47-original-skill\u002Fparallel-tfidf-search-opus47-original-skill-r001\u002Finputs\u002Fskills\u002Fworkload-balancing",1,"https:\u002F\u002Fgithub.com\u002Flinyouxue\u002Fskill-repair-benchmark","https:\u002F\u002Fgithub.com\u002Flinyouxue","2026-11-14 20:28:35",{"source":8,"skillName":5,"commands":32,"prompt":42,"zipAvailable":43},[33,36,39],{"tool":34,"command":35},"npx","npx skills add linyouxue\u002Fskill-repair-benchmark --skill workload-balancing",{"tool":37,"command":38},"bunx","bunx skills add linyouxue\u002Fskill-repair-benchmark --skill workload-balancing",{"tool":40,"command":41},"pnpm","pnpm dlx skills add linyouxue\u002Fskill-repair-benchmark --skill workload-balancing","安装技能，技能地址：https:\u002F\u002Fgithub.com\u002Flinyouxue\u002Fskill-repair-benchmark\u002Fblob\u002Fmain\u002Fevaluation\u002Fresults\u002FOpus47-OriginalSkill-79Tasks-20260920\u002Fruns\u002Fopus47-original-skill\u002Fparallel-tfidf-search-opus47-original-skill-r001\u002Finputs\u002Fskills\u002Fworkload-balancing\u002FSKILL.md",true,[45],{"path":46,"resourceType":47,"resourceTypeDesc":48,"sizeBytes":49,"sourceHtmlUrl":50},"references\u002Fadvanced_techniques.md","REFERENCE","参考文档",7936,"https:\u002F\u002Fgithub.com\u002Flinyouxue\u002Fskill-repair-benchmark\u002Fblob\u002Fmain\u002Fevaluation\u002Fresults\u002FOpus47-OriginalSkill-79Tasks-20260920\u002Fruns\u002Fopus47-original-skill\u002Fparallel-tfidf-search-opus47-original-skill-r001\u002Finputs\u002Fskills\u002Fworkload-balancing\u002Freferences\u002Fadvanced_techniques.md",[52,59,66,73,78,83],{"skillNo":53,"name":54,"nameZh":6,"description":55,"descriptionZh":6,"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":19},"01M7E1HGVRY73NBJ022CJG13X6","video-frame-extraction","Extract frames from video files and save them as images using OpenCV","https:\u002F\u002Fgithub.com\u002Flinyouxue\u002Fskill-repair-benchmark\u002Fblob\u002Fmain\u002Fjpg-ocr-stat\u002Fresult\u002Fskilltta-claude4.7\u002Fgroup_03\u002Frun_03\u002Finputs\u002Fskills\u002Fvideo-frame-extraction\u002FSKILL.md",[],[],{"skillNo":60,"name":61,"nameZh":6,"description":62,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":63,"categories":64,"keywords":65,"publishedAt":19},"01M7E1HAG5R7CJ9C8NYJS771MB","openai-vision","Analyze images and multi-frame sequences using OpenAI GPT vision models","https:\u002F\u002Fgithub.com\u002Flinyouxue\u002Fskill-repair-benchmark\u002Fblob\u002Fmain\u002Fjpg-ocr-stat\u002Fresult\u002Fskilltta-claude4.7\u002Fgroup_03\u002Frun_03\u002Finputs\u002Fskills\u002Fopenai-vision\u002FSKILL.md",[],[],{"skillNo":67,"name":68,"nameZh":6,"description":69,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":70,"categories":71,"keywords":72,"publishedAt":19},"01M7E1H7DADKB6QBWKC2KQ63SZ","image-ocr","Extract text content from images using Tesseract OCR via Python, including structured field extraction from receipts and forms","https:\u002F\u002Fgithub.com\u002Flinyouxue\u002Fskill-repair-benchmark\u002Fblob\u002Fmain\u002Fjpg-ocr-stat\u002Fresult\u002Fskilltta-claude4.7\u002Fgroup_03\u002Frun_03\u002Finputs\u002Fskills\u002Fimage-ocr\u002FSKILL.md",[],[],{"skillNo":74,"name":54,"nameZh":6,"description":55,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":75,"categories":76,"keywords":77,"publishedAt":19},"01M7E1H0WBNT43TENGQY7AVZHD","https:\u002F\u002Fgithub.com\u002Flinyouxue\u002Fskill-repair-benchmark\u002Fblob\u002Fmain\u002Fjpg-ocr-stat\u002Fresult\u002Fskilltta-claude4.7\u002Fgroup_03\u002Frun_02\u002Finputs\u002Fskills\u002Fvideo-frame-extraction\u002FSKILL.md",[],[],{"skillNo":79,"name":61,"nameZh":6,"description":62,"descriptionZh":6,"repositoryFullName":8,"ownerLogin":9,"ownerAvatarUrl":10,"ownerAccountNo":11,"ownerDisplayName":12,"repositoryNo":13,"starsCount":14,"licenseSpdxId":15,"licenseFileUrl":6,"sourceHtmlUrl":80,"categories":81,"keywords":82,"publishedAt":19},"01M7E1GTC7D4N4Q2EF03875J9E","https:\u002F\u002Fgithub.com\u002Flinyouxue\u002Fskill-repair-benchmark\u002Fblob\u002Fmain\u002Fjpg-ocr-stat\u002Fresult\u002Fskilltta-claude4.7\u002Fgroup_03\u002Frun_02\u002Finputs\u002Fskills\u002Fopenai-vision\u002FSKILL.md",[],[],{"skillNo":84,"name":68,"nameZh":6,"description":69,"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":19},"01M7E1GQ92CWFMGH53KSSE4WER","https:\u002F\u002Fgithub.com\u002Flinyouxue\u002Fskill-repair-benchmark\u002Fblob\u002Fmain\u002Fjpg-ocr-stat\u002Fresult\u002Fskilltta-claude4.7\u002Fgroup_03\u002Frun_02\u002Finputs\u002Fskills\u002Fimage-ocr\u002FSKILL.md",[],[]]