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 keyword coverage for the async Python domain. Its main weakness is that the capability description leans toward high-level concepts ('Master Python asyncio') rather than listing specific concrete actions the skill enables. The word 'Master' is slightly vague and aspirational rather than action-oriented.
Suggestions
Replace 'Master Python asyncio...' with specific concrete actions like 'Implement Python asyncio event loops, manage coroutines, create task groups, handle async context managers, and structure async/await patterns'.
Use third-person action verbs instead of the imperative 'Master' — e.g., 'Guides implementation of...' or 'Provides patterns for...' to better describe what the skill does.
| 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 reference document that explains many concepts Claude already knows (event loops, coroutines, futures). While the code examples are high-quality and executable, the sheer volume (~500+ lines) wastes token budget. The content would benefit enormously from aggressive trimming of explanatory text and splitting into a concise overview with linked reference files.
Suggestions
Remove the 'Core Concepts' section entirely—Claude already knows what event loops, coroutines, tasks, futures, and async context managers are. Replace with a brief 'Key rules' section covering only non-obvious gotchas.
Split into SKILL.md (quick start + decision guide + common pitfalls) and separate reference files like PATTERNS.md and REAL_WORLD.md, with clear links from the main file.
Cut the 'When to Use This Skill' bullet list—this is metadata that belongs in the frontmatter description, not the body content.
Consolidate the simulated examples (AsyncDB, WebSocket) into shorter snippets or remove them in favor of real library usage patterns (e.g., actual asyncpg or websockets library code).
| 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 skill presents a catalog of patterns without guidance on how to compose them or validate that an async implementation is correct. No validation checkpoints or feedback loops for debugging async issues. | 2 / 3 |
Progressive Disclosure | Monolithic wall of text with no references to external files. All content is inline in a single massive document. The 'Real-World Applications' and 'Advanced Patterns' sections could easily be split into separate reference files. No navigation aids or cross-references to help find specific patterns quickly. | 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
91fe43e
- 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.