async-python-patterns
Comprehensive guidance for implementing asynchronous Python applications using asyncio, concurrent programming patterns, and async/await for building high-performance, non-blocking systems.
43
30%
Does it follow best practices?
Impact
Pending
No eval scenarios have been run
Advisory
Suggest reviewing before use
Optimize this skill with Tessl
npx tessl skill review --optimize ./skills/antigravity-async-python-patterns/SKILL.mdQuality
Discovery
32%Based on the skill's description, can an agent find and select it at the right time? Clear, specific descriptions lead to better discovery.
The description identifies the domain (async Python with asyncio) but reads more like a course catalog entry than a skill selector. It lacks concrete actions, explicit trigger conditions, and relies on buzzword-heavy language like 'comprehensive guidance' and 'high-performance, non-blocking systems' without specifying what the skill actually does or when it should be invoked.
Suggestions
Add an explicit 'Use when...' clause with trigger terms like 'Use when the user asks about asyncio, coroutines, event loops, async/await syntax, or concurrent Python programming'.
Replace vague phrasing like 'comprehensive guidance' with specific actions such as 'Write coroutines, manage event loops, implement task groups, handle async I/O, and structure concurrent workflows'.
Include common user-facing terms and file/library references like 'coroutines', 'event loop', 'aiohttp', 'async generators', 'gather', 'TaskGroup' to improve trigger term coverage.
| Dimension | Reasoning | Score |
|---|---|---|
Specificity | Names the domain (async Python, asyncio, concurrent programming) and mentions some concepts (async/await, non-blocking systems), but doesn't list concrete actions like 'write coroutines', 'manage event loops', 'implement task groups', or 'handle async I/O'. | 2 / 3 |
Completeness | Describes what the skill covers (async Python guidance) but completely lacks a 'Use when...' clause or any explicit trigger guidance for when Claude should select this skill. Per rubric guidelines, a missing 'Use when...' clause caps completeness at 2, and the 'what' portion is also vague enough to warrant a 1. | 1 / 3 |
Trigger Term Quality | Includes relevant keywords like 'asyncio', 'async/await', 'asynchronous', and 'concurrent programming' that users might naturally use, but misses common variations like 'coroutines', 'event loop', 'aiohttp', 'async generators', 'gather', or 'TaskGroup'. | 2 / 3 |
Distinctiveness Conflict Risk | The focus on asyncio and async/await provides some specificity, but 'concurrent programming patterns' and 'high-performance, non-blocking systems' are broad enough to overlap with skills about threading, multiprocessing, or general Python performance optimization. | 2 / 3 |
Total | 7 / 12 Passed |
Implementation
27%Reviews the quality of instructions and guidance provided to agents. Good implementation is clear, handles edge cases, and produces reliable results.
This skill is essentially a table of contents with no substantive content. It defers all concrete guidance to a referenced file that doesn't exist in the bundle, leaving the skill with only vague, abstract instructions. There are no code examples, no executable patterns, and no specific async/await guidance despite the skill's stated purpose of teaching comprehensive async Python patterns.
Suggestions
Add concrete, executable code examples for core async patterns (e.g., asyncio.gather, task groups, async context managers) directly in the SKILL.md rather than deferring everything to a missing file.
Replace vague instructions like 'Pick concurrency patterns' with specific decision criteria and corresponding code snippets (e.g., 'Use asyncio.gather for independent I/O tasks: `results = await asyncio.gather(fetch_a(), fetch_b())`').
Include the referenced `resources/implementation-playbook.md` in the bundle, or inline the essential patterns so the skill is self-contained.
Add explicit validation/debugging steps for async code, such as checking for unawaited coroutines, using asyncio debug mode, or verifying proper cleanup of resources.
| Dimension | Reasoning | Score |
|---|---|---|
Conciseness | The skill includes some unnecessary sections like 'Use this skill when' and 'Do not use this skill when' which are somewhat verbose and explain things Claude can infer. The 'Limitations' section contains generic boilerplate. However, the Instructions section is reasonably lean. | 2 / 3 |
Actionability | The skill provides no concrete code examples, no executable commands, and no specific patterns. Instructions like 'Pick concurrency patterns' and 'Add timeouts, backpressure' are vague directives without any concrete implementation guidance. It defers all real content to a referenced file that doesn't exist in the bundle. | 1 / 3 |
Workflow Clarity | The Instructions section provides a rough sequence (clarify → pick patterns → add error handling → test), but steps are abstract with no validation checkpoints, no feedback loops, and no concrete verification steps for async code correctness. | 2 / 3 |
Progressive Disclosure | The skill references `resources/implementation-playbook.md` for all detailed patterns and examples, but no bundle files are provided, meaning the reference leads nowhere. The SKILL.md itself is essentially a hollow shell with no substantive content, making the progressive disclosure structure broken. | 1 / 3 |
Total | 6 / 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 |
|---|---|---|
frontmatter_unknown_keys | Unknown frontmatter key(s) found; consider removing or moving to metadata | Warning |
Total | 10 / 11 Passed | |
- Repository
- boisenoise/skills-collections
- Commit
431bfad
- 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.