async-python-patterns
Master Python asyncio, concurrent programming, and async/await patterns for high-performance applications. Use when building async APIs, concurrent systems, or I/O-bound applications requiring non-blocking operations.
76
66%
Does it follow best practices?
Impact
96%
0.98xAverage score across 3 eval scenarios
Advisory
Suggest reviewing before use
Optimize this skill with Tessl
npx tessl skill review --optimize ./plugins/python-development/skills/async-python-patterns/SKILL.mdQuality
Discovery
89%Based on the skill's description, can an agent find and select it at the right time? Clear, specific descriptions lead to better discovery.
This is a solid description with explicit 'Use when' triggers and good domain-specific keywords that developers would naturally use. Its main weakness is that the 'what' portion uses somewhat high-level language ('Master Python asyncio') rather than listing specific concrete actions the skill enables. The word 'Master' also reads more like marketing copy than a functional description.
Suggestions
Replace 'Master Python asyncio...' with specific concrete actions like 'Implement Python asyncio event loops, manage coroutines and task groups, write async/await patterns, handle async generators and context managers'.
Avoid aspirational verbs like 'Master' which sound like marketing copy; use action-oriented third-person verbs like 'Implements', 'Creates', 'Designs' to describe concrete capabilities.
| Dimension | Reasoning | Score |
|---|---|---|
Specificity | Names the domain (Python asyncio, concurrent programming) and some general actions ('building async APIs, concurrent systems'), but doesn't list multiple specific concrete actions like 'create event loops, manage coroutines, implement task groups, handle async context managers'. | 2 / 3 |
Completeness | Clearly answers both 'what' (Master Python asyncio, concurrent programming, async/await patterns) and 'when' (explicit 'Use when building async APIs, concurrent systems, or I/O-bound applications requiring non-blocking operations'). | 3 / 3 |
Trigger Term Quality | Good coverage of natural terms users would say: 'asyncio', 'async/await', 'concurrent', 'async APIs', 'I/O-bound', 'non-blocking operations'. These are terms developers naturally use when seeking help with Python async programming. | 3 / 3 |
Distinctiveness Conflict Risk | Clearly scoped to Python asyncio and async/await patterns specifically, which is a distinct niche unlikely to conflict with general Python skills or other language-specific concurrency skills. The trigger terms are specific enough to avoid false matches. | 3 / 3 |
Total | 11 / 12 Passed |
Implementation
42%Reviews the quality of instructions and guidance provided to agents. Good implementation is clear, handles edge cases, and produces reliable results.
This skill is a comprehensive but excessively verbose async Python reference that reads more like a tutorial than a skill file for Claude. While the code examples are high-quality and executable, the document wastes significant token budget explaining concepts Claude already knows (event loops, coroutines, futures) and could be reduced to roughly 1/3 its size. The monolithic structure with no external file references makes it a poor fit for the SKILL.md format.
Suggestions
Remove the 'Core Concepts' section entirely — Claude already knows what event loops, coroutines, tasks, futures, async context managers, and async iterators are.
Remove the 'When to Use This Skill' bullet list and trim the decision guide to just the table, or remove it entirely.
Split advanced patterns and real-world applications into separate referenced files (e.g., ADVANCED_PATTERNS.md, REAL_WORLD_EXAMPLES.md) and keep SKILL.md as a concise overview with quick-start and the most essential patterns only.
Add a debugging/validation workflow section — e.g., how to verify concurrent operations are actually running concurrently, how to detect accidental blocking, or how to use asyncio debug mode.
| Dimension | Reasoning | Score |
|---|---|---|
Conciseness | Extremely verbose at ~500+ lines. Explains concepts Claude already knows well (what an event loop is, what coroutines are, what futures are, what async context managers are). The 'Core Concepts' section is pure padding. Many patterns use simulated/placeholder code (asyncio.sleep) that adds bulk without real value. The decision guide table and 'When to Use' list are largely unnecessary for Claude. | 1 / 3 |
Actionability | All code examples are fully executable Python with proper imports, type hints, and complete function definitions. Patterns are copy-paste ready and cover real scenarios like web scraping with aiohttp, producer-consumer queues, semaphore rate limiting, and testing with pytest-asyncio. | 3 / 3 |
Workflow Clarity | Patterns are individually clear and well-sequenced, but there's no overarching workflow for building an async application. The 'Common Pitfalls' section provides good guidance but lacks explicit validation checkpoints or feedback loops. For a skill covering concurrent/async operations, there's no guidance on debugging or verifying correctness of concurrent behavior. | 2 / 3 |
Progressive Disclosure | Monolithic wall of text with no references to external files. All content is inline in a single massive document. Content like the WebSocket server example, real-world applications, and advanced patterns could easily be split into separate referenced files. No bundle files exist to support progressive disclosure. | 1 / 3 |
Total | 7 / 12 Passed |
Validation
90%Checks the skill against the spec for correct structure and formatting. All validation checks must pass before discovery and implementation can be scored.
Validation — 10 / 11 Passed
Validation for skill structure
| Criteria | Description | Result |
|---|---|---|
skill_md_line_count | SKILL.md is long (736 lines); consider splitting into references/ and linking | Warning |
Total | 10 / 11 Passed | |
- Repository
- wshobson/agents
- Commit
34632bc
- Reviewed
Table of Contents
Is this your skill?
If you maintain this skill, you can claim it as your own. Once claimed, you can manage eval scenarios, bundle related skills, attach documentation or rules, and ensure cross-agent compatibility.