python-resource-management
Python resource management with context managers, cleanup patterns, and streaming. Use when managing connections, file handles, implementing cleanup logic, or building streaming responses with accumulated state.
82
73%
Does it follow best practices?
Impact
100%
1.02xAverage score across 3 eval scenarios
Passed
No known issues
Optimize this skill with Tessl
npx tessl skill review --optimize ./plugins/python-development/skills/python-resource-management/SKILL.mdQuality
Discovery
82%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 that clearly communicates both what the skill does and when to use it, with a good explicit 'Use when' clause. Its main weakness is that the capability descriptions are somewhat categorical rather than listing specific concrete actions, and some trigger terms like 'connections' and 'streaming' could overlap with other skills. The description is concise and well-structured without unnecessary fluff.
Suggestions
Add more specific concrete actions, e.g., 'Implements __enter__/__exit__ protocols, builds async context managers, creates generator-based streaming pipelines' to improve specificity.
Consider adding distinguishing qualifiers to reduce overlap, e.g., 'Python-specific resource lifecycle management' or mention specific patterns like 'contextlib utilities, try/finally cleanup' to differentiate from general connection or streaming skills.
| Dimension | Reasoning | Score |
|---|---|---|
Specificity | Names the domain (Python resource management) and lists several areas (context managers, cleanup patterns, streaming), but doesn't describe concrete actions like 'implement context managers' or 'build streaming response generators with accumulated state tracking'. The terms are more categorical than action-oriented. | 2 / 3 |
Completeness | Clearly answers both 'what' (Python resource management with context managers, cleanup patterns, and streaming) and 'when' (explicit 'Use when' clause covering connections, file handles, cleanup logic, and streaming responses with accumulated state). | 3 / 3 |
Trigger Term Quality | Includes strong natural keywords users would say: 'context managers', 'cleanup', 'connections', 'file handles', 'streaming responses', 'accumulated state'. These cover common variations of how developers would describe resource management needs in Python. | 3 / 3 |
Distinctiveness Conflict Risk | While 'context managers' and 'cleanup patterns' are fairly distinct, terms like 'connections', 'file handles', and 'streaming responses' could overlap with database skills, file I/O skills, or web framework skills. The combination narrows it but individual triggers could cause conflicts. | 2 / 3 |
Total | 10 / 12 Passed |
Implementation
64%Reviews the quality of instructions and guidance provided to agents. Good implementation is clear, handles edge cases, and produces reliable results.
This is a solid, actionable skill with excellent code examples covering both fundamental and advanced resource management patterns. Its main weaknesses are verbosity in the introductory sections (explaining concepts Claude already knows) and the monolithic structure that could benefit from splitting advanced patterns into separate files. The workflow clarity could be improved by adding validation/verification steps for confirming proper resource cleanup.
Suggestions
Remove or drastically shorten the 'Core Concepts' and 'When to Use This Skill' sections — Claude already understands context managers, protocol methods, and when cleanup matters.
Move advanced patterns (streaming accumulation, metrics tracking, ExitStack) into a separate ADVANCED.md file and link to it from the main skill.
Add a brief verification pattern showing how to confirm resources were properly released (e.g., checking connection pool status, verifying file handles are closed).
| Dimension | Reasoning | Score |
|---|---|---|
Conciseness | The skill includes some unnecessary explanations Claude already knows (e.g., 'Core Concepts' section explaining what context managers are, what __enter__/__exit__ do, that __exit__ always runs). The 'When to Use This Skill' section is also somewhat redundant given the description. However, the code examples themselves are lean and well-structured. | 2 / 3 |
Actionability | All patterns include fully executable, copy-paste ready Python code with proper type annotations, docstrings, and usage examples. The code covers both sync and async patterns, class-based and decorator-based approaches, and includes anti-patterns (the O(n²) string concatenation example). | 3 / 3 |
Workflow Clarity | The patterns are individually clear but there's no sequenced workflow with validation checkpoints. For resource management involving cleanup of connections and file handles (potentially destructive operations), there are no explicit verification steps to confirm resources were properly released. The best practices list is helpful but reads as a checklist rather than a workflow. | 2 / 3 |
Progressive Disclosure | The content is well-organized with clear sections (Quick Start, Fundamental Patterns, Advanced Patterns, Best Practices), but it's a monolithic document at ~300 lines. The advanced patterns (streaming, metrics, ExitStack) could be split into separate reference files with links from the main skill, improving scannability. | 2 / 3 |
Total | 9 / 12 Passed |
Validation
100%Checks the skill against the spec for correct structure and formatting. All validation checks must pass before discovery and implementation can be scored.
Validation — 11 / 11 Passed
Validation for skill structure
No warnings or errors.
- Repository
- wshobson/agents
- Commit
27a7ed9
- 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.