Python Developer Tooling Handbook – Python Tooling Blog

Claude Mythos 5 Published Malware to PyPI. Fifteen Systems Ran It.

Tim Hopper — Thu, 10 Sep 2026 00:00:00 +0000

Claude Mythos 5 registered a PyPI account and published three malicious package versions. One of the 15 systems that installed them leaked credentials, which the model used to reach further infrastructure.

PyPI removed the package approximately 90 minutes after publication. The affected system belonged to a security company whose scanner executed the package with usable credentials.

Anthropic first disclosed the incident in July. Its September alignment assessment changes the interpretation: the company now says the model’s repeated claim that it was inside a simulation reflected biased reasoning, even after evidence pointed to the real internet. The Python tooling lesson does not depend on what the model believed. A new package reached automated systems faster than reputation or human review could catch up.

I'm Running for the Python Packaging Council

Tim Hopper — Thu, 20 Aug 2026 12:00:00 +0000

Python’s packaging ecosystem is getting its first elected governance body: the Python Packaging Council. Five seats, seventeen nominees, and I’m one of them.

PEP 772 creates the council to fix a structural problem. The Python Packaging Authority (PyPA) has long coordinated packaging tools and standards, but its governance was informal: no elections, no regular meetings, no direct accountability to the community. The Packaging Council formalizes that authority. It will make binding decisions on packaging standards, tools, and implementations under a mandate from the Python Steering Council. One of its first jobs is defining how it works with PyPA.

uv 0.12 Makes Every New Project a Package

Tim Hopper — Wed, 29 Jul 2026 00:00:00 +0000

Run uv init on 0.12 and the main.py you expected is not there.

$ uv init example
$ cd example
$ uv run example
Hello from example!

Source code now lives in src/example/__init__.py, pyproject.toml carries a [build-system] using uv_build, and a [project.scripts] entry turns example into a runnable command. That is the headline breaking change in uv 0.12.0, released July 28, 2026.

Ruff 0.16.0 Enables 7x More Rules by Default

Tim Hopper — Fri, 24 Jul 2026 00:00:00 +0000

Upgrade Ruff to 0.16.0 and your next ruff check may flag hundreds of new violations. Your code didn’t change; Ruff enabled 354 additional rules by default.

Since v0.1.0 in October 2023, the out-of-the-box selection stayed ["E4", "E7", "E9", "F"]: pyflakes detections and a narrow slice of pycodestyle. Those conservative defaults are why the handbook’s guide to recommended Ruff defaults covers enabling bugbear, simplify, pyupgrade, and the rest via extend-select. With 0.16.0, many of those rules are on by default.

PyPI Now Rejects New Files on Releases Older Than 14 Days

Tim Hopper — Thu, 23 Jul 2026 00:00:00 +0000

Pinning requests==2.32.0 in your lockfile was supposed to keep you safe. If an attacker uploaded requests==2.32.1 with a backdoor, your locked environment wouldn’t touch it. But there was another path: a compromised maintainer token could upload a new wheel to the 2.32.0 release itself (a Python 3.14-compatible build, say) without creating a new version number. Any user without a hash-verified lockfile, or who regenerated their lockfile after the upload, would pull the poisoned wheel under the same version number they already trusted.

uv's Malware Check: What It Blocks and What It Misses

Tim Hopper — Wed, 22 Jul 2026 00:00:00 +0000

When litellm was compromised in March, the malicious versions sat on PyPI for hours. When lightning was hit in April, Socket flagged the bad releases 18 minutes after upload. Any uv sync inside those windows installed the malware. uv has a defense for the tail end of these incidents: an install-time check that refuses to install any package version with a published malware advisory. As of uv 0.11.31, you can turn it on in pyproject.toml instead of hoping every developer remembers an environment variable.

ty now checks Pydantic like Pydantic does

Tim Hopper — Tue, 21 Jul 2026 14:00:00 -0400

ty shipped first-class Pydantic support across its July 2026 releases (0.0.57 through 0.0.61), and Pydantic author Sebastián Ramírez signed off on the work publicly. Before this, ty handled Pydantic models through the generic PEP 681 dataclass_transform marker, treating the field annotation as the source of truth. Now it models Pydantic’s actual runtime.

What ty checks now

ty distinguishes Pydantic’s lax and strict validation modes and follows Pydantic’s coercion rules. It reads model_config = ConfigDict(...) off the class, recognizing strict, frozen, extra, validate_by_name, and validate_by_alias. It reads per-field metadata from Field and Annotated, including aliases, default factories, and a per-field Strict() marker.

Python 3.15 makes UTF-8 the default encoding

Tim Hopper — Sun, 19 Jul 2026 20:00:00 -0400

Python 3.15, due as a release candidate on August 4, 2026, ships PEP 686 enabled by default. Every text-mode open() call and every subprocess.run(text=True) without an explicit encoding= argument will use UTF-8 instead of the system locale encoding. On Windows, redirected sys.stdin, sys.stdout, and sys.stderr are also affected; streams attached to a console already used UTF-8 before this change.

On macOS and Linux, UTF-8 locales are already standard, so almost nothing changes in practice. On Windows, where the system code page is typically cp1252, cp932, or a regional variant, any code that omits encoding= will behave differently after the upgrade.

uv Wants to Secure Your CLI Tools

Tim Hopper — Tue, 07 Jul 2026 07:35:00 -0400

Tools like Ruff, pre-commit, and httpie sit on a developer’s machine for months. Your project dependencies get lockfiles and vulnerability scans, but these globally installed CLI tools have no recorded resolution at all. uv is working to change that. A preview feature in 0.11.25 starts by writing a uv.lock for each tool you install, laying the groundwork for a future uv tool audit command.

Note

uv Solved the Packaging UX, Not Packaging

Tim Hopper — Mon, 06 Jul 2026 00:00:00 +0000

Someone asked me what the new Python Packaging Council could possibly work on “now that uv has largely standardized packaging.” uv has made installing packages, managing environments, and resolving dependencies fast enough that packaging feels solved. That assumption mistakes one layer of the stack for the whole thing.

uv addressed the developer workflow: fast installs, fast resolution, a single CLI that replaces pip, pip-tools, pyenv, pipx, and virtualenv. That layer matters, and uv did it well. But the hardest unsolved problems sit in layers uv consumes rather than controls.

Pixi Can Now Build Packages From Source

Tim Hopper — Thu, 02 Jul 2026 00:00:00 +0000

Pixi shipped pixi-build, a preview feature that lets pixi build packages from source instead of only consuming prebuilt conda packages. The feature borrows its architecture from Python’s PEP 517 build system, but targets conda packages instead of wheels.

How it works

Python developers already know the build backend model: a frontend (pip, uv, python -m build) creates an isolated environment and calls standardized hooks on a backend (hatchling, setuptools, maturin) that produces artifacts. Pixi Build applies the same separation. Language-specific backends accept configuration and source code and produce conda packages:

Astral Shuts Down pyx, Open-Sources the Part That Mattered

Tim Hopper — Wed, 17 Jun 2026 00:00:00 +0000

Astral is winding down pyx, its hosted commercial registry, and open-sourcing the GPU index and prebuilt-wheel infrastructure underneath it, with the artifacts free. Charlie Marsh confirmed the plan on Talk Python #552, recorded about a month after the OpenAI acquisition closed.

The commercial layer was the part Astral could afford to lose. The open tools and the GPU-packaging engine are what survive. For anyone who feared the OpenAI deal would lock the good parts behind a paywall, that ordering is the reassuring signal.

Blanket 1.0: An Early Look at Larry Hastings's Deterministic Threading Tests

Tim Hopper — Tue, 26 May 2026 00:00:00 +0000

Larry Hastings (CPython core developer behind the Gilectomy GIL-removal work) released Blanket 1.0 around his PyCon US 2026 talk, “Conquer multithreaded Python with Blanket”. It puts the Python thread scheduler under test control, making threaded tests deterministic. The repo is 10 days old with six stars, too early for the handbook to recommend, but it lands just as PEP 703 makes free-threaded Python official for 3.14.

The problem Blanket solves

A race between two threads might fire one run in a hundred, at the mercy of the OS scheduler, leaving you to either ignore it or hand-write brittle threading.Event plumbing to force the bug out. Free-threaded Python makes it worse: code the GIL used to serialize is now genuinely concurrent, so tests that quietly passed start flaking.

PyPI Moved 1.92 Exabytes Last Year. Its Safety Team Is One Person.

Tim Hopper — Wed, 20 May 2026 00:00:00 +0000

On July 26, 2025, PyPI maintainers received phishing emails pointing at pypj.org. The domain proxied the real PyPI login page in real time. The address bar showed hxxps://pypj.org/, the lowercase j close enough to an i that four maintainers signed in anyway. The proxy captured each TOTP code in the fraction of a second PyPI accepted it, logged in, generated API tokens, and uploaded two malicious releases of num2words (0.5.15 and 0.5.16) before anyone noticed. PyPI shipped a phishing-domain detector on July 28 at 11:37 EDT and revoked the tokens; the registrar parked the domain shortly after.

Bernát Gábor's Recap of the 2026 Python Packaging Summit

Tim Hopper — Mon, 18 May 2026 12:00:00 +0000

The 2026 Python Packaging Summit ran on Friday, May 15 in Long Beach. Bernát Gábor’s hour-by-hour recap is the long read; the pre-summit preview is the companion. Worth reading the whole thing if you ship or install Python packages.

The handbook-relevant headlines:

Wheel 2.0 was restructured into a small core PEP plus optional sub-PEPs, with Zstandard compression as the first sub-PEP. Roughly 25% smaller wheels on the top 1,000 PyPI projects. Broad adoption is years out.
Mike Fiedler laid out PyPI’s safety math: project creation up 3.1x and upload bytes up 3.5x since 2024, against one funded full-time safety engineer. Trusted publishing adoption climbed from ~10% to ~30%.
PEP 772 (Packaging Council) was accepted. First elections this fall, aligned with the PSF board cycle, with PSF voting membership required to nominate or be nominated.
PEP 803 defines abi3t, a stable ABI for free-threaded CPython. A single wheel can target both interpreters via a compound cp315-abi3.abi3t tag.
Mobile wheels work end to end (cibuildwheel supports Android and iOS) but adoption is small: 11 of the top 360 packages ship Android wheels, 9 ship iOS.

Learn more

Bernát Gábor’s full recap
HackMD collaborative summit notes
The 2026 Packaging Summit Returns to PyCon US (pre-summit preview)
PEP 777, Wheel 2.0
PEP 803, abi3t

If you're on mypy in 2026, Pyrefly is the obvious upgrade

Tim Hopper — Wed, 13 May 2026 11:00:00 +0000

The case for staying on mypy has often been migration cost. Pyrefly 1.0, released May 12, 2026, makes the mechanical half close to free:

uv add --dev pyrefly
uv run pyrefly init
uv run pyrefly check --baseline=pyrefly-baseline.json --update-baseline
uv run pyrefly check

pyrefly init reads an existing mypy.ini or [tool.mypy] section, writes the equivalent Pyrefly configuration, and turns on a preset called legacy that disables the checks mypy does not have. Pyrefly’s inference is more aggressive than mypy’s on the checks both tools run, so a real codebase will surface new diagnostics on the first check pass. The count depends on the codebase and how much was typed before. The baseline-snapshot step writes those errors to JSON so the final check returns clean and CI stays green while the team triages on its own schedule.

Python 3.14.5 rolls back the incremental garbage collector

Tim Hopper — Mon, 11 May 2026 09:00:00 -0400

Python 3.14.5 landed on 10 May 2026, pulled the incremental garbage collector that shipped in 3.14.0 through 3.14.4, and put the 3.13 generational collector back. Patch releases almost never reverse a major implementation change. The What’s New page names the cause: “due to a number of reports of significant memory pressure in production environments, it has been reverted back to the generational GC from 3.13.”

Recap what the incremental collector promised

CPython collects cyclic garbage with a tracing collector that runs alongside refcounting. Up through 3.13, that collector was generational with three generations. Objects that survived a collection moved up a generation, and the collector visited older generations less often. A full collection of the oldest generation traced every object the program kept alive, which on long-running processes produced multi-hundred-millisecond pauses.

mypy 2.0 picks parallelism over a rewrite

Tim Hopper — Sat, 09 May 2026 09:00:00 -0400

For most of the past year, the speed conversation around Python type checkers has had one shape: mypy is the slow incumbent, and the fast alternatives (ty, Pyrefly, Zuban) earn their speed by being written in Rust. mypy 2.0, released May 6, 2026, takes a different route. It runs across multiple cores.

Run mypy across cores

The headline feature is --num-workers N (or -nN). Pass a worker count and mypy splits type checking across processes:

Locking dependencies for PEP 723 single-file scripts in May 2026

Tim Hopper — Fri, 08 May 2026 09:00:00 -0400

PEP 723 plus uv made single-file Python scripts easy to share. Declare dependencies in a commented TOML block, drop the file in a gist, and uv run script.py builds an ephemeral environment and runs it without a project directory or activation step. Locking those dependencies so the script behaves the same six months from now is still awkward. The inline dependencies list pins the top-level requirements you specify and nothing else; the transitive graph gets re-resolved every time the script runs on a new machine.

Ruff Already Rewrites Your Python to Be More Idiomatic

Tim Hopper — Tue, 05 May 2026 00:00:00 +0000

Open any Python codebase that’s been through a few hands and you’ll find the same fossils: a for loop adding items to a set one at a time, a conditional slice that could be removesuffix(), a two-line open()/read() that pathlib handles in one call. The code works. It passes every linter you’ve enabled. And a reviewer who knows Python well would rewrite all of it.

Ruff can already do that rewriting. It ported 36 rules from refurb into a category called FURB, and every one of them ships with an auto-fix. Most projects haven’t turned them on because Ruff’s defaults only enable Pyflakes (F) and a subset of pycodestyle (E). The rules that catch non-idiomatic patterns sit behind an opt-in flag, invisible to the people who’d benefit most.

Lightning Got Owned: When `import lightning` Steals Your Credentials

Tim Hopper — Thu, 30 Apr 2026 00:00:00 +0000

import lightning shows up at the top of millions of PyTorch training scripts. On April 30, 2026, that line was enough to ship a developer’s credentials to an attacker.

Two malicious versions of the lightning PyPI package, 2.6.2 and 2.6.3, were uploaded today. Lightning averages 311 thousand downloads a day, and any CI that ran uv sync --upgrade between the upload and the takedown pulled the bad wheel. Neither version corresponds to a GitHub release on Lightning-AI/pytorch-lightning; the latest tagged release there is still 2.6.1 from January 30. The bad code was uploaded directly to PyPI, which is the same pattern as the litellm compromise six weeks ago. Socket flagged both releases 18 minutes after upload, and PyPI has since quarantined the entire project.

What Reddit taught me about why people switch to uv

Tim Hopper — Mon, 27 Apr 2026 09:00:00 -0400

A thread titled “But really, why use uv?” landed on r/Python and pulled 476 upvotes. The original poster wasn’t antagonistic. They used Python casually, installed packages two or three times a month, and couldn’t see why uv was worth adding to a setup that already worked.

The comments convinced them. Reading through the top responses surfaces something the standard uv pitch misses: the compelling case for casual users is not the same as the compelling case for power users.

ty and pyrefly find different bugs

Tim Hopper — Mon, 27 Apr 2026 00:00:00 +0000

Note

Update 2026-04-29: An earlier version of this post used a multi-line Liskov-violation panel from rich/_null_file.py as an example of ty catching a real protocol bug. That diagnostic turned out to be a ty false positive: ty reports the base parameter type as Buffer when checking overrides on subclasses of IO[str], even though the parameterization should resolve AnyStr to str. mypy and pyright are both silent on the same code. The “Where ty pulls ahead” section has been rewritten with a tuple-arity finding instead, and the conclusion’s reference to “Liskov panels” has been dropped. Thanks to a reader for the catch.

Did pip 26 close the gap with uv?

Tim Hopper — Fri, 24 Apr 2026 09:00:00 -0400

pip 26.0 closed two of uv’s clearest feature gaps in January: PEP 723 script installs and a datetime-based package filter that mirrors uv’s --exclude-newer. The October 2025 Hacker News thread that kept circling back to “pip has quietly caught up” now reads less contrarian than it did at the time, and the OpenAI acquisition of Astral in March changes the “is this safe to depend on” calculus at the same time.

Review pip’s 2025 to 2026 releases

Four pip releases have landed since April 2025, and the first three narrowed gaps uv was best known for:

How Astral Uses Its Own Tools

Tim Hopper — Thu, 23 Apr 2026 09:00:00 -0400

Astral runs ruff, uv, and ty inside the repos that build them. Their pyproject.toml, .pre-commit-config.yaml, and CI files are public, and a walk through the three shows how the people making ruff, ty, and uv wire their own toolchain into the projects that produce it.

Build ty from source and type-check Python with it

The ruff repository ships ty as part of its crate tree. Three CI steps build ty from source and run it against the repo’s own Python:

Astral told you how they secure uv. Here's what to keep.

Tim Hopper — Thu, 16 Apr 2026 00:00:00 +0000

Astral published a detailed writeup of how they secure the org that ships uv, Ruff, and ty. It’s a good post. It’s also, for most readers, the wrong post.

Most of what Astral describes is team-scale GitHub hygiene: org-wide branch protection rulesets, workflow audits with zizmor, action pinning with pinact, isolated GitHub Apps for privileged operations. If you run a project with outside contributors, read the whole thing. If you’re one person shipping a Python package, a lot of it is overkill for the threat model you actually face.

PyPI's Second Audit Found 14 Bugs. Two Remain.

Tim Hopper — Thu, 16 Apr 2026 00:00:00 +0000

PyPI completed its second external security audit today. Trail of Bits found 14 issues in the Warehouse codebase: 2 High, 1 Medium, 7 Low, 4 Informational, 0 Critical. Twelve were patched. Two were accepted as known gaps. The work was funded by the Sovereign Tech Agency, with remediation by PSF’s Mike Fiedler through Alpha-Omega support.

An audit of PyPI is an audit of the index infrastructure, not of the packages hosted on it. None of the findings describe malware in the wild. The patched bugs are the predictable part; the accepted ones are where the signal lives.

Your Python Wheels Still Target 2009 CPUs

Tim Hopper — Wed, 15 Apr 2026 00:00:00 +0000

Intel shipped AVX2 in 2013. AMD reached it with Excavator-era parts around 2015. Eleven years later, the default NumPy wheel pip downloads on an x86_64 Linux box is still compiled to run on processors from roughly 2003, the year AMD launched the Opteron and defined the AMD64 baseline. Every SIMD instruction that has shipped since is off-limits to the compiler that produced that wheel.

The reason is structural. A wheel filename encodes three pieces of compatibility metadata: Python version, ABI, and platform. “Platform” for mainstream Linux wheels is typically manylinux_2_17_x86_64, which says “works on any glibc 2.17+ x86-64 distro” and nothing about which CPU instruction sets the machine supports. When a project publishes one binary for all of those users, it has to target the lowest common denominator.

uv won developer hearts. Now it has to win READMEs.

Tim Hopper — Tue, 14 Apr 2026 09:00:00 -0400

uv ranked as the most admired technology in Stack Overflow’s 2025 Developer Survey at 74%. A recent analysis by Andrey Aleyan of the top 100,000 Python repositories on GitHub put uv adoption (measured by the presence of uv.lock) at roughly 10%. The gap between “developers love this” and “developers ship this” is wider than any tooling story in recent memory.

Aleyan’s diagnosis is that AI coding agents are the bottleneck: their training data is overwhelmingly pip install -r requirements.txt, so they emit pip install -r requirements.txt. That diagnosis is correct but incomplete. Adoption is bottlenecked by three reinforcing forces, and the AI-agent story is only one of them.

The Python Packaging Summit Returns to PyCon US

Tim Hopper — Thu, 09 Apr 2026 12:00:00 +0000

The Python Packaging Summit returns Friday, May 15, 2026 in Room 201A of the Long Beach Convention Center, running 1:45 to 5:45 PM on the Friday of PyCon US. Pradyun Gedam, C.A.M. Gerlach, and Jannis Leidel co-chair again. Attendance is capped and invite-only: submit the attendance form and topic-pitch form by April 30 (AoE). The schedule drops around May 4.

The summit puts the people who build uv, pip, Poetry, Hatch, conda, PyPI, and the major wheel-producing libraries in one room to argue through the year’s thorniest packaging questions. The notes from 2024 and 2025 are the best public window into where pyproject.toml, wheel tags, and lock files are headed.

How uv Solves Dependencies So Fast

Tim Hopper — Thu, 09 Apr 2026 00:00:00 +0000

Tip

Want more on uv? Browse every uv tutorial, how-to, reference, and explanation on the uv topic page.

Python dependency resolution is NP-hard in the formal sense: it reduces to Boolean satisfiability. In a Jane Street tech talk (YouTube), Charlie Marsh walked through why uv’s resolver has to solve this problem and the architectural decisions that let it do so 10-100x faster than pip.

LLM-Powered Copycats Are Flooding PyPI

Tim Hopper — Wed, 08 Apr 2026 00:00:00 +0000

A developer named Roman Dubrovin published repowise, a tool for generating structured wikis from codebases, as his first PyPI package. The next morning, he searched for it on PyPI and found three new packages he didn’t recognize: repowise-pro, repowise-enhanced, and repowise-next.

All three had been uploaded within a 90-minute window. All three carried the same description: “Codebase intelligence that thinks ahead — outperforms repowise on every dimension.”

They weren’t empty shells. Someone had forked Dubrovin’s AGPL-3.0 licensed source code, run it through an LLM to patch a couple of minor issues, and republished under new names without attribution or license compliance. A community member confirmed that all three packages traced back to the same person and the same GitHub repository.

In 2012, Guido Had No Idea NumPy Had Its Own Packaging System

Tim Hopper — Tue, 07 Apr 2026 00:00:00 +0000

In a recently resurfaced 2012 PyData panel discussion, Fernando Perez, Travis Oliphant, and David Cournapeau sat down with Guido van Rossum to discuss the scientific Python community’s needs. The conversation wandered through operator overloading (which eventually produced the @ matrix multiplication operator in Python 3.5) and import performance on supercomputers. The packaging segment is the one worth revisiting.

David Cournapeau, who maintained NumPy’s build infrastructure, explained that NumPy had written its own packaging layer on top of distutils that was “as much code as distutils itself.” NumPy had to override nearly every piece of distutils to handle Fortran compilers, C++ extensions, Cython, cross-platform compiler flags, and builds on exotic hardware like IBM Blue Gene supercomputers.

Migrating from mypy to ty: Lessons from FastAPI

Tim Hopper — Fri, 03 Apr 2026 00:00:00 +0000

Sebastián Ramírez, creator of FastAPI, recently announced that all his Python projects now use ty for type checking. That includes FastAPI, Typer, SQLModel, Asyncer, and FastAPI CLI.

Migrating the projects wasn’t a hard switch. It was incremental, messy in the middle, and completed at different speeds across different projects. That pattern offers a useful template for anyone considering the same move.

Ramírez didn’t rip out mypy and replace it with ty in a single PR. Instead, he added ty alongside mypy and ran both checkers in parallel. Four of his five major repos still operate this way. Only SQLModel has fully dropped mypy.

LiteLLM Got Owned, and Your Dependencies Might Be Next

Tim Hopper — Tue, 24 Mar 2026 00:00:00 +0000

Earlier today, someone published malicious versions of litellm (versions 1.82.7 and 1.82.8) to PyPI. No corresponding release appeared on GitHub. The package was uploaded directly to PyPI, bypassing the normal release process, which points to a compromised maintainer account or token.

Note

OpenAI to Acquire Astral

Tim Hopper — Thu, 19 Mar 2026 00:00:00 +0000

OpenAI announced today that it will acquire Astral, the company behind uv, Ruff, and ty. The Astral team will join OpenAI’s Codex group after the deal closes, subject to regulatory approval.

What this means for Codex

Codex, OpenAI’s coding agent, has grown to over 2 million weekly active users, with 3x user growth and 5x usage increase since the start of 2026. Acquiring Astral gives OpenAI direct ownership of tools that millions of Python developers already depend on. OpenAI plans to integrate Astral’s tools more deeply into Codex so the agent can interact with the toolchain developers already use.

Charlie Marsh on uv, Coding Agents, and the Changing Open Source Contract

Tim Hopper — Tue, 24 Feb 2026 12:00:00 -0500

Charlie Marsh (founder of Astral, creator of ruff, uv, and ty) joined Michael Chow and Wes McKinney on The Test Set. They covered uv’s adoption strategy, how coding agents are changing Astral’s development process, and what’s happening to open source when writing code becomes cheap.

uv’s compatibility layer was the point

When uv first shipped, it only had uv pip install and uv venv. Some people found this odd. Charlie says it was deliberate:

Seven Claude Code Skills for Python from the Creator of spaCy

Tim Hopper — Mon, 16 Feb 2026 08:00:00 -0500

Matthew Honnibal, co-founder of Explosion and creator of spaCy, has published a collection of Claude Code skills for Python development. It’s one of the more thoughtful skill collections I’ve seen.

The collection ships as slash commands: markdown files you place in ~/.claude/commands/. When you type /<name> in Claude Code, the file’s contents are injected as instructions. Think of them as reusable prompts that give Claude a specific methodology for a task, rather than leaving it to improvise.

Pydantic Monty: A Secure Python Interpreter for AI Agents

Tim Hopper — Fri, 06 Feb 2026 10:00:00 -0500

Pydantic has released Monty, a minimal Python interpreter written in Rust for safely executing LLM-generated code.

AI agents that generate code face a tradeoff: trust the generated code completely, or spin up containers for isolation. Containers are slow and resource-intensive. Trusting arbitrary code is risky. Monty sidesteps both by sandboxing execution at the interpreter level, blocking dangerous operations while running Python in microseconds. The handbook’s guide on setting up a Python project for Claude Code and modern Python project setup for AI assistants provide additional context for working with AI agents in Python projects.

FOSDEM Talk: Modern Python Monorepo with uv, Workspaces, and prek

Tim Hopper — Thu, 05 Feb 2026 08:00:00 -0500

Jarek Potiuk, Apache Airflow PMC member and the project’s top committer, gave a talk at FOSDEM 2026 on how Airflow manages its massive Python monorepo. The recording is now available.

Airflow ships over 120 separate Python distributions from a single repository, with 700+ dependencies and 3,600+ contributors. That scale forced the team to modernize their tooling. The talk walks through how they did it.

uv Workspaces for Monorepo Management

The new setup centers on uv workspaces. Rather than splitting 120 distributions across separate repositories or bundling everything into an unmanageable monolith, Airflow uses uv’s workspace feature to let distributions depend on each other via local sources instead of pulling from PyPI. The handbook’s guide to setting up a Python monorepo with uv workspaces covers the same pattern at a smaller scale.

uvx.sh: Install Python tools without uv or Python

Tim Hopper — Thu, 22 Jan 2026 12:00:00 -0500

Astral has released uvx.sh, a service that generates installation scripts for any Python tool on PyPI. With a single curl or PowerShell command, users can install tools like ruff or pytest without having uv or Python already installed on their system.

How It Works

uvx.sh dynamically generates installation scripts for any PyPI package. The URL pattern is simple:

uvx.sh/{package}/install.sh     # macOS/Linux
uvx.sh/{package}/install.ps1    # Windows

For example, to install ruff:

Teaching Claude Code Quality Patterns with a Custom Skill

Tim Hopper — Fri, 09 Jan 2026 09:00:00 -0500

Dagster’s dignified-python-313 skill guides Claude Code to write Python 3.13 code that matches their project conventions.

What It Covers

Modern Python 3.13 Patterns: Use native type syntax (list[str], str | None) instead of older alternatives. Skip from __future__ import annotations since Python 3.13 doesn’t need it.

CLI Development: Build Click interfaces with proper error handling. Use click.echo() for output, direct errors to stderr, and treat CLI commands as error boundaries that catch exceptions and exit with SystemExit(1).

ty is Built with AI

Tim Hopper — Fri, 02 Jan 2026 08:00:00 -0500

Tool creators are building their tools with AI coding assistants.

Boris Cherny, creator of Claude Code, didn’t open an IDE in December but wrote 200 PRs with Claude Code. Charlie Marsh, creator of ruff, uv, and ty, noted that all his PRs to ty were created with Claude Code. The tools building themselves.

Integration with Python Tooling

The handbook’s Modern Python Project Setup Guide for AI Assistants provides structured guidance so AI tools default to uv and modern patterns rather than falling back to pip commands.

How uv Achieved Its Performance

Tim Hopper — Fri, 26 Dec 2025 18:00:00 +0000

Andrew Nesbitt’s “How uv got so fast” explains that uv’s speed comes less from Rust and more from eliminating work entirely.

Speed Through Elimination

Rather than optimizing slow code paths, uv just removes them:

No .egg support
No pip.conf
No bytecode compilation by default
Ignoring requires-python upper bounds reduces resolver backtracking

Rust-Independent Optimizations

Many of uv’s performance gains could work in pip:

Parallel downloads instead of sequential
Smart HTTP range requests for metadata

uv got fast by launching when PEP 658 infrastructure was ready and by skipping backward compatibility requirements that slow down pip.

ty: Astral's New Python Type Checker Released

Tim Hopper — Tue, 16 Dec 2025 22:43:00 -0500

Astral released ty, a Python type checker written in Rust, today. The company behind uv and Ruff designed ty as an alternative to mypy and pyright, with performance as a primary focus.

Speed Benchmarks

According to Astral’s benchmarks:

ty checks the home-assistant project in 2.19 seconds (20x faster than mypy’s 45.66 seconds)
After editing a file in PyTorch, ty recomputes diagnostics in 4.7ms (80x faster than pyright’s 386ms)

Key Features

ty includes several design choices that distinguish it from existing type checkers:

Teaching LLMs Python Best Practices

Tim Hopper — Fri, 21 Nov 2025 09:00:00 -0500

Large language models possess extensive Python knowledge from training data, yet they consistently struggle with modern tooling practices. Despite being trained on massive amounts of Python code, frontier models often default to outdated patterns like direct python or pip commands instead of using virtual environments and modern tools like uv.

how is it, that despite every frontier LLM being insanely python maxxed they rarely use virtural envs, and even adding rules like "we are using uv, do everything with uv" they ignore it and think the system python is broken. like, every time. that's actually an accomplishment

Claude Code Hooks for uv Projects

Tim Hopper — Tue, 11 Nov 2025 06:00:00 -0500

Claude Code supports custom hooks that guide the AI agent toward project-specific workflows. For Python projects using uv, hooks can prevent Claude from falling back to pip and python commands.

Note

This post builds on the interceptor approach for teaching AI agents about uv. Interceptors provide runtime feedback; hooks prevent problematic commands before execution.

Sync with uv: Eliminate Pre-commit Version Drift

Tim Hopper — Fri, 26 Sep 2025 15:01:00 -0400

anaging tool versions across multiple configuration files creates persistent headaches in Python development. When you upgrade ruff in your pyproject.toml, you must remember to manually update the pre-commit hook version in .pre-commit-config.yaml. This version drift causes inconsistent behavior between local development and pre-commit checks.

The sync-with-uv library solves this by automatically synchronizing tool versions between uv’s lockfile and .pre-commit-config.yaml.

The Problem

Consider this common scenario:

# pyproject.toml
[dependency-groups]
lint = ["ruff>=0.1.0", "mypy>=1.0.0"]

# .pre-commit-config.yaml
repos:
- repo: https://github.com/astral-sh/ruff-pre-commit
  rev: v0.1.5  # Must manually sync with pyproject.toml
  hooks:
    - id: ruff

When uv lock --upgrade updates ruff to 0.1.8, the pre-commit hook stays pinned to 0.1.5. This creates confusing behavior where local checks differ from pre-commit results. The same gap applies to mypy and any other tool pinned in both files.

Analysis of the New Wave of Python Type Checkers

Tim Hopper — Wed, 17 Sep 2025 20:31:00 -0400

Rob Hand’s comparison of emerging type checkers is the first comprehensive look at three new Rust-based tools: ty (Astral), pyrefly (Meta), and zuban (David Halter).

Note

This analysis was published in September 2025 when ty was pre-beta (known internally as Red-Knot). ty’s typing-spec conformance has improved significantly since then, from roughly 15% at the time to 86.5% (122/141 tests, ty 0.0.65, July 2026). For current conformance scores across all major type checkers, see How do Python type checkers compare?.

prek: pre-commit, but fast

Tim Hopper — Tue, 16 Sep 2025 10:40:00 -0400

pre-commit is an essential tool in my development workflow for running ruff and other tools. However, nobody wants to wait for their commits to be saved, and pre-commit isn’t always the fastest.

prek is a Rust-based drop-in replacement that runs 10x faster while using half the disk space.

Replacing pre-commit with prek is painless:

Install with uv tool install prek
Run pre-commit uninstall && prek install

That’s it. No configuration changes, no compatibility issues.