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.
75
62%
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 description leans slightly toward categorical labels rather than concrete actions, and some trigger terms like 'connections' and 'streaming' could overlap with other Python-related skills. Overall it performs well for skill selection purposes.
Suggestions
Make capabilities more action-oriented, e.g., 'Implements context managers, handles resource cleanup with __enter__/__exit__, builds streaming responses with accumulated state'
Add more distinctive qualifiers to reduce overlap, e.g., specifying 'Python with-statement patterns' or 'async context managers' 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 list multiple concrete actions like 'implement context managers, handle file cleanup, build streaming responses with state accumulation'. 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
42%Reviews the quality of instructions and guidance provided to agents. Good implementation is clear, handles edge cases, and produces reliable results.
The skill provides high-quality, executable Python code examples covering a broad range of resource management patterns, which is its primary strength. However, it is significantly over-verbose for its target audience (Claude), explaining well-known concepts like context managers, the with statement, and O(n²) string concatenation. The monolithic structure with 9 inline patterns and no progressive disclosure makes it token-inefficient.
Suggestions
Remove the 'Core Concepts' section entirely and the 'When to Use This Skill' section — Claude already understands context managers, __enter__/__exit__, and when resource cleanup matters.
Split advanced patterns (streaming accumulation, metrics tracking, ExitStack) into a separate ADVANCED_PATTERNS.md file and reference it from the main skill.
Remove explanatory docstrings and comments that restate what the code obviously does (e.g., '"""Exit context: always close connection."""', '# Creates new string each time').
Add a brief decision matrix or flowchart at the top: @contextmanager for simple cases, class-based for complex state, ExitStack for dynamic resources — replacing the verbose pattern-by-pattern discovery.
| Dimension | Reasoning | Score |
|---|---|---|
Conciseness | The skill is excessively verbose at ~300 lines. It explains concepts Claude already knows well (context managers, __enter__/__exit__, string concatenation complexity, what the with statement does). The 'Core Concepts' section is entirely redundant. The 'When to Use This Skill' section lists obvious use cases. Many patterns include unnecessary docstrings and comments explaining basic behavior. | 1 / 3 |
Actionability | The code examples are concrete, executable, and well-typed with proper Python syntax. Each pattern includes both the implementation and usage examples, making them copy-paste ready. | 3 / 3 |
Workflow Clarity | The patterns are individually clear and well-sequenced, but there's no guidance on when to choose one pattern over another, no decision tree, and no validation/verification steps. For a skill covering resource management (which can involve destructive operations), the lack of explicit error recovery workflows or testing guidance beyond a bullet point is a gap. | 2 / 3 |
Progressive Disclosure | This is a monolithic wall of text with no references to external files and no bundle structure. The content spans 9 patterns plus best practices all inline, when advanced patterns (streaming metrics, ExitStack, string accumulation) could easily be split into separate reference files. There's no navigation structure beyond section headers. | 1 / 3 |
Total | 7 / 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
112197c
- 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.