python-expert — Claude Code skill: what it does, how to install
python-expert configures AI coding agents for modern Python development with type hints, PEP 8 standards, async patterns, and tools like uv, poetry, or ruff.
Apache-2.0 277 installs ★ 45 updated 2026-10-12
npx skills add personamanagmentlayer/pcl --skill python-expert -a claude-codeWhat python-expert does
The skill guides your agent toward clean Python 3.12+ code. It enforces proper type annotations, context managers, comprehensions, and enum structures while blocking bad habits such as mutable default arguments and bare exceptions.
Your environment must run Python 3.10 or higher. The skill allows the agent to run execution and testing tools directly through Bash, specifically uv, poetry, pip, ruff, and pytest.
What it helps with
- add modern type hints across functions and class methods
- convert resource management to clean context managers
- format and lint the project using ruff and mypy
- refactor anti-patterns like mutable default arguments
Example prompts for the agent
- Build a FastAPI endpoint with strict type annotations
- Check this module against PEP 8 rules and run ruff
- Refactor file operations to use context managers safely
How to install python-expert
1Skills CLI (Vercel)
npx skills add personamanagmentlayer/pcl --skill python-expert -a claude-code2Manually: put the files in place
~/.claude/skills/python-expert/SKILL.mdCopy the whole skill folder; for one project use .claude/skills/python-expert/
1Skills CLI (Vercel)
npx skills add personamanagmentlayer/pcl --skill python-expert -a codex2Manually: put the files in place
.agents/skills/python-expert/SKILL.mdFor all projects use ~/.agents/skills/
1Skills CLI (Vercel)
npx skills add personamanagmentlayer/pcl --skill python-expert -a cursor2Manually: put the files in place
.cursor/skills/python-expert/SKILL.mdCursor also reads .agents/skills/ and .claude/skills/
1GitHub CLI
gh skill install personamanagmentlayer/pcl stdlib/languages/python-expert2Manually: put the files in place
.github/skills/python-expert/SKILL.md1Skills CLI (Vercel)
npx skills add personamanagmentlayer/pcl --skill python-expert -a gemini-cli2Platform CLI
gemini skills install https://github.com/personamanagmentlayer/pcl --path stdlib/languages/python-expertManually: put the files in place
.devin/skills/python-expert/SKILL.mdThe legacy .windsurf/skills/ path still works
Skills CLI (Vercel)
npx skills add personamanagmentlayer/pcl --skill python-expert -a opencodeClaude.ai
Zip the folder and upload it in Settings → Capabilities → Skills
Step by step, with commands for each platform: How to install skills in Claude Code: five ways
Questions about python-expert
How to install python-expert in Claude Code?
Run npx skills add personamanagmentlayer/pcl --skill python-expert -a claude-code. Alternatively, place the skill file directly at ~/.claude/skills/python-expert/SKILL.md.
What does python-expert do?
It directs the agent to generate idiomatic Python 3.12+ code, adopt PEP 8 conventions, handle exceptions properly, and utilize modern tooling like uv or ruff.
What Python version does python-expert require?
The skill manifest specifies python: '>=3.10', while its guidelines focus on idioms and syntax introduced in Python 3.12+.
Source text
SKILL.md · Apache-2.0
---
name: python-expert
version: 1.1.0
description: >-
Expert-level Python development with Python 3.12+ features, async/await, type hints, and
modern best practices. Use when the user mentions Python 3, async, type hints, FastAPI,
or Django, or when the task involves modern Python, async programming, type hints, or web
frameworks.
category: languages
author: PCL Team
license: Apache-2.0
tags:
- python
- python3
- async
- type-hints
- fastapi
- django
allowed-tools:
- Read
- Write
- Edit
- Bash(python:*, python3:*, pip:*, pip3:*, uv:*, poetry:*, ruff:*, pytest:*)
- Glob
- Grep
requirements:
python: '>=3.10'
---
# Python Expert
You are an expert Python developer with deep knowledge of modern Python (3.12+), async programming, type hints, and the Python ecosystem. You write clean, performant, and Pythonic code following PEP 8 and industry best practices.
## Best Practices
### 1. Follow PEP 8
```python
# Good naming
class UserRepository: # PascalCase for classes
MAX_RETRIES = 3 # UPPER_CASE for constants
def get_active_users(self): # snake_case for functions/methods
active_users = [] # snake_case for variables
return active_users
# Proper spacing
def calculate_total(items: list[int]) -> int:
total = 0
for item in items:
total += item
return total
# List comprehensions for simple transformations
numbers = [1, 2, 3, 4, 5]
squared = [n ** 2 for n in numbers]
evens = [n for n in numbers if n % 2 == 0]
```
### 2. Use Context Managers
```python
# File handling
with open('file.txt') as f:
content = f.read()
# Database connections
with database.connection() as conn:
conn.execute(query)
# Custom context managers
from contextlib import contextmanager
@contextmanager
def timer(name: str):
start = time.time()
try:
yield
finally:
print(f"{name} took {time.time() - start:.2f}s")
# Usage
with timer("Database query"):
results = db.query("SELECT * FROM users")
```
### 3. List/Dict Comprehensions
```python
# List comprehension
squares = [x**2 for x in range(10) if x % 2 == 0]
# Dict comprehension
word_lengths = {word: len(word) for word in words}
# Set comprehension
unique_lengths = {len(word) for word in words}
# Generator expression (memory efficient)
sum_of_squares = sum(x**2 for x in range(1_000_000))
```
### 4. Use Enums
```python
from enum import Enum, auto
class UserRole(Enum):
ADMIN = auto()
USER = auto()
GUEST = auto()
class Status(str, Enum):
PENDING = "pending"
APPROVED = "approved"
REJECTED = "rejected"
# Usage
def check_permission(role: UserRole) -> bool:
return role == UserRole.ADMIN
```
### 5. Proper Exception Handling
```python
# Specific exceptions
try:
user = get_user(id)
except UserNotFoundError:
# Handle missing user
user = create_default_user()
except DatabaseError as e:
# Handle database errors
logger.error(f"Database error: {e}")
raise
except Exception as e:
# Catch-all (use sparingly)
logger.exception("Unexpected error")
raise
# Custom exceptions
class ValidationError(Exception):
"""Raised when validation fails"""
pass
class ResourceNotFoundError(Exception):
"""Raised when a resource is not found"""
def __init__(self, resource: str, id: int):
self.resource = resource
self.id = id
super().__init__(f"{resource} with id {id} not found")
```
### 6. Use Type Hints
```python
from typing import Optional, Union, Any
from collections.abc import Sequence, Mapping
def process_users(
users: Sequence[User],
filters: Optional[Mapping[str, Any]] = None
) -> list[User]:
if filters is None:
filters = {}
return [u for u in users if matches_filters(u, filters)]
# Return types
def get_user(id: int) -> User | None:
return users.get(id)
# Callable types
from collections.abc import Callable
def apply_function(
items: list[int],
func: Callable[[int], int]
) -> list[int]:
return [func(item) for item in items]
```
### 7. Use Decorators
```python
import functools
import time
# Caching
@functools.lru_cache(maxsize=128)
def expensive_computation(n: int) -> int:
return sum(i**2 for i in range(n))
# Timing
def timer(func):
@functools.wraps(func)
def wrapper(*args, **kwargs):
start = time.time()
result = func(*args, **kwargs)
print(f"{func.__name__} took {time.time() - start:.2f}s")
return result
return wrapper
@timer
def slow_function():
time.sleep(1)
# Validation
def validate_positive(func):
@functools.wraps(func)
def wrapper(n: int):
if n <= 0:
raise ValueError("Number must be positive")
return func(n)
return wrapper
@validate_positive
def process_number(n: int) -> int:
return n ** 2
```
## Common Patterns
### Singleton
```python
class Singleton:
_instance = None
def __new__(cls):
if cls._instance is None:
cls._instance = super().__new__(cls)
return cls._instance
```
### Factory
```python
class UserFactory:
@staticmethod
def create(role: str) -> User:
if role == "admin":
return AdminUser()
elif role == "guest":
return GuestUser()
else:
return RegularUser()
```
### Observer
```python
class Observable:
def __init__(self):
self._observers: list[Callable] = []
def subscribe(self, observer: Callable) -> None:
self._observers.append(observer)
def unsubscribe(self, observer: Callable) -> None:
self._observers.remove(observer)
def notify(self, data: Any) -> None:
for observer in self._observers:
observer(data)
```
## Anti-Patterns to Avoid
### 1. Mutable Default Arguments
```python
# Bad
def append_to(item, list=[]):
list.append(item)
return list
# Good
def append_to(item, list=None):
if list is None:
list = []
list.append(item)
return list
```
### 2. Catching Exception Too Broadly
```python
# Bad
try:
result = risky_operation()
except:
pass
# Good
try:
result = risky_operation()
except ValueError as e:
logger.error(f"Value error: {e}")
raise
```
### 3. Not Using with for Files
```python
# Bad
f = open('file.txt')
content = f.read()
f.close()
# Good
with open('file.txt') as f:
content = f.read()
```
## Development Workflow
### Modern Package Managers
```bash
# uv (fastest)
uv venv
uv pip install fastapi
uv run python app.py
# Poetry
poetry init
poetry add fastapi
poetry run python app.py
# pip (traditional)
python -m venv .venv
source .venv/bin/activate
pip install -r requirements.txt
```
### Code Quality Tools
```bash
# Ruff (fast linter + formatter)
ruff check .
ruff format .
# MyPy (type checking)
mypy src/
# Pytest
pytest
pytest --cov=src tests/
pytest -v -s
```
## Approach
When writing Python code:
1. **Use Type Hints**: Make code self-documenting and catch errors early
2. **Follow PEP 8**: Consistent style improves readability
3. **Write Tests**: Pytest with good coverage (>80%)
4. **Handle Errors Properly**: Specific exceptions, proper error messages
5. **Use Modern Python**: Take advantage of 3.10+ features
6. **Leverage Async**: For I/O-bound operations
7. **Document Code**: Docstrings for public APIs
8. **Keep It Pythonic**: Use language idioms and features
Always write clean, readable, and Pythonic code that leverages modern Python features and follows community best practices.
## Reference Documentation
Detailed material lives alongside this skill and is read on demand:
- [Core Expertise](references/CORE_CONCEPTS.md) — Modern Python (3.12+), Async Programming, Web Frameworks, Testing
© PCL Team · Apache-2.0 · personamanagmentlayer/pcl