
Python Scripting
- 121 installs
- 4 repo stars
- Updated April 11, 2026
- 89jobrien/steve
python-scripting is a Claude Code skill that creates self-contained Python scripts using uv and PEP 723 inline dependencies with automatic install on first run.
About
python-scripting is a Claude Code skill that creates standalone Python scripts using uv and PEP 723 inline script metadata. It sets up argument parsing, input/output handling, and reproducible dependency declaration inside the script itself. A developer uses it for one-off automation, quick data processing, or small CLI tools that need dependencies without a full project setup.
- Creates self-contained Python scripts with PEP 723 inline dependencies
- Uses uv for automatic dependency install on first run
- Ships a uv-script.template.py with argparse scaffold
Python Scripting by the numbers
- 121 all-time installs (skills.sh)
- Ranked #89 of 290 Python skills by installs in the Skillselion catalog
- Data as of Jul 28, 2026 (Skillselion catalog sync)
python-scripting capabilities & compatibility
- Capabilities
- python scripting · cli scaffolding · dependency management
- Pricing
- Free
What python-scripting says it does
Creates self-contained Python scripts using uv and PEP 723 inline script metadata.
Dependencies install automatically on first run.
npx skills add https://github.com/89jobrien/steve --skill python-scriptingAdd your badge
Show developers this skill is listed on Skillselion. Paste this into your README.
| Installs | 121 |
|---|---|
| repo stars | ★ 4 |
| Last updated | April 11, 2026 |
| Repository | 89jobrien/steve ↗ |
What it does
Generate a standalone Python utility script with inline PEP 723 dependencies run via uv.
Who is it for?
Standalone utility scripts, one-off automation, quick data processing, and small CLI tools that need dependencies.
Skip if: Full multi-module Python applications or projects requiring a packaged build.
When should I use this skill?
Creating a standalone Python script with automatic dependency management.
What you get
A single-file Python script declares its dependencies inline via PEP 723 and runs with uv, installing deps automatically.
- standalone PEP 723 Python script
By the numbers
- requires-python >=3.12
- 1 script template (uv-script.template.py)
Files
Python Scripting Skill
Creates self-contained Python scripts using uv and PEP 723 inline script metadata.
What This Skill Does
- Creates standalone Python scripts
- Uses PEP 723 inline dependencies
- Sets up argument parsing
- Handles input/output
- Configures reproducible builds
When to Use
- Standalone utility scripts
- One-off automation tasks
- Quick data processing
- CLI tools
- Scripts that need dependencies
Reference Files
references/UV_SCRIPT.template.py- Python script template with PEP 723 metadata
PEP 723 Format
#!/usr/bin/env -S uv run --script
# /// script
# requires-python = ">=3.12"
# dependencies = [
# "requests",
# "rich",
# ]
# ///Running Scripts
uv run script.py [args]Dependencies install automatically on first run.
Best Practices
- Use
exclude-newerfor reproducibility - Include docstring with usage examples
- Use argparse for CLI arguments
- Return exit codes (0 success, non-zero error)
- Keep scripts focused on one task
#!/usr/bin/env -S uv run --script
# /// script
# requires-python = ">=3.12"
# dependencies = [
# "{{DEPENDENCY_1}}",
# "{{DEPENDENCY_2}}",
# ]
# [tool.uv]
# exclude-newer = "{{ISO_DATE}}"
# ///
"""{{SCRIPT_DESCRIPTION}}
Usage:
uv run {{SCRIPT_NAME}}.py [OPTIONS] [ARGUMENTS]
Examples:
uv run {{SCRIPT_NAME}}.py --help
uv run {{SCRIPT_NAME}}.py input.txt
uv run {{SCRIPT_NAME}}.py --verbose --output results.json
Requirements:
- uv (https://docs.astral.sh/uv/)
- Python 3.12+
The script will automatically install dependencies on first run.
"""
import argparse
import sys
from pathlib import Path
def parse_args() -> argparse.Namespace:
parser = argparse.ArgumentParser(
description="{{SCRIPT_DESCRIPTION}}",
formatter_class=argparse.RawDescriptionHelpFormatter,
)
parser.add_argument(
"input",
type=Path,
nargs="?",
help="Input file path",
)
parser.add_argument(
"-o",
"--output",
type=Path,
help="Output file path",
)
parser.add_argument(
"-v",
"--verbose",
action="store_true",
help="Enable verbose output",
)
return parser.parse_args()
def main() -> int:
args = parse_args()
if args.verbose:
print(f"Input: {args.input}")
print(f"Output: {args.output}")
# {{MAIN_LOGIC}}
return 0
if __name__ == "__main__":
sys.exit(main())
Related skills
FAQ
How are dependencies handled?
They are declared inline with PEP 723 metadata and install automatically on first run with uv.
When should I use this?
For standalone utility scripts, one-off automation, quick data processing, and small CLI tools that need dependencies.