sethserver.com Subscribe
An orange robot with a yellow top holds a smaller turquoise and purple robot in its arms against a mint green background. The larger robot has wide circular eyes, a triangular nose, and a gritted teeth expression, with yellow accordion-style arms and circular joints at the knees.

OpenAI Bought Astral - and my fav tool uv

By Seth Black • Updated: March 23, 2026

Python · 4 min read

Like this kind of writing? Get one email a week with notes on startups, AI, and the occasional strong opinion about Python: subscribe to the newsletter.

Man, do I enjoy using uv. It was one of the few tools that immediately became a habit. I'm old so it takes me a minute to get used to new tools.

So yeah, I saw the news: OpenAI is acquiring Astral, the folks behind uv, Ruff, and ty. Part of me is happy because I like good tools and I like when smart engineers get paid. Another part of me gets that familiar "uh oh" feeling. The "Oracle buys MySQL" feeling. Time will tell.

Astral's tools are real infrastructure now. If you write Python at work, there's a decent chance you already depend on them directly, or you depend on a project that depends on them. That's why this kind of acquisition hits differently than "big company bought a small devtools startup." This is more like: someone bought part of the plumbing.

Why uv became my default

For years, Python dependency management has been broken in very predictable ways. Pick your poison: pip, venv, pip-tools, Poetry, Conda, or just install it globally and hope.

The pain usually looks like one of these:

uv feels like it was built by someone who ships software and hates waiting.

A few things I like:

Here's the kind of setup I mean. Nothing fancy. Just solid and correct:

uv venv
source .venv/bin/activate
uv pip install -r requirements.txt

That's already a win for older repos. You don't have to rewrite everything on day one.

Or if you're living in pyproject.toml land:

uv sync

That one command is where uv starts to feel like a modern tool instead of a pile of scripts. On a team, "everyone runs uv sync" is easy to enforce. It's simple to document, review, and bake into CI.

A practical pattern I've used:

  1. Put dependencies in pyproject.toml.
  2. Commit the lockfile (or whatever your workflow uses to freeze versions).
  3. In CI, do a clean sync and run tests.

Example CI-ish flow:

uv sync --frozen
uv run pytest -q

The --frozen flag matters. It fails CI if someone forgot to update the lock. Annoying once, then it saves you from months of drift.

uv being fast and strict will surface problems you were ignoring. You might discover you were relying on unpinned transitive dependencies. Or that your build depends on a system library you never documented. That's not uv being mean. That's uv being honest.

Speed changes behavior. If installs are slow, people avoid recreating environments. If that's painful, your "clean build" only happens on release day, right before a fire.

My trust issues are earned

I worked at a SaaS company that claimed it used AI to automate financial tasks. A few weeks in, I found out the "AI" was mostly spreadsheet column mapping and data formatting. Support teams were weirdly defensive about showing how anything worked. I was literally told to come watch people work in an office in South Asia.

Code review confirmed the vibe: it was Excel with extra steps.

So when I hear "developer-first philosophy" in an acquisition announcement, I think: what's the incentive structure now? Who pays for what? What gets deprioritized? What quietly rots?

Open source tools don't die with a bang. They rot:

I've watched this happen with internal tools too. The team that owns the "boring but critical" thing gets reassigned to the shiny thing. The boring thing keeps running, until the day it doesn't. Then everyone acts surprised.

Acquisitions don't guarantee this, but they increase the odds. The buyer has their own goals. Astral wanted to make great Python tooling. OpenAI wants to make Codex better and own the developer loop. Those goals can overlap. They can also collide.

What I hope happens next

Here's what I want:

A few specifics that would build trust fast:

  1. Clear governance
    Who is the maintainer team now? What happens if priorities shift? Is there a public commitment to keeping the projects open and actively maintained?

  2. Public policy on telemetry
    If there's telemetry, say so. If there isn't, say so. "Trust us" is not a policy.

  3. Reproducibility stays non-negotiable
    uv should keep pushing toward deterministic environments. Lockfiles should stay first-class. CI flags like --frozen should keep working.

  4. No forced Codex coupling
    Integrations can exist. Forced coupling is where tools stop being tools.

And if OpenAI wants Codex to run tools across the dev workflow, great. Just don't turn my wrench into a smart wrench that needs a login.

I'll keep using uv until it gives me a reason not to. I really hope it doesn't.

-Sethers

Share this post
Newsletter

One email, once a week.

Notes on databases, systems, and the occasional strong opinion about Python. No spam, unsubscribe anytime.

Seth Black
Written by

Seth Black

Engineer and founder based in Texas. Writes about databases, AI, and running things in production. Embeds in small teams as lead engineer.

More from Python

View all →
Python

Python Logging Done Right

Nov 18, 2026
Python

Python Pydantic Validation: Stop Writing Manual Checks

Mar 04, 2026
Python

Python asyncio Recipes

Mar 04, 2026