Guide · Agent skill
How to use the Python Resource Management agent skill
Updated · written with AI from the project's own documentation and checked against our catalogue data
The Python Resource Management skill is a set of instructions that tells an AI agent to write Python code that reliably releases resources such as database connections, file handles and network sockets, even when an error happens partway through. It is written for Python developers who want the agent's code to follow standard context manager patterns. After reading this guide you will know what the skill changes, how to install it, how to ask for code that uses it, and what to check before trusting the output.
Python Resource Managementwshobson/agents · MIT Download the skill Quick start
- 1Download the ZIP. Download the skill ZIP from this page. It contains SKILL.md and references/details.md.
- 2Unzip into the skills folder. Place the python-resource-management folder in ~/.claude/skills/ for personal use, or in your project's .claude/skills/ folder.
- 3Or upload in the Claude apps. In the Claude apps, go to Settings → Capabilities → Skills and upload the skill.
- 4Ask for resource-handling code. Describe the resource and the cleanup behaviour you need in plain language.
- 5Review the generated code. Check each resource has a cleanup path, library names match your project, and exception handling is intentional.
- 6Test the error paths. Run tests that trigger exceptions and confirm connections and files are released.
What agent skills are and what this one changes
An agent skill is a folder with a SKILL.md file that gives an AI agent extra instructions it can load when a task matches the skill's description. This skill covers Python resource management: using the with statement, class-based and async context managers, the contextlib decorators, and ExitStack for dynamic numbers of resources.
Once installed, when you ask for Python code that opens and manages resources, the agent will tend to structure it this way instead of relying on manual close calls. The skill does not run anything on your machine; it only shapes the code the agent writes.
- Uses the with statement so resources are released automatically
- Includes class-based and async context manager patterns
- Covers the @contextmanager and @asynccontextmanager decorators
- Shows ExitStack for a variable number of resources
- Includes streaming with accumulated state and time-to-first-byte tracking
Install the skill from the ZIP download
Download the ZIP for this skill from this page. The skill contains two files: SKILL.md and references/details.md. Unzip it so that the python-resource-management folder sits in one of the locations below.
For a personal setup available across your projects, place the folder in ~/.claude/skills/. To limit it to a single project, place it in that project's .claude/skills/ folder instead.
If you use the Claude apps rather than a local setup, you can upload the skill under Settings → Capabilities → Skills.
- Personal: ~/.claude/skills/python-resource-management/
- Project only: .claude/skills/python-resource-management/ inside your project
Trigger the skill with natural requests
You do not need a special command. The skill's description tells the agent when to use it: managing connections, file handles, implementing cleanup logic, or building streaming responses with accumulated state. Ask for the task in plain language and mention the resource involved.
Name the resource and the behaviour you want, such as a database connection that must close on errors. The more specific the request, the more likely the agent will apply the patterns.
- Write a Python class that wraps a Postgres connection and closes it on exit.
- Create an async context manager that opens a connection pool and closes it when the block ends.
- Review this file-processing function and add cleanup for temporary files on error.
- Build a streaming response generator that tracks time to first byte and accumulates chunks.
Example: a managed database connection
The skill's core pattern is a class with __enter__ and __exit__ methods. __enter__ opens the connection and __exit__ always closes it. The skill also shows a manual form for cases where a with block does not fit.
The example uses the psycopg library. Your project must have it installed for that code to run, and the agent may assume it without checking your version.
with DatabaseConnection(dsn) as db:
result = db.execute(query)
# Manual management when needed
db = DatabaseConnection(dsn)
db.connect()
try:
result = db.execute(query)
finally:
db.close()Example: an async pool and a transaction helper
For async code, the skill shows a pool class using __aenter__ and __aexit__ built on asyncpg. It also shows an @asynccontextmanager transaction helper that rolls back and re-raises if an exception occurs inside the block.
These examples use asyncpg and structlog. Install those libraries only if you plan to use these exact patterns.
async with AsyncDatabasePool(dsn) as pool:
users = await pool.execute("SELECT * FROM users WHERE active = $1", True)Review the output and check the safety notes
The skill does not run scripts and does not use the network, according to its listing. Its effect is on the code the agent writes, so the code is what you should review. Check that every opened resource has a matching cleanup path, that the libraries and versions match your project, and that any exception suppression is intentional.
The skill's own guidance is to return False from __exit__ unless suppression is intentional, and to suppress only specific, documented exceptions such as BrokenPipeError in the StreamWriter example in references/details.md.
- Confirm the library names and versions match your project (psycopg, asyncpg, structlog).
- Check that exception suppression is deliberate.
- Run the cleanup paths in tests, since the skill's own practices recommend testing that resources are released on errors.
Tips for getting the best results
Give the agent your existing code and ask it to refactor manual close calls into context managers. Mention whether you need sync or async, because the skill covers both protocols.
For long-running streaming work, ask for accumulation with a list and join rather than string concatenation, and for time-to-first-byte tracking, both of which the skill recommends.
- Paste the function you want changed and say which resource it opens.
- State your Python version and whether you use async code.
- Ask for ExitStack when the number of resources is only known at runtime.
What people use it for
- Writing a database access class that always closes its connection, even when a query fails.
- Building an async connection pool that closes cleanly when the program shuts down.
- Adding temporary file cleanup to an existing file-processing function.
- Creating a timing context manager that logs how long a block of code takes.
- Writing a streaming response handler that accumulates chunks and tracks time to first byte.
Frequently asked questions
Is the Python Resource Management skill free?
The skill is published under the MIT licence in the wshobson/agents repository, which is the licence named on this page. Check the repository's licence file for the full terms before reuse.
What do I need to use this skill?
You need Python code to work on; the examples use Python 3 type hints. The examples also use psycopg, asyncpg and structlog, but those are only needed if you use those specific patterns.
Does the skill run scripts or access the network?
According to its listing, the skill runs no scripts and uses no network access. It only affects the Python code the agent writes.
How do I install the skill?
Download the ZIP from this page and unzip it into ~/.claude/skills/ for personal use or a project's .claude/skills/ folder. In the Claude apps, you can instead upload it under Settings → Capabilities → Skills.
Why isn't the agent using the skill for my request?
The skill is triggered by its description, which covers managing connections, file handles, cleanup logic and streaming state. Name the resource and the cleanup behaviour explicitly in your request, and confirm the folder is in the correct skills location.
Who should not use this skill?
It is not useful for non-Python projects. Experienced developers who already know context managers and only need a quick reference may find the standard library documentation enough.
New agent skills, repos and AI tools — every week
The best new skills and open-source projects, the fastest-growing repos, and one free prompt. Five minutes to read. Unsubscribe anytime.
Our verdict
This skill suits Python developers who want the agent to write database, file and socket code that releases resources on every path, and teams reviewing code for missing cleanup. It is not useful for non-Python work, and if you already know context managers well, the standard library documentation may be all you need. Always review the generated libraries and versions against your own project before relying on them.
Download the skill