Charlie Marsh on uv, Coding Agents, and the Changing Open Source Contract
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:
A lot of people were like, oh, that’s weird. Why is it uv pip? It should just be uv install. But it was very intentional. That’s kind of like our compatibility layer.
The full uv run / uv lock / uv sync interface came six months later, with the goal that uv run would resolve dependencies, install Python, create a virtual environment, and run the command without the user thinking about any of it.
Python packaging standards made uv possible
Charlie credits the Python packaging PEPs for making uv feasible at all:
I actually feel kind of lucky because we started building uv at a moment in time where it became very practical to build. There was a lot of work that happened in standards in the years that preceded working on uv. I think it would have been a lot harder to build uv a few years before.
Astral is now working with NVIDIA and PyTorch on a proposal called “wheel variants to encode things like CUDA driver version into package metadata, a longstanding pain point that currently can’t be expressed in the packaging spec.
“More productive but a lot less fun”
The episode title comes from a Charlie tweet that keeps getting quoted back at him. He now runs 3-4 Claude Code sessions in parallel as his primary workflow, for Python and Rust alike:
It’s not always the case that it can do any one thing way faster or way better than I could, but I can parallelize or multitask a lot more.
The productivity gains came with a cost he didn’t expect. His own team told him they trusted his PRs less:
People on the team felt like they couldn’t trust my PRs as much anymore. Previously they didn’t feel like they had to review them super closely. They trusted my work a lot. And now if I’m putting up a PR that’s done by Claude Code, empirically I’m putting up code that has patterns or mistakes or issues in it that I just wouldn’t have put up before.
Asked whether his own confidence held steady, he said: “No, definitely gone down. I think I’m still a lot more productive, but this is why it’s a very challenging moment.”
Astral’s response has been pragmatic: more lint rules (they already use clippy-pedantic for Rust), better CLAUDE.md files to guide agents away from repeated mistakes, and investment in tooling that builds confidence in changes faster, like ty’s ecosystem report infrastructure that diffs diagnostics across projects for every PR.
The open source contract is breaking
Both Charlie and Wes described a growing problem with AI-generated contributions: people drop an issue into Claude Code, get a PR, and submit it without validating correctness or thinking about architecture.
Writing the code is not expensive. That is the cheap and easy part. The hard thing is validating correctness, thinking hard about the architecture, all these things that come downstream of writing code.
Wes connected this to The Lisp Curse: when building your own solution costs almost nothing, the incentive to collaborate erodes. Why negotiate with maintainers when you can fork, fix, and move on? Charlie noted the compounding risk: one person forking is fine, but a year of everyone forking and nobody building foundational tools has consequences nobody’s measuring.
uv as the killer app for coding agents
Wes made a case for uv that had nothing to do with speed:
One of the reasons I’ve become such a big fan of uv is actually because of AI. Now I can say, here’s my Python script, just uv run this, set it and forget it. I think that feature was developed pre-AI, but is also the killer app for making self-contained runnable things that are outputted by coding agents.
This tracks with what we’ve seen. Step zero of using Claude Code with Python is making sure it reaches for uv instead of pip. Charlie confirmed: the models are getting better at this, partly because the AI labs themselves are uv users.
What’s resilient
Charlie’s framing for what to build next centers on what survives regardless of how AI reshapes development:
Static analysis, really good verification, really fast verification — that’s in my opinion very resilient. Typing will only become more important because it’s a very fast way to validate correctness.
He mentioned standalone Python binaries, test infrastructure, and possibly a runtime as areas Astral is considering. The question behind all of it: “If we wanted Python to remain a great choice for agents, what problems do we have a responsibility to solve?”
Listen to the full episode on The Test Set.