Astral joins OpenAI

0:00

01:05:08

Links Episode Deep Dive Transcript

OpenAI just acquired Astral, the company behind uv, Ruff, and ty. And if your first thought was "wait, is uv toast?", you are not alone. But here's the twist Charlie Marsh shared with me: he thinks they may ship more open source at OpenAI than they ever did at Astral. On this episode, we get into the acquisition, the mixed feelings, the future of your favorite Python tools, and what it's like to build right at the center of the AI universe.

Episode Deep Dive

Guest Introduction and Background

Charlie Marsh is the founder and former CEO of Astral, the company behind some of the most widely used developer tools in the modern Python ecosystem: Ruff (a linter and formatter), uv (a package manager and Python version manager), and ty (a type checker currently in development). Astral's calling card has always been high performance, with its tools written in Rust and known for being dramatically faster than the tools they replace. Charlie started Ruff as a side project, published a blog post when it reached proof-of-concept stage, and was surprised by how strongly the community responded to both the ideas and the speed. He turned it into a full-time effort and founded Astral in late 2022, deliberately keeping the team small while the tools grew into ecosystem staples.

This is not Charlie's first appearance on Talk Python. He has been on the show to talk about Ruff, then uv, and then pyx, so this conversation continues a journey that listeners have followed across several big releases. The news this time is bigger and different: OpenAI acquired Astral, and Charlie now continues to lead the Astral team from inside OpenAI, working alongside the Codex group. In this episode he speaks candidly about the acquisition, the mixed reactions to it, what stays the same for your favorite tools, and what it is like to build developer tooling right at the center of the AI world.

What to Know If You're New to Python

This episode lives at the intersection of Python's tooling layer and the fast-moving world of AI-assisted coding. A little background on how Python projects are built, run, and checked, plus what it means to "build with agents," will help you follow the conversation and get the most out of it.

Python packaging and virtual environments: Python projects depend on third-party libraries, and tools like uv install those dependencies, lock exact versions, and create isolated virtual environments so projects do not interfere with each other. uv is the star of this episode, so understanding why dependency management is hard makes its appeal obvious.
Linters, formatters, and type checkers: A linter flags suspicious code, a formatter enforces a consistent style automatically, and a type checker verifies that your types line up before you run anything. Astral's Ruff covers the first two and ty is its take on the third, so these categories come up throughout the discussion.
CPython and prebuilt Python distributions: CPython is the reference implementation of Python that most people run. Astral's Python build standalone project ships prebuilt, relocatable versions of CPython so a tool can download and unzip a working Python rather than compiling one, which Michael calls the "secret sauce" behind uv.
Rust as the language for fast Python tooling: Rust is a systems programming language that produces very fast, memory-safe binaries. Astral writes its Python tools in Rust, and part of why OpenAI was interested is that the team sits at the Python and Rust intersection.
Agentic coding (building with AI agents): An AI coding agent does not just autocomplete a line; it can read your codebase, run your tests, edit files, and self-correct toward a goal. Charlie and Michael spend much of the episode on what it means to build software this way, with OpenAI's Codex as the running example.

Key Points and Takeaways

OpenAI acquired Astral, and the tools are not going away The central news of this episode is that OpenAI acquired Astral, the maker of uv, Ruff, and ty. The deal was announced in March 2026 (March 19, per Michael's records), and Charlie and the team joined OpenAI about a month before this recording. The loudest worry in the community was some version of "is uv toast?", and pushing back on that fear is the thing Charlie most wanted to do. He stresses that the tools remain a priority, that the team continues to build them, and that he still leads the Astral group, now inside OpenAI on the Codex team. Rather than ask people to take that on faith, he frames the real proof as actions over time. His closing message is that if you have liked the work and how the team runs its repositories and community, you should be happy with how this plays out.

The twist: possibly more open source at OpenAI than at Astral The most counterintuitive idea in the conversation is Charlie's belief that the team may ship more open source at OpenAI than it did as an independent company. The reasoning is about constraints. As a venture-funded business, Astral was increasingly having to think about commercialization, which meant the work had to stay coupled to a realistic commercial vision and was largely focused on just Python. Inside OpenAI, that monetization pressure is off and there is broad company alignment around shipping open source. Charlie is careful to say this is hard to prove and that time will tell, but sitting where he is now, he genuinely expects the amount of open source they release over the next year to possibly exceed what they would have done otherwise. He also notes the team now has room to be more ambitious and even experiment beyond Python.

Why OpenAI wanted Astral Charlie lays out several overlapping reasons OpenAI was interested. First, there is a great deal of both Python and Rust at OpenAI, and Astral works precisely at that intersection while also being a heavy user's worth of tooling for the company itself. Second, OpenAI is a big user of Astral's tools, so the team can find where their tooling falls short at scale and fix it for everyone. Third, both sides want to explore how tools should change as software is increasingly built with agents, which is easier when you can co-design the models, the harness, and the tools together. Finally, Charlie credits OpenAI's respect for what a small team accomplished and the belief that, on a bigger platform, that team could have an even bigger impact. He frames OpenAI as, among other things, a huge user of Astral tooling.

What changes and what stays the same for uv, Ruff, and ty For the tools people depend on every day, Charlie's repeated answer is that a lot stays the same. He looked at the data and found the release rate held roughly constant across the whole process, from before the acquisition through the intermediate window to after. The current goal is actually to ship a backlog of highly requested features that never quite fit the old roadmap, with locked tool installs as an example: being able to run a tool install that points at a git repository and reuses a published lock file so you get the exact same dependencies. ty remains on track for a stable release later this year. The main structural change is on the commercial side rather than the open source tools themselves.

Winding down pyx, but open sourcing the GPU work pyx was Astral's hosted Python registry, essentially the server to the uv client and the first piece of a planned commercial platform aimed at problems uv could not solve alone, like private package distribution, security scanning, and the considerable pain of GPU, CUDA, and PyTorch installs. With the acquisition, the team is winding down the hosted pyx service. The piece Charlie is most excited about is that the work they did around GPU indexes and prebuilt wheels will be open sourced, with the artifacts made freely available. As an independent company they had to figure out how to build a business around that work; now they can simply release it because it is a good thing to have out in the world. People who worked on pyx are being moved onto other efforts within the Astral suite.

ty and OpenAI as a testing ground for a type checker at scale Charlie sees a clear upside in having OpenAI's enormous and varied codebase to harden ty against, with very different styles of code across research and applied work. The original ty beta milestone was using it internally on Astral's own code, mostly pyx, which is only a moderately sized Python codebase. Now the goal is to get ty ready to run as a default across more of OpenAI's code before the stable release, which helps the team prioritize which issues are real and which can wait. As Charlie puts it, if you can get it running here at scale with sufficient coverage and great performance, there is a good chance it will run anywhere. Michael notes that ty and Meta's Pyrefly stand well above older type checkers from a different era, with ty focused on delivering fast autocomplete and editor completion across large projects.

Python build standalone, the secret sauce that lives outside Python Michael argues that an underappreciated reason uv works so well is Python build standalone: uv lives outside of Python rather than inside it. The project ships prebuilt, relocatable CPython so that on your machine you download, unzip, and run, with no need to compile Python yourself. Charlie describes it, half-jokingly, as kind of a fork of CPython, really just CPython with a set of patches to the build system to make it relocatable rather than any change to the implementation. The team wants to upstream as much as possible to CPython, since fewer deviations make the project easier to maintain and benefit everyone. Two ongoing priorities are removing quirks that make the builds feel different and pushing performance, including profile guided optimization rather than a JIT, with a goal of releasing the same day CPython does. This is the Python you get when you ask uv to install a version you do not already have.

Using AI coding agents well is a skill you have to learn A recurring theme is that working effectively with agents is a genuine engineering skill, not a switch you flip. Charlie admits he was not really using agents to build software until around December, mostly relying on tab completion, until a wave of people went home for the holidays, had time to experiment, and came back changed. He says he has not really typed out code in the editor in months, using it now mostly to read code or edit docs and changelogs. He is honest that he went through a rough patch he half-jokingly calls AI psychosis, putting up pull requests that were genuinely bad while believing they were good. The lesson he takes from it is that these tools reward learning and good workflows, and that the models getting better steadily reduces how much micromanagement they need. Michael agrees that it is an engineering skill, on par with coding or testing.

github.com/openai/codex

The joy, the loss, and the redemption of building with agents Charlie is reflective about what changes emotionally when an agent writes the code. He worried he would be stuck choosing between enjoying his work and shipping faster, since early on agentic coding felt more productive but less fun. He acknowledges losing something real, like no longer thinking as hard about the layout of a data structure. But he counters with concrete upsides: he has not dealt with a rebase conflict in months, and the cost of experimentation, while not zero, is now very low. His favorite example is a change in uv to content-address the cache so overlapping files across many package versions are not stored repeatedly, the kind of hard idea he can now hand to Codex as a goal like reducing memory consumption by at least one percent, then review and judge. Michael adds that what he actually loves is building things, a point Charlie echoes by calling this an unusually high-leverage time to be a software engineer, since the skills act as a multiplier on your instincts.

Why two people describe AI coding so differently Michael offers a theory for why the same activity produces wildly different reports. The people who go all in, learn the skill, pay for the top model, and stick with it tend to have great experiences, while skeptics who try a free, lower-tier agent once tend to have a bad experience that reinforces their doubt. The two camps believe they are talking about the same thing, but they are not doing the same thing. Charlie agrees there is something to this and is candid that everyone has biases, including him as an OpenAI employee, but that it is easy to find ways to confirm whatever you already believe. He thinks you do yourself a disservice by being completely dismissive, because the skill takes time and even develops into an intuition for sensing when a model is wrong. As a leader, he pushed agents on his team for a pointed reason: many of their users build with agents, so the team has to understand that experience.

github.com/openai/codex

Agents are reshaping open source maintenance One of the more sobering threads is what cheap generation does to open source projects. Charlie notes the cost of putting up a plausible pull request is now basically zero for an arbitrary contributor, while it still takes maintainers something like an hour to read, verify, and truly understand the code, a part that has not gotten much easier. The team also sees issues that are clearly raw LLM output, where asking a follow-up question just gets the question pasted into an agent and the answer pasted back. He imagines a near future where ten people a day publish a new, agent-built Python package manager, some good and some bad, and he is not sure he could tell them apart. Michael's response is that this makes reputation, community, and stewardship more valuable, pointing to how Django sustains conferences and fellows. Michael also praises Ruff in agent workflows, where having the agent run Ruff format and Ruff check gives it another layer to catch its own mistakes in a non-compiled language like Python.

What it is like to work inside a frontier AI lab Charlie gives a rare look at life inside OpenAI. Internally, Codex has effectively taken over, including among people who are not software engineers, with a significant share of the desktop app's users being other kinds of knowledge workers; a teammate joked it must be the most dogfooded app of all time. That creates a powerful, constant feedback loop across the models, apps, and hardware. He says you quickly become a person who believes the models will keep getting very good very quickly, especially after talking with research about data center buildout and algorithmic efficiencies. He also finds it strange to watch outsiders speculate about the company in ways that, from the inside, are often confident but wrong. One of his investors predicted a frontier lab would not feel less crazy than a startup, and Charlie thinks that was right.

The founder's journey and the human weight of the decision The episode is also a personal story. Charlie started the company in late 2022 around the same time his first child was born, and his son arrived about seven weeks early, leaving him fixing issues from the hospital. He had quit his job to start a company without yet knowing what it would be, with a child on the way, and his father was understandably skeptical. He recalls signing the letter of intent at his niece's birthday party and walking up to tell his mom he had just signed an LOI with OpenAI. He is candid that the stakes grew heavier over time as employees with families joined the journey, and that a real motivation for the deal was delivering a good outcome to them. A month in, he feels markedly less existential stress and more like he gets to focus on pure product. Michael relates, recalling quitting his own job eleven years ago to start Talk Python with daughters heading to college and a mortgage to cover.

astral.sh

Mixed feelings and keeping the social contract with users Charlie does not gloss over the negative reactions to the acquisition. He says the range of feelings reminded him of when the team first formed a company, with some people excited, some convinced the project should never be part of a company, and some worried about its future. His guiding principle is that words alone will not convince skeptics; you earn trust through actions over time. As a team, they ran an exercise imagining a year out and writing down what they want to be able to say about the tools, starting with the obvious commitment that they remain open source, along with values like quality over quantity. He frames this in terms of social contracts with users rather than financial ones. His stated goal is that even people who were skeptical at the announcement will eventually agree the team did right by its users.

Interesting Quotes and Stories

On the question hanging over the whole episode, whether the tools are safe:

"If you like the work we've done, and you've been happy with how we've run our repos and our community, then I think you will be happy with how things play out." -- Charlie Marsh

The twist that surprised a lot of listeners:

"I genuinely think it's possible that we end up writing more open source here than we did at Astral." -- Charlie Marsh

On why he is not trying to win the argument with a press release:

"You won't convince everybody just with words. And what you really have to do is convince people with actions over time." -- Charlie Marsh

"The story of this acquisition hasn't really been told yet." -- Charlie Marsh

A small, human moment from the deal itself:

"I signed that at my niece's birthday party. And I kind of went up to my mom and I was like, yeah, I just signed an LOI with OpenAI." -- Charlie Marsh

On the strangeness and thrill of this era of software:

"What a time to be writing software." -- Charlie Marsh

On learning to use the tools, including the embarrassing part:

"I won't say full blown AI psychosis, but putting up PRs that were definitely bad that I thought were good." -- Charlie Marsh

"It's an engineering skill, just like coding or testing." -- Michael Kennedy

On how deeply AI tools have soaked into OpenAI:

"It must be the most dogfooded app of all time." -- a Codex teammate, relayed by Charlie Marsh

On what cheap generation does to open source maintainers:

"The cost of putting up a plausible PR is basically zero for an arbitrary contributor ... and then it takes us like an hour to read and understand the code." -- Charlie Marsh

On why the joy of building can come back:

"The cost of experimentation or just trying something, it's not zero, but it's very low." -- Charlie Marsh

Key Definitions and Terms

uv: Astral's package manager and Python version manager, described in the episode as roughly Node plus npm for Python because it both manages dependencies and provides and runs Python itself. See github.com/astral-sh/uv.
Ruff: Astral's Rust-based linter and formatter for Python, known for being extremely fast and useful as a guardrail in AI coding workflows. See github.com/astral-sh/ruff.
ty: Astral's type checker, still in development with a stable release targeted for later this year, focused on fast autocomplete and editor completion across large codebases. See github.com/astral-sh/ty.
pyx: Astral's hosted Python registry, the server-side counterpart to the uv client and the first piece of its commercial platform; the hosted service is being wound down after the acquisition.
Python build standalone: A project that ships prebuilt, relocatable CPython distributions so tools can download and unzip a ready-to-run Python instead of compiling one; it is the runtime uv installs for you. See github.com/astral-sh/python-build-standalone.
CPython: The standard reference implementation of Python that most developers run; Python build standalone is essentially CPython with build-system patches. See github.com/python/cpython.
Codex: OpenAI's agentic coding tool and desktop app, the team Charlie now works alongside, used heavily inside OpenAI even by non-engineers. See github.com/openai/codex.
Pyrefly: Meta's Python type checker, cited as the other modern, high-performance type checker in the same tier as ty. See github.com/facebook/pyrefly.
Letter of intent (LOI): An early, mostly non-binding document that signals serious intent to do a deal before the final acquisition terms are confirmed.
Profile guided optimization (PGO): A compiler technique that uses data from running a program to produce a faster build, used to make Python build standalone fast without resorting to a JIT.
Dogfooding: Using your own product internally as a real user; Charlie describes Codex as possibly the most dogfooded app of all time at OpenAI.
Agentic programming: Building software with AI agents that can read a codebase, run tests, edit files, and self-correct toward a goal, rather than just autocompleting code.

Learning Resources

If this episode left you curious to go deeper, here are a few courses that map closely to its themes of agentic coding, dependency management, and type-safe Python. They are good next steps whether you want to build with agents more effectively or strengthen the tooling foundations the conversation kept returning to.

training.talkpython.fm/courses/agentic-ai-programming-for-python: Learn to work with AI that behaves like a skilled junior developer, understanding your codebase, running tests, and building features, which is exactly the agentic workflow Charlie and Michael describe.
training.talkpython.fm/courses/managing-python-dependencies-with-pip-and-virtual-environments: Master dependency management and virtual environments, the exact problem space uv was built to make fast and painless.
training.talkpython.fm/courses/python-type-hint-course-with-hands-on-examples: Get fluent with Python typing and the frameworks built on it, which gives useful context for why fast type checkers like ty matter.

Overall Takeaway

The headline of this episode is an acquisition, but the heart of it is a question of trust. OpenAI now owns Astral, and yet the most reassuring signal is not a promise but a pattern: the release cadence held steady, the roadmap is full of long-requested features, the GPU work is heading to open source, and the team has written down what it wants to be true a year from now. Charlie's honest framing, that you convince people with actions over time rather than words, is the right lens for both the tools and the broader moment he is describing. Underneath the news sits a bigger story about what it means to build software at all right now, when an agent can write a plausible pull request in a minute and the scarce, valuable thing becomes judgment, reputation, and community. For anyone who loves Python's tooling or wonders how AI is reshaping the craft, this conversation is a grounded, optimistic map of where things are heading, and a reminder that the people who lean in, learn the new skills, and keep their standards high are the ones who get to shape what comes next.

Links from the show

Guest
Charlie Marsh: github.com

The announcement: astral.sh
OpenAI: openai.com
uv: github.com
ty: github.com
Ruff: github.com
pyx: astral.sh
Codex team: openai.com
Anthropic did something similar by acquiring Bun: www.anthropic.com
Daily Stars Explorer: emanuelef.github.io

Agentic AI Programming for Python: training.talkpython.fm
Python Web Security: OWASP Top 10 with Agentic AI: training.talkpython.fm

Episode #552 deep-dive: talkpython.fm/552
Episode transcripts: talkpython.fm

Theme Song: Developer Rap
🥁 Served in a Flask 🎸: talkpython.fm/flasksong

---== Don't be a stranger ==---
YouTube: youtube.com/@talkpython

Bluesky: @talkpython.fm
Mastodon: @talkpython@fosstodon.org
X.com: @talkpython

Michael on Bluesky: @mkennedy.codes
Michael on Mastodon: @mkennedy@fosstodon.org
Michael on X.com: @mkennedy

Episode Transcript

Collapse transcript

WebVTT format On GitHub

00:00 OpenAI just acquired Astral, the company behind uv, Ruff, and ty.

00:04 And if your first thought was, wait, is uv toast?

00:08 You're not alone.

00:10 But here's the twist Charlie Marsh shared with me.

00:13 He thinks they may ship more open source at OpenAI than they ever did at Astral.

00:18 On this episode, we get into the acquisition, the mixed feelings, and the future of your

00:22 favorite Python tools, and what it's like to build right at the center of the AI universe.

00:27 This is Talk Python To Me, episode 552, recorded June 2nd, 2026.

00:51 Welcome to Talk Python To Me, the number one Python podcast for developers and data scientists.

00:56 This is your host, Michael Kennedy.

00:58 I'm a PSF fellow who's been coding for over 25 years.

01:02 Let's connect on social media.

01:04 You'll find me and Talk Python on Mastodon, BlueSky, and X.

01:07 The social links are all in your show notes.

01:10 You can find over 10 years of past episodes at talkpython.fm.

01:13 And if you want to be part of the show, you can join our recording live streams.

01:17 That's right.

01:18 We live stream the raw uncut version of each episode on YouTube.

01:21 Just visit talkpython.fm/youtube to see the schedule of upcoming events.

01:26 Be sure to subscribe there and press the bell so you'll get notified anytime we're recording.

01:31 This episode is brought to you by Sentry.

01:33 Don't let those errors go unnoticed.

01:34 Use Sentry like we do here at Talk Python.

01:36 Sign up at talkpython.fm/sentry.

01:40 Charlie Marsh, welcome back to Talk Python and me.

01:42 Lovely as always to have you on the show.

01:44 Thank you.

01:44 Yeah, it's great to be on the show again.

01:46 It's always a pleasure.

01:47 We talk about so many interesting things.

01:49 We've kind of shared the journey.

01:51 your journey together a little bit in the sense that I had you on originally to talk about Ruff

01:55 and how cool and how fast it was. And when uv came out, I'm like, oh, you have to, we have to have

01:59 you on the show to talk about uv and all these different things. pyx as well. And now something,

02:05 something a little bit different, but awesome. I mean, congratulations that you're now part of

02:10 OpenAI. I know that there's mixed feelings out in the universe about this, and we're going to talk

02:16 about that but personally just happy for you this must be a dream come to true in some ways and

02:22 yeah just congrats thank you yeah thanks so much it's funny it's like uh yeah a lot of the maybe

02:27 all of the biggest moments for the for the company have been punctuated by appearances on talk python

02:33 so uh we have really been we have we have been on this journey together certainly all of our big

02:39 you know like product and tool releases i'm excited to come on here and yeah and talk more about the

02:43 acquisition, joining OpenAI, all that kind of stuff. So yeah, thanks. Thanks for having me on

02:47 again. And yeah, it's been, it's been fun. Hopefully we can do some more episodes too.

02:51 You're welcome. And you know, I think having you on the show, especially now, certainly for uv,

02:57 but even more so now, kind of like a public service to the community type of thing. Cause

03:04 there's a lot of people out there just wondering what tools should they use? How does this change

03:08 this thing that I've become so dependent upon and love so much and things like that. So I think just

03:13 to share thoughts and future and all that is really good.

03:17 Yeah, definitely.

03:18 Now, before we do any of that business, believe it or not,

03:21 not everyone has listened to every single episode of Talk Python To Me.

03:24 Y'all out there, if that's you, you got some homework,

03:26 but it may be a quick introduction for folks who don't know you.

03:29 Yeah, of course.

03:30 So I'm Charlie.

03:31 I am the founder and was the CEO of Astral.

03:36 We were a company.

03:37 We build high-performance developer tools for the Python ecosystem.

03:41 So we're best known for Ruff, which is our linter and formatter.

03:46 And then we also build uv, which is a package manager and a manager.

03:49 And then we're also working on a type checker called ty.

03:52 We joined OpenAI about a month ago, I think at the time of recording.

03:56 I continue to lead the Astral team here at OpenAI.

04:00 We continue to work on all those tools.

04:03 And hopefully in the future, we'll continue to work on all sorts of new cool tools too,

04:08 in addition to all the things we've already done.

04:09 But that's my background.

04:11 We build developer tools, things that we hope, building software, effective, more fun.

04:15 Well, you certainly nailed that.

04:17 Developer tools, especially around packaging and other things like Ruff, but especially with uv,

04:22 you really, really nailed it.

04:24 And people certainly connected to it.

04:26 Before we talk about this current and future, let's just do a little bit of looking back.

04:31 So I remember having you on the show when Ruff was still just a project that you were doing.

04:37 You're like, what if I learned this weird language, Rust,

04:39 that was not that popular at the time?

04:41 And I built this thing that was like black, but it was really fast and then released that.

04:46 And my first experience was worth it was, oh, this is probably broken, or I just don't understand

04:51 how to use it because I ask it to analyze a hundred thousand lines of Python code in a project.

04:56 And it just went done. I'm like, huh, that probably didn't work. What did I miss? You know,

05:00 maybe it's supposed to be like, look, look at the sub directories or something. I don't know

05:04 what happened here. So take us on this journey of sort of from starting your open source journey

05:10 until you pre-acquisition, just building up Astral?

05:13 Yeah, definitely.

05:14 So, I mean, I started the company, I was at a moment in my life

05:19 when I thought I wanted to start a company, but I wasn't really sure what I wanted to do.

05:24 And Ruff at the time was really like the side project that I wasn't really supposed to be spending time on,

05:31 but I found really fun and interesting and cool.

05:34 And I sort of published a blog post when I got it to what I'd considered

05:38 to be sort of a proof of concept stage.

05:40 And, you know, it turns out people were very interested in like the ideas behind it. And, and, and also the, I guess the instantiation of those ideas, like the fact that they ran this thing and it was fast and it seemed useful. And so I started working on it full time pretty soon after that. Started the company pretty soon after that. That was like late 2022. My first kid was born right around the same time. So I was kind of like, I had like a baby and, you know, this company that was at the time, just me.

06:10 um then eventually started going to team like five that's a decent amount of work to have a baby and

06:14 a new company i remember i think the baby made a bit of an appearance on yeah i think the baby made

06:18 a bit of an appearance on the podcast one time which was all good yeah it was an amazing um

06:23 yeah it was an amazing time in my life and um uh you know my uh my son was also born like seven

06:30 weeks early and so i thought i had kind of like seven weeks to like figure out what i was doing

06:35 with this company and then my son was just like born and and thankfully he's doing great but

06:39 it was like a time in my life when uh everything was was kind of like things were going crazy like

06:44 in all arenas um uh but isn't that emblematic of of being a dad just like yeah yeah i thought i had

06:51 this time or i thought this was lined up and it completely just yeah and i was like fixing issues

06:56 like from the hospital and like anyway i look back on it all like very fondly though you know yeah

07:02 crazy to balance it all and then after a while i started growing the team um like we raised some

07:07 money i was able to grow the team and um you know we started with rough which was our linter

07:13 that kind of expanded um after that we did our formatter that was all that's also part of rough

07:18 um and then you know a little bit after that we basically decided to start working on packaging

07:23 which was um uh i mean at the time for us it was actually really different because we were working

07:28 on python tooling but everything we'd built was like static analysis like linter formatter and i

07:33 I kind of felt like if we wanted to be, you know, the Python tooling company, like aspirationally,

07:39 that we sort of had to find a way to make packaging feel really different.

07:44 And so we were like, let's take on this whole new set of challenges around.

07:47 That was uv, did a couple of big uv releases, and the tools just kept like growing, growing,

07:53 growing and put together.

07:56 I mean, I just feel really lucky to be working with the team that we were able to put together

08:00 because we were able to attract, I think, some really amazing people by building this company

08:07 around build open source, write Rust, programming language tooling. And over time, you build momentum

08:12 because people liked what we were doing. And then we had just huge amounts of usage. And so the work

08:17 becomes more and more impactful. Last year, we started thinking seriously about commercialization

08:23 because up to that point, we were, I mean, up until the point we were acquired, we were obviously

08:28 venture funded. I mean, it was a pretty efficient company. If you think about it, we weren't spending

08:33 crazy amounts of money. We always kept the team pretty small. But obviously the goal was to build

08:37 a successful independent business. And so the question becomes, well, how do we want to monetize

08:43 it? And I think our strategy around monetization was always quite consistent, which was we wanted

08:49 the tools, what we considered the tools, like Ruff, uv, ty, to be free, open source, very

08:58 permissively licensed, and ideally kept pristine from the monetization portion of the business.

09:06 And what we wanted to do was basically build cloud services, like hosted services that people

09:10 would pay money for that were kind of like the natural next thing you need if you were

09:14 using our developer tools.

09:16 And that was basically, that was actually like the vision that I like wrote out from the start. Not that it was like so, so like ingenious or whatever, but it was like, I was like, okay, we'll like build the tools and then we'll have like a kind of like a Python cloud that people will use our tools and the tools will create distribution, like companies that use tools will buy our products.

09:35 And then maybe we can have like technical advantages because we work on both the tools and the hosted services and all that kind.

09:42 So pyx was like the first piece of that platform.

09:49 And pyx was our or is our hosted Python registry.

09:55 It's sort of like the server to the uv client.

09:57 So we had lots of issues in uv from people who, you know, companies basically that have needs around how they do Python packaging and distribution that we couldn't really solve in the client.

10:07 Like maybe they need to distribute private packages or maybe they need to have various kinds of security scanning built into their registry instead of using PyPI.

10:18 And we basically said, well, let's go build a really good registry.

10:20 And we thought we could use that to solve not only those kinds of enterprise problems around security and private package distribution, but also a bunch of what we considered user experience problems, like trying to make packaging even faster, trying to make a big dent in PyTorch and GPUs and CUDA, a lot of the user friction that people run into when they're trying to build with GPUs.

10:47 And so we were like, we could solve that if we have our own server, you know, and people are using our unique client.

10:53 Yeah, and people want to know what you're alluding to with the PyTorch and all the issues.

10:57 We did a whole episode both on pyx and on Wheel Next recently, especially the Wheel Next one, which was, I don't know, months ago, less than a year ago, something like that.

11:08 Tons of hard problems that I've spent lots of time thinking about.

11:11 It's very hard, yeah.

11:12 Yeah, we're kind of like working on that in standards and we're still continuing to do that.

11:16 And at the same time, we were like, let's see if we can solve this for paying customers.

11:20 Because machine learning researchers, that's very high value users.

11:24 Those people are very expensive for companies.

11:27 So if you can make them more productive, and part of the goal of pyx is basically make those people more productive by trying to solve problems that require expertise, both in GPUs and CUDA and Python packaging, which is sort of a rare combination.

11:39 So it's a rare combination, but it's one you basically need if you want to be productive in that space, unfortunately.

11:43 Yeah, yeah. And the old Python packaging standards are kind of misaligned.

11:47 So that's why it means...

11:48 Yeah, exactly.

11:51 This portion of Talk Python is brought to you by Sentry.

11:54 I've been using Sentry personally on almost every application and API that I've built for Talk Python and beyond over the last few years.

12:02 They're a core building block for keeping my infrastructure solid.

12:05 They should be for yours as well. Here's why.

12:08 Sentry doesn't just catch errors. It catches all the stuff that makes your app feel broken.

12:12 The random slowdown, the freeze you can't reproduce, that bug that only shows up once real users hit it.

12:18 And when something goes wrong, Sentry gives you the whole chain of events in one place.

12:22 Errors, traces, replays, logs, dots connected.

12:25 You can see what's led to the issue without digging through five different dashboards.

12:30 Seer, Sentry's AI debugging agent, builds on this data, taking the full context,

12:35 explaining why the issue happened, pointing to the code responsible, drafts a fix,

12:40 and even flags if your PR is about to introduce a new problem.

12:44 The workflow stays simple.

12:45 Something breaks, Sentry alerts you, the dashboard shows you the full context,

12:49 Seer helps you fix it and catch new issues before they ship.

12:53 It's totally reasonable to go from an error occurred to fixed in production in just 10 minutes.

12:59 I truly appreciate the support that Sentry has given me

13:02 to help solve my bugs and issues in my apps, especially those tricky ones that only appear in production.

13:08 I know you will too if you try them out.

13:10 So get started today with Sentry.

13:12 Just visit talkpython.fm/sentry and get $100 in Sentry credits.

13:17 Please use that link.

13:18 It's in your podcast player show notes.

13:20 If you're signing up some other way, you can use our code talkpython26, all one word,

13:25 talkpython26, to get $100 in credits.

13:29 Thank you to Sentry for supporting the show.

13:32 So yeah, we started, I think we did the, we launched the closed beta for that in like

13:36 August of last year, maybe.

13:38 And so from there, we basically had like, I would say three quarters of the team was working purely on the open source.

13:44 And then maybe a quarter of the team, me included, was working on the commercial platform and starting a real kind of like sales process around that and like going and selling it to companies.

13:54 And probably not widely known, but we had like real revenue and actually grew pretty well.

14:00 I mean, it was no, you know, you see all these blog posts about companies going from like zero to a hundred million dollars in like three months or something and breaking all sorts of records.

14:07 It wasn't like that, but it certainly grew pretty well.

14:11 And we had, I would say, a small number of very high quality customers.

14:16 And a lot of that basically came from the open source, people who used our open source

14:20 tooling and saw we were building this thing.

14:22 And that led to a lot of companies coming to us and wanting to see this product that

14:26 we had talked about and written about.

14:29 So we spent a while building that.

14:32 And then, you know, eventually we ended up in conversations with OpenAI.

14:38 That is a, it turns out to be a long and interesting process.

14:43 But we announced that deal, I think in April, I think in April.

14:50 Sorry, you can fact check me on that.

14:51 I'm just scrolling off my memory.

14:53 But we ended up announcing Let's see, March 19th, 2026.

14:57 How about that?

14:59 We announced that deal in March and then we joined OpenAI about a month ago.

15:04 Okay.

15:05 So a couple of months in between, figure out all the details and so on.

15:09 So I want to take you through kind of reliving that experience and goals.

15:16 But first, what was OpenAI primarily interested in your tooling?

15:21 Was it UV?

15:23 Was it rough?

15:25 I mean, to me, let me just speculate out loud.

15:28 then maybe I can channel some of the thoughts of the people out in the audience.

15:31 Like uv, obviously for packaging and managing Python apps, tooling, dependencies, all of that,

15:37 right?

15:37 We've seen Claude acquire Bun, which is kind of a JavaScript equivalent.

15:42 Maybe equivalent's not quite, but in the same ballpark type thing as uv,

15:46 sort of like npm a little bit, but also running stuff.

15:50 Yeah, it's a package major and a runtime.

15:52 So it's like Node and npm.

15:54 Exactly.

15:55 It's like, yeah, Node plus npm.

15:56 That's a good way to put it.

15:57 But then also rough, like if you've got Codex, the team that you're on, you know, I see some of the AIs out there just going grep, grep, grep, grep.

16:04 And I'm like, that seems like a really shallow way to understand it.

16:07 So what if you could parse a concrete syntax tree and truly understand the code, not just fragments here and there?

16:13 Like that might be super interesting.

16:15 So these are my thoughts.

16:16 And I'm like, well, why did OpenAI come and show an interest in you all?

16:19 Yeah.

16:19 What can you say about it?

16:21 Yeah, definitely.

16:21 I mean, there's a few different pieces to it.

16:23 And, you know, I think one is, you know, OpenAI, there's a lot of, this has been written about publicly, like there's a lot of Python at this company, also a lot of Rust at this company.

16:37 And we work at the intersection.

16:38 We work on Python tooling.

16:40 We write a lot of Rust.

16:42 And they're also big users of our tools.

16:45 So part of it is, you know, how can we help accelerate OpenAI as like one user of our tools?

16:52 I think another is we, as an independent company for the acquisition, had been thinking a lot about how do our tools need to change as the way we build software changes.

17:06 So we have to think a lot now about a lot of our users are building software with agents.

17:12 And so we're thinking a lot about how do we make tools that are great for humans and for agents and what changes and what stays the same.

17:18 And there are lots of questions that we want to explore there that I believe, and I think OpenAI believe this too, we can more effectively explore together.

17:28 If you basically think about kind of co-designing like the models and the harness and tools, like what are interesting questions and where can you like innovate in order to try and build like a really different developer experience?

17:41 And part of it too is I think just that we're lucky because I think OpenAI had a lot of respect for our team and the impact that we've been able to have with the resources that we had.

17:54 And that if we were put in part of a bigger platform, we could have an even bigger impact.

18:00 So it's a mix of things.

18:01 Part of it is about accelerating OpenAI.

18:07 Part of it is thinking about like how tools change and like the future of software as we, the Codex team.

18:14 So, you know, this, this also speaks, I think, to a bit to, you know, sort of like what changes and what stays, what stays the same.

18:23 Because for us, we, like we tend to view OpenAI as like a user of our tools.

18:31 And what we want to do is we want to keep building what we hope is like great software that benefits everyone, you know, including OpenAI.

18:41 So, you know, for us, we kind of use this platform in part as, oh, here's a big, you know, like a huge user of our tooling.

18:49 How can we find areas where our tooling is like insufficient that help accelerate internally, but then also tools better for everybody?

18:57 And so like still very much working on like all of our tools, like very much still a priority

19:03 to keep, keep building those.

19:05 And then similarly, if you think about that second piece of like, how can we bigger about

19:10 like the future of software?

19:11 We now have lots of opportunities that we, we sort of didn't have before.

19:14 Like, I think before we were a bit more constrained because one, you know, the things that we

19:19 worked on, they did have to be coupled in a realistic way to kind of like the commercial

19:24 vision of the company.

19:26 And two, we were pretty focused on Python and just Python.

19:32 And the idea of expanding scope in different ways was, I think, more challenging.

19:36 And so when I look at what we're doing here, part of it is I think we can actually be a

19:42 little bit more ambitious and maybe a little bit crazy in terms of the experiments that

19:49 we run or the things that we try to build.

19:52 And even think beyond Python if we want to in terms of how can we build tools that basically make programming more productive?

19:58 Like that was always our goal.

20:01 And so here at OpenAI, it's like I want to keep and we're going to keep building our open source tools.

20:06 We want to use those to build the best possible programming experience we can for Python.

20:10 And we also want to be thinking about like what's the future of how we build software and how can we go and sort of like test those waters?

20:17 And if we sort of like think a few steps ahead, what is like the next generation of tooling look like, whether it's for Python or for Rust or for, you know, other parts of the software development?

20:26 That's pretty interesting. I guess one thing I left out in my enumeration of reasons they might care about you all is just Python intersect Rust super team, right?

20:35 Like just the folks that work there.

20:37 Yeah, that must be really interesting to just have such a bigger space to explore in, right?

20:43 Because you were known as Astral, the team that makes awesome Python tools.

20:47 But if you're like, oh, we got this really great idea about C++ and packaging,

20:51 that wouldn't be congruent with how you're trying to grow

20:54 into your Python cloud offerings and pyx and those types of things.

20:58 But now the constraints are off.

21:00 Constraints are just very different, right?

21:02 I mean, I think we're still extremely committed to our tools.

21:07 And we actually just finished, the first thing I did, maybe not the first day, but starting the second week,

21:13 is I wrote up a charter for our team that we all kind of like aligned around

21:18 to basically try to figure out like, what are we doing here?

21:21 Like, what is our mission here at OpenAI?

21:23 And like, how is it different than what we did before?

21:25 How do we prioritize?

21:27 How do we figure out whether something's worth doing, whether it fits into like our mandate

21:30 and everything to do?

21:32 And we just, we sort of like went through that mission exercise.

21:36 And then we did a bunch of planning over the past two weeks to kind of set our goals

21:39 for the next, we're doing like two month cycles.

21:41 So we set our goals for the next two months.

21:43 and I will say like of like most of what's in there is like continuing to build our open source

21:50 tools and like trying to solve the problems that we see there and then there's obviously some new

21:55 experimental different stuff that's like we wouldn't have done before you know especially

21:59 around you know we're thinking about experimenting with like Rust tooling we think Rust is really

22:04 interesting we spend all our time writing Rust we think Rust is going to be like an increasingly

22:07 important language are there things that we could do to make like Rust more effective you know are

22:11 there other ways that like agents are going to fit into the broader software lifecycle of like

22:16 filing issues and and code review and all those kinds of things so you know it's a mix of keep

22:22 building the tools that like so many people depend on like including open ai um like keep but also

22:27 solving problems that honestly some of them probably don't matter that much to open ai but

22:30 they matter a lot to our users um and go was better and part of it is like thinking big about

22:36 new areas where we could be having you know hopefully like a 10x impact over what things

22:40 are today in the same way that hopefully we did with our existing tools. So, you know, I think

22:46 like we will, you know, it's easy for me to say this. I think like ultimately time will tell whether

22:51 this is true, but I, at least right now, I genuinely think it's possible that we end up writing more

22:55 open source here than we did at Astral. Because if you look at the arc of what was happening at

23:01 Astral, I mean, it was going, like the company was going well, but also we were increasingly having

23:05 to think like how do we commercialize? Yes. I was just thinking that actually. How do we build a

23:09 commercial product and yeah yeah here we have like no constraints or like you know no rules or

23:15 whatever but like we certainly um we certainly do have the ability right now to like keep building

23:21 in open source and it's definitely uh you know there's a lot of alignment in that throughout

23:25 the company so um i don't know i'm just like i'm very to be honest with you i'm just like super

23:30 happy right now because um i think it was obviously a very stressful process uh in a lot of different

23:37 ways. Just a lot of responsibility to weigh, you know, a lot of high stakes moments, a lot of

23:43 different groups to consider, whether it's like the people on the team, our users, our customers,

23:50 right? There's just a lot, a lot, a lot to think about. But like sitting here now a month in,

23:55 I'm like, I'm super happy with, with like where the, where we're situated on as a team,

24:00 like the things that we're committed to doing over the next few months, the resources we have to do

24:05 them, it's like, I don't know, it feels like a really special like moment in time. And I think

24:11 I really think the amount of like open source that we will ship over the next year will be like,

24:15 yeah, again, possibly more than we would have done otherwise. I mean, obviously hard to hard to prove

24:19 and who knows how that will play out. But that's how I feel like sitting here today, at least.

24:23 That's great. You know, one thing I was thinking about while you're saying this is I run my own

24:27 company here at Talk Python, right? And there's a remarkably high percentage of my time. It just

24:33 feels like administration support, et cetera.

24:37 You know, I'm doing accounting and I'm trying to figure out like, chasing

24:41 down sponsors for the show, following up on invoices that don't get paid,

24:45 keeping the website running, you know, just like all these things, none of

24:48 which delivered direct value.

24:50 And so you've, you probably live this like even to a higher degree than I did,

24:55 but, but then now you've been like plucked from that environment, leaving

24:59 all that infrastructure, like accounting and stuff aside.

25:02 And now you're more like pure product, which is in a sense could actually be better, as you were saying.

25:07 I mean, you know, to be honest, like it's like that's a lot of what I was hoping for is I thought that this would put us in a position.

25:16 And again, like I should be held to account, you know, at some point in the future to see whether this works out or not.

25:22 But like I I thought I would be putting us in a position to keep doing the things that we love to do and that we're really good at.

25:30 And, you know, in a place that was that didn't require us to compromise on a lot of our values in terms of how we think about users and how we think about building.

25:41 And I'm I don't know, I'm excited about like what we have planned.

25:44 So, yes, I I certainly, you know, my my job has changed quite a bit, as you can imagine.

25:50 Like I it's funny because like I'm not I'm probably working more or the same amount.

25:56 But I like I kind of like always I just like work a lot.

26:00 but I do feel less stressed to be honest.

26:04 Like I feel less stress about, sort of like existential stress about

26:09 how do I make sure the company doesn't like completely fail,

26:12 you know, especially for It's probably more deep.

26:14 Even all these people who came and joined, right?

26:17 But now I feel less stress.

26:19 I feel way more, I feel just like, I don't know.

26:21 It's very cool.

26:22 Amazing.

26:22 All right, before we move off this topic of, you know, you joining OpenAI and all that,

26:26 I kind of just want to have you relive the experience

26:29 a little bit for people like what what was it like to hear from open ai like oh my gosh they want to

26:34 acquire they want to have a discussion about maybe acquiring us and then maybe telling the team

26:39 telling your wife like just and your family like just to the extent you can just give people a

26:43 sense of like what those first couple yeah yeah of course i mean there's like you know there are

26:47 there's obviously a lot i can't say um you know the things i will say is like one um i i think

26:54 think I'm pretty naive, but it was like, it was a lot of work and takes a lot of time. And, you

27:02 know, there's just a bunch of different phases to the process where sometimes things move very fast

27:05 and sometimes they move slow and then they move very fast. And it just has all sorts of ups and

27:10 downs and twists. And, you know, I think, I think people had, you know, lots of different feelings

27:18 about the acquisition. And yeah, that's right. There was a lot of positive, but also a lot of

27:24 negative stuff that you probably got thrown at you when this came out, right? So that must have been

27:28 a little bit challenging to deal with. Yeah. I mean, I think for me, like it wasn't,

27:33 to be totally honest, it wasn't anything that I didn't expect. And it reminded me a bit of when

27:40 we announced that we were, you know, to be honest, it reminded me a bit of when we announced that we

27:43 were forming a company and sort of like, you know, the range of reactions that you get around that.

27:49 Some people are very excited for you. Some people are like, this should be an open source project

27:53 that isn't part of a company.

27:55 Some people are worried about the future of the project

27:56 or think that you're not happy with your choices.

28:00 And I kind of tell myself a lot of the same things that I told myself then,

28:04 which are, no matter what you say and how genuine you are

28:10 and how you feel about those things, you won't convince everybody just with words.

28:15 And what you really have to do is convince people with actions over time.

28:19 And so when we announce the acquisition, A lot of people really excited and happy, including users who thought this would be a better, more sustainable future for the tool, but also people not happy about it.

28:32 And for me, the thing that I told myself is, not to be too poetic, but the story of this acquisition hasn't really been told yet.

28:41 You can predict that certain things are going to happen, but I think a much better way to look at it is looking back a year from now,

28:50 what are we going to say about it? Like, and what do we want to be able to say about it? And so we

28:54 actually went through that same exercise as a team, we sat down and we wrote out, you know, a year from

28:58 now, what do we want to be able to say about our tools? And some things are obvious, like, they're

29:03 still open source, right? Like, that's like, incredibly obvious to me that like, that's still

29:06 going to be true. You know, but there's a lot of other stuff to like, oh, we want to make sure that

29:12 we continue to like, keep a very high quality bar, we keep trying to build things that we think are

29:17 really great as opposed to shipping, you know, like quality over quantity. That's like a value

29:21 that we have that we want to retain. And we had this whole list of things, you know, that we want

29:25 to continue to be true. And so for me, I just try to stay focused on what are people going to say

29:30 about this in a year? And that directly translates to how do we want users to feel, right? Like,

29:35 how do we want to treat users? What are the contracts that we want to make? Not financial

29:39 contracts, but like social contracts, basically, that we want to make sure that we're upholding.

29:44 So, you know, we thought a lot about it as a team.

29:47 Like it's hopefully it's obvious, but this was not a decision that was that,

29:52 you know, that I made lightly.

29:53 I thought very, very hard about what are all the trade-offs here

29:56 and how does everyone get affected?

29:57 And, you know, ultimately I believe and I really hope that your time has passed.

30:03 Like even the people who were skeptical when we announced the deal will,

30:06 you know, we'll agree that like we've, we've done right by our users.

30:10 So that's my goal.

30:11 And honestly, motivation to me.

30:13 Yeah. I think that's certainly a genuine, genuine idea and, and, you know,

30:18 gold, gold to drive towards that. That's awesome. And how'd your, how about the family?

30:22 Oh, my own family.

30:23 Yeah. Yeah. Like how, like when you, when you told him, what was that like?

30:26 Yeah, it was very, it was, it was very cool. I actually, I signed the letter of intent,

30:34 which is sort of like, it's a non-binding document, but it's kind of like the first thing,

30:38 or sorry, it's fine. It's binding in certain ways, but like the deal is not really like

30:42 confirmed in any sense but i signed that at my niece's like uh birthday party and i kind of went

30:48 up to my mom and i was like yeah i just uh just signed a you know hello i with open ai and so it

30:53 was cool to see people's reactions yeah i'm sure it was wild that's awesome yeah it's very it's

30:58 very validating um yeah it's nice it's nice to you my uh my dad my dad is my dad's great um and we

31:07 have a great relationship um but he was a little skeptical when i quit my job to start a company

31:14 and um and actually at the time like i we had a child on the way and when i when i left my job we

31:19 i didn't know what the company would be and so it was basically like i left my job to start a

31:23 company i don't know what it's going to be and i have a kid on um and so uh you know it's it's nice

31:28 to um i'm glad that we had a good outcome yes i know exactly what you're talking about i remember

31:33 when i quit my job 11 years ago to start talk python i had two daughters who were just about

31:39 starting to enter college we'd have to pay for and we had a mortgage and i just like spent some time

31:44 looking in the mirror like you better be sure about this could be this is high stakes you know

31:48 there's a lot of people who depend upon getting this right but yeah yeah exactly no and i think

31:52 being a founder it's like um i mean i never like i i think there are some people who like really want

31:58 to be founders and like for me that was not really like the goal like i don't need to be like

32:03 under CEO or any of that. Like I sort of stumbled into like creating what is, what is in

32:10 some ways like the perfect job of getting to work on these things that we love. And, like, I just

32:15 love building these things. Like I just think it's like the coolest thing ever. and I think

32:20 it's so fun. And I sort of like stumbled into that, but then you find yourself, you know, you do find

32:25 yourself bearing a lot of responsibility. And I think I felt that a lot, right. It's like,

32:29 especially I was reflecting on this recently. Cause it's like, actually when I started the

32:33 company, it didn't feel that high stakes. But as the company went along, I felt more and more high

32:38 stakes. Because when I started the company, it wasn't really worth anything. And like, it was

32:42 just kind of me. And then over time, the company starts to actually kind of be working. And then

32:47 a bunch of people, a bunch of employees who you convinced to come join you on this journey,

32:52 and they have families. And you know, so it's, yeah, it's just interesting, because like, I,

32:57 yeah, I was like, the beginning wasn't that I, it wasn't that hard of a decision. But over time,

33:01 I think it does weigh on you a lot.

33:04 And so it's nice to be able to deliver a good outcome to those.

33:10 Yeah, 100% and 100%.

33:13 This portion of Talk Python To Me is brought to you by the courses and us over at Talk Python

33:18 Training.

33:19 After a conversation like this one with Charlie, it's hard not to feel the pull to go build

33:24 something with AI.

33:25 And that's exactly what our two newest courses are all about.

33:29 The first is agentic AI programming for Python.

33:32 You'll learn to work with AI like a sharp junior developer on your team,

33:36 one that reads the whole code base, runs your tests, and cleans up on its own with Ruff,

33:40 all while you stay in the driver's seat.

33:42 It's about the guardrails and workflows that turn AI from a frustrating slop machine

33:47 to a real force multiplier.

33:49 And shipping faster means you have to ship safer.

33:52 So in Python Web Security OWASP Top 10 with agentic AI,

33:57 you'll build your own custom security agent that audits the entire code base in minutes

34:01 for about the price of a fancy coffee.

34:03 We'll turn it loose on real open source apps and find genuine vulnerabilities in every single one.

34:09 Both courses are waiting for you over at talkpython.fm

34:12 slash courses with direct links right there in your show notes.

34:16 Thank you for supporting the show by taking one of our courses at Talk Python.

34:21 All right, let's talk about basically the tooling.

34:25 So uv rough ty, what changes, what stays the same?

34:29 For example, I just noticed if I scroll down somewhere, just yesterday you had a new release

34:37 of uv.

34:37 So, you know, there's still, there's a commit an hour ago, right?

34:41 There's still lots of stuff going on here.

34:42 Yeah.

34:43 Just like, yeah.

34:44 No, no, no.

34:45 I mean, like, I don't know.

34:46 I think if you, I was actually looking at the data recently.

34:49 I think our rate of releases has basically stayed the same across this entire process.

34:54 like from before the acquisition to, you know, the sort of intermediary window to after.

35:00 I like a lot, like for uv, like a lot stays the same. And, you know, there are, I would actually

35:08 say that the goal right now is actually to try and ship a lot of the, what we would consider like

35:14 most highly requested features and things we've wanted to do for a long time, but haven't been

35:18 able to fit into the roadmap. So a lot of stuff coming around, a lot of stuff that we're doing

35:23 there now things like locked tool installs like people really want to be able to do uv tool install

35:30 and point it to a git repo and reuse their lock file so that you get the exact same dependencies

35:35 that were locked and published like things like that so you know we're very focused on basically

35:42 trying to like ship all the things that people really want right now because it's a good time to

35:46 do it so yeah for uv like a lot stays the same for rough again a lot stays the same for t

35:53 TY, well, sorry, I mean, sort of boring, but like a lot stays the same.

35:57 I mean, we're still like working towards a stable release later this year.

36:02 But one of the things that's been very cool is we can use OpenAI as kind of like a testing

36:10 ground to get ty ready and like make sure it's good.

36:15 That's super interesting because, you know, the other type checker that I think is sort

36:20 of on par with your all's work is Pyrefly.

36:23 from meta and i think those two just stand far above everything else that's out you know my pie

36:28 and those things are great but they're just from a different era right and like ty is focused on

36:33 i need to have autocomplete now i need to have now over like a huge project right and so i know your

36:40 projects are big but open a is projects open ai's projects are probably larger right and more yeah

36:45 i mean we don't really have like we had like for the beta when we did the ty beta the milestone

36:50 there was like, we're using it internally for all of our own stuff. Like, cause if, if we weren't

36:55 using internally that it's not ready for anyone. And so that was the bar for the beta, but that was

36:59 like, that was mostly pyx, which is, you know, it's a moderately sized Python code base. Yeah,

37:05 here it's obviously super different and there's lots of different, tons of different kinds of

37:08 code because you have, you know, the company is there's like research and applied and the way that

37:14 you work in those worlds is very different. So there actually was already some ty here.

37:19 But we're kind of, you know, basically we're setting a bunch of goals around how can we get ty ready to be used here as a default and enroll it out to more of the code base over time.

37:30 And that will come before the stable release.

37:33 But it's a helpful way for us to understand, like, basically to prioritize issues around, like, what's real and what can be postponed.

37:39 Because if we can get it running here, then, like, I won't say then, like, you can get it running anywhere.

37:44 that's like a bit much, but it's like, if you can get it running here at scale, you know,

37:48 and providing like sufficient coverage and like great performance, then like there's a good chance

37:52 that like to. So we're kind of like informing the roadmap a little bit based on like internal needs

37:59 and spending time on like trying to roll it out. But, you know, ideally for us, and this is again,

38:03 part of like how we view like our mission here. It's like, ideally for us, when we find ways to

38:08 like accelerate the org with our tools, we also want to like, like cycle those things back into

38:13 improvements that we can then ship out to everyone so like sharpening the tools over time by like

38:17 making sure that here um so so yeah i mean the open source like the yeah like the sorry not to

38:23 talk like a manager but like the resourcing and like the you know number of people who are working

38:27 on x y and z and like all that like it's pretty similar um and you know the main the main things

38:32 that have changed are in terms of how the team is structured is like uh we were working on pyx um

38:38 We are, we're basically, we're going to wind down like the hosted service there. But one piece I'm

38:46 really excited about, which is again, something that was we wanted to do, but was kind of hard to do

38:52 hard to justify doing before, we're going to take everything we did around the GPU indexes and the

38:58 wheels that we built. And we're actually just going to open source that and make all the artifacts

39:02 freely available. We can and like, it's makes a lot more so like, we think that's a great thing to be

39:08 out and released, but before we had to think about how do we build a business around it.

39:12 So, you know, in terms of resourcing, like we had people on the team that were working

39:16 on pyx, we're kind of taking them off and like, you know, they're working on other things

39:19 within the Astral Suite.

39:21 And then we're spinning up a couple new efforts around, you know, more experimental things

39:26 that probably aren't ready to announce yet, but we'll see.

39:28 But if they work, you know, then you'll hear about them more in the future.

39:31 So, you know, still like a very significant focus on continuing to build our tools.

39:36 But then some percent of the company kind of working on like new, you know, net new efforts around where we think software is going.

39:44 Okay, interesting.

39:46 One thing that we haven't talked about yet, maybe people don't put it front and center, but I think it's actually the secret sauce of uv is Python build standalone.

39:54 Yeah.

39:54 The fact that uv lives outside of Python, not inside of Python is a very meaningful difference.

40:01 What's the story with that?

40:03 Yeah, I mean, not to be too boring, but like it's I don't know, it's basically like Sam continues and change. Like we have, there's one person on our team who was working on Python build standalone full time for the acquisition, and he's continuing to work on Python build standalone, you know, full time now. I think there it's like, you know, one thing that we do want to do to the degree that we can and is try to upstream things to see Python.

40:30 Because if you think about Python build standalone, it's kind of, I mean, to some degree, it's basically like, I wouldn't want to advertise it this way because it's scared.

40:37 But I guess I'm saying it on a podcast.

40:39 Like in some way, it's like a fork of CPython.

40:41 I mean, it's like CPython with a bunch of patches applied to the build system.

40:46 Yeah, it's a fork, but in a different way.

40:49 Because a lot of times it's like, oh, we want to build it on the JVM or we want to do this XYZ.

40:54 And this is just like, we just wanted to run from a different location than the install.

40:58 I'm not trying to like reach in and change a bunch of the implementation or anything like that.

41:01 It's more like we try to, we basically try to apply minimum changes to make it like relocatable.

41:05 You know, the idea being we can pre-build Python for you.

41:09 And then on your machine, you just download, unzip it and it runs.

41:11 You don't have to build yourself.

41:12 That's like the core goal of the project.

41:14 But yeah, we do want to try and like upstream what we can there.

41:18 And, you know, it sounds to me like the CPython, the core devs are kind of open to that, right?

41:23 Like, yeah, they didn't intend to build it.

41:25 So it's hard to move.

41:26 It's just like, that's how it sort of became, you know, evolved, right?

41:29 So if you can come back and say, well, look, if you'd make these minor changes, actually

41:33 you're way more flexible.

41:34 I don't see why they'd be against it.

41:35 It kind of benefits everyone, I would hope.

41:38 Like we actually really want things to get upstreamed because it makes it easier for us

41:42 to maintain because we no longer have patches on top of CPython.

41:46 We just have CPython.

41:47 So like, you know, the fewer deviations we have, the better.

41:50 So yeah, it's, I mean, it's just sort of like normal work that requires lots of coordination

41:56 of like what's changing and why in terms of getting things upstreamed and like finding the time for it

42:01 not just for us but i mean to review and see python so um we'll continue pushing on that and then i

42:05 mean python build standalone in general there's kind of like two components to it like one is

42:09 there's there's sort of like evergreen work to like keep up with c python because c python

42:13 development is very active um and uh like you know they have a very they have a lively release

42:20 calendar, like both for the newer like betas and also for like fixes on old minor versions or

42:28 previous minor versions. So part of the work is like CPython, make sure that we're like,

42:32 you know, our goal is typically to try and get releases out the same day that they go out and

42:36 CPython. So we do that. And then kind of like continuing to make the project better in like a

42:41 bunch of different ways. And, you know, like I think the two that we've been really focused on

42:45 over the past year would be one, getting rid of quirks,

42:49 like things that are confusing and different.

42:51 And I think we actually did a very good job there.

42:53 We get very few reported.

42:55 We solved a lot of the key things that were like weird.

42:58 And then two, performance.

42:59 We want it to be the fastest Python can get, basically.

43:03 And that's not by building a JIT or doing anything super different.

43:07 It's just building it better, right?

43:09 Building it in a different way and trying to be really rigorous about benchmarking

43:13 and various levers that we have on Python.

43:14 Nice, like profile guide compiler optimizations and stuff like that.

43:18 Yeah, like PGO and stuff like that.

43:20 I mean, because who wants to download a slower Python, right?

43:22 Like it's always a bummer if someone files an issue and they're like, I got my Python from like Debian

43:27 and it was like faster.

43:28 And so we like, we want to have like the fastest Python

43:31 implementation.

43:32 You're like, yeah, but not next time.

43:34 Next one that comes out is going to be faster.

43:36 No quirks, fast, you know, small, ideally, all those things.

43:40 So just kind of continuing to push the project.

43:42 Cool.

43:42 And so people out there listening who don't know what Python build standalone it is.

43:45 Basically, if you say uv install Python, or you say uv, V, E, and V to create a virtual environment,

43:50 but you don't have that version of Python, this is the Python that gets downloaded and installed

43:54 to be the runtime of it, yeah.

43:56 Yeah.

43:56 All right, let's look at one thing real quick before we move off.

43:59 I pulled up this thing called the Daily GitHub Star Explorer,

44:03 Daily Stars Explorer, have you seen this?

44:05 Wow, no.

44:06 Okay, sorry, no, no, no, it's good.

44:08 I pulled up uv here, and this is the lifetime of uv.

44:11 And you could look that it's pretty consistent from before and after the acquisition in terms of start.

44:16 But this is stars.

44:17 That's what I matter.

44:18 So you go over here and say, they'll show me the commits.

44:21 And again, the commits are still pretty much the same, right?

44:25 Like early dev, there's a ton of commits, but like there's still plenty of commits over time.

44:29 Here's the integral, the commits over time.

44:33 It's pretty much linear.

44:34 Yeah, cool.

44:37 Surprise.

44:38 I mean, to be honest, there was probably a period in there

44:40 where like the entire company was extremely distracted.

44:43 Oh yeah.

44:44 I think I can actually, I think I can see it.

44:46 I think it's right here.

44:47 Yeah.

44:48 Right.

44:49 Look at that.

44:49 February 13th and 19th, 2026.

44:52 Is that around the time?

44:53 Yeah, it sounds, I probably like.

44:54 I mean, if you announced it in March, like probably you.

44:57 There's a lot.

44:57 Yeah.

44:57 There's like, there's certainly plenty of disruption and travel and all that kind of stuff.

45:02 Sure.

45:02 Of course.

45:03 I feel like this week actually is the week that we as a team

45:06 feel like we're getting back to normal because we did all this planning

45:08 and now we have like clear goals for what we're trying to do.

45:12 Sweet.

45:12 Yeah, I love working on that.

45:15 That's awesome.

45:16 All right, well, let's talk about, speaking of working,

45:18 what it's like just to work at a frontier model place, right?

45:22 Obviously, everybody in software development, unless they're intentionally putting their heads in the sands to avoid AI,

45:28 have just been rocked both in a positive and negative way.

45:31 There's just so much new and different and change from AI.

45:35 But that's not the same as being in AI, in the middle of AI as this is happening.

45:40 So what can you say about the change of going from the outside to the inside, I guess?

45:46 Yeah, it's interesting.

45:48 I mean, I'm worried that no one will trust my opinions on AI anymore because I work at OpenAI.

45:54 You're just a shield, Charlie.

45:57 You're just trying to get people to use codecs.

45:58 I mean, I think there's a lot of interesting things happening.

46:00 I think one internally here, Codex has really taken over, including for non-software engineers.

46:09 And by that, I really mean the Codex desktop app, because a very significant percentage

46:14 of users of that app are not software engineers.

46:17 They're other kinds of knowledge workers who are doing things.

46:21 And everyone at the company, I think someone on the Codex team tweeted, it must be the most

46:26 dog-fooded app of all time.

46:27 Everyone at the company is doing everything with Codex all the time.

46:30 And so there's a very powerful like feedback and constant testing loop like happening at the company across like the models and the apps and the hard.

46:38 I think you very quickly become this is the thing that like I know I'm going to say it like people are sort of like not going to believe me.

46:45 But like you do kind of quickly become a oh, wow, like the models are going to continue to get very good, very quickly person.

46:54 Like, because especially when you start talking to research and you see, you know, the thing like the sort of projections and a lot of this stuff is public or has been written about elsewhere.

47:02 But it's just like, you know, the things that are happening in terms of the build out of data centers and algorithmic efficiencies and, you know, all sorts of discoveries that are happening.

47:15 It's like the models, it does seem like the models are going to continue to get like significantly better in a period of time.

47:21 And so it is interesting to be in a position to kind of like think about what that means and what to do about it.

47:29 I think it's interesting to be inside and see a lot of people speculate and talk about the company,

47:37 often in ways that, at least from what I can see internally, are like completely wrong.

47:42 Sometimes they're right, but often they're confident but wrong.

47:47 You're like, I see what's coming for it. It means this. And you're like, no.

47:51 So, so it's just interesting to be working at a place, you know, it's just something to be that's just working at a place that's like this moment in time, sort of, you know, in the spotlight or a lot of people.

47:58 Yeah, 100%. It's definitely the swirling center of the zeitgeist.

48:03 It's funny because when I talked to one of my investors about when we were talking about the acquisition and they were like, well, you know, I think if you go to like OpenAI or, you know, one of the frontier labs, like, I don't think it will be like less crazy than a startup.

48:18 Like, I think it will like be.

48:19 Yeah, yeah, yeah.

48:20 And I was like, yeah, you're probably right.

48:24 Yeah.

48:24 All right.

48:24 Well, sort of related to that is what do you think about just agentic programming in general?

48:31 Yeah.

48:31 What a time to be writing software.

48:34 I mean, like things are changing.

48:36 I'll say a bunch of things and some of them won't be that insightful.

48:39 Things are changing incredibly quickly.

48:41 I mean, I wasn't really using agents at all until like December of this year.

48:46 Like I was using, you know, tab completion and stuff, but I wasn't really like running

48:50 agents to build software.

48:52 And I was one of, I think, you know, a wave of people that went home for the holidays and

48:56 had time and started like doing everything through agents.

49:00 And I kind of came back and was like, wow, this is really different.

49:03 And now, like I haven't really, again, this isn't like I haven't really like typed out

49:07 code in the editor, I think, since like for months.

49:11 It's insane.

49:12 I know exactly.

49:13 It's insane.

49:14 I mean, I still use my editor, but it's mostly to read code or maybe it's to edit rows, like

49:18 the change log or the docs or something.

49:20 Yeah.

49:21 I do all my AI coding inside an editor, but because I want to be able to interact with

49:26 what it's created, not necessarily because I'm typing it so much these days.

49:30 Like, oh, it was almost right, but I want to change this one thing and then tell it

49:32 like, let's go.

49:33 I want a tool that lets me navigate code well, not as much as I used to want one to write

49:38 code well previously.

49:39 Yeah.

49:39 And it's like, I think, I think it's very hard to know, like what, what the form factor

49:44 is even going to be.

49:44 And look, that's not that long ago, like that, that, that I was, you know, doing all my code

49:48 in an editor.

49:49 And now I'm like doing all my code, like in the, you know, like through codex and it's

49:52 like, like things are just changing incredibly quickly.

49:55 Yeah.

49:56 I even went through, I think my own phases of kind of like, I won't say full blown, like

50:00 AI psychosis, but like putting up PRs that were like definitely bad that I thought were

50:04 good, you know, like convincing myself that I was like doing good work that was done by

50:08 the agent.

50:09 And I think I've kind of like hopefully gotten over like the peak of that.

50:13 And I'm like learning to use these, these tools in a more effective way.

50:17 I mean, to me, that's, I think one had been one of the key insights is like, like these,

50:21 like using this, these tools well as a skill.

50:24 And it's like something that you have to learn.

50:26 100%.

50:27 It's an engineering skill, just like coding or testing.

50:30 I absolutely agree.

50:31 It's not like you're just going to drop into an editor, like the CLI and say, like, build

50:36 me the perfect piece of software, right?

50:37 Like that's not like, no, you can't say that.

50:41 What you got to say is build me the perfect editor or you go to jail and then it will.

50:46 No, I'm just kidding.

50:46 Sorry.

50:47 No, no.

50:47 But, but I, so I think for me, part of it has been like learning.

50:51 It's a skill.

50:52 I mean, I think I went through, I tweeted about this at some point, which is a sentence

50:56 I always hate saying, but like, I went through a phase where I was feeling

51:01 a lot, like I was having way less fun programming, but I was like getting more productive.

51:06 Like I was very worried that working with agents would be like a lot less fun, but a lot more

51:11 productive. And then I would be stuck in this position where I'd be like, well, what do I want

51:14 to do? Do I want to enjoy my work or do I want to ship? And I actually feel a lot better about

51:20 that now than I did a few years ago. And I think, I think it's a combination of things. I think one,

51:24 it's the models legitimately getting better. And so the amount of micromanagement getting,

51:29 getting lower. But two, it's like learning how to use them well and like building workflows.

51:34 And so, you know, for me, it's like, I still get the same satisfaction of like coming up with a great insight or like closing a user issue, right? Like merging a PR, shipping something, like shipping an improvement, even if I'm not typing things out, like you still have to, it sounds like a low bar, but like you still have to use your brain to like, think about what the problem is and what the solution should be.

51:53 Yeah. And your experience and your expertise, right? Like it still absolutely applies more indirectly. Like I also had the same micro experience, I guess, where I'm like, oh man, I don't want this AI thing to take over because I really love coding. It was a joyful, deep experience that I could just disappear into and come back and have created something great.

52:14 But what occurred to me over time is I got better with the agents and so on was what I actually like more than just writing code is building things, making things with software and with computers.

52:25 And boy, can you make stuff even more so now than you used to be able to a couple of years ago with things like Codex and others, just like you can really build stuff.

52:32 And if you work with them, you get what you want, build, not just some random thing, which is fun.

52:37 Yeah.

52:38 And even, I mean, first of all, I think it's actually super normal and pretty common feeling right now.

52:43 Like it's a weird, like existentially, it's a strange time to be a software engineer because like things are changing a lot and there are legitimately like elements of the craft that like I'm not going to say they're like going away, but it's like there are things that I used to do in terms of like type like how I wrote out code that I like don't really get to think about anymore.

53:01 and I don't want to say like typing out code like that sounds a little bit dismissive it's like

53:07 you know thinking hard about like the layout of like my data structure like I don't think quite

53:11 as hard about a lot of those things anymore and like I I do feel like I've lost something um at

53:16 you know at the same time uh even if you feel that way there's like a lot of uh I think there are a

53:21 lot of like redeeming nice things that are happening like I don't I haven't I don't deal

53:26 with or I haven't dealt with a rebase conflict in months, right? Or the thing that I really love

53:33 right now, especially is the cost of experimentation or just trying something. It's not zero, but it's

53:39 like very low. And there are so many things that I've always wanted to try. Like, I don't know,

53:46 like right now I'm working on a change in uv to content address our cache. Like we want to make

53:51 get more memory efficient. So if you download like lots of versions of a package and it has a lot of

53:56 overlapping files, we don't have to save a bunch of different copies of them. It's sort of, it's not

54:02 like critical what it is, but the point is like, it's pretty hard to like, pretty hard to implement.

54:07 But now if what I want is just to understand what the implications will be, like how will

54:11 affect performance, like what are some of the hard design, like I can just run that in the background.

54:15 Or like, if I want to try to find like interesting memory or performance optimizations, I can just

54:19 give codex a goal slash goal find an improvement that you know or find a change that improves like

54:25 reduces memory consumption by like at least one percent in this project and like it'll just like

54:29 go off and find something and then I can review what it does and think hard about what makes sense

54:33 and what doesn't so um I don't know I'm trying to for me I mentioned those because those are the

54:37 kinds of things that I think can bring a lot of joy back to building even if you feel like you

54:42 are losing something um and it's just a it's just like it's just a crazy time to be building like

54:49 It will continue so much.

54:51 But I do think, you know, to your point about, you know, like it is an extremely high leverage

54:58 time to like be a software engineer.

54:59 Like the value of software engineering skills are like extremely is it software engineering

55:03 skills right now, I think are extremely valuable because you it's like a multiplier on your

55:09 instincts and your abilities.

55:11 So like if you have a really good understanding of the problem space, you can like, I think,

55:15 get a lot of leverage out of building with agents.

55:18 So anyway, these are the things that I try to look at as I reconcile my own identity.

55:23 Not to get too philosophical, but my own identity as a software engineer with what does it mean

55:27 to be a software engineer?

55:28 How has it changed already?

55:30 How is it going to continue?

55:31 And also talk about it with people on the team.

55:33 Like everyone, I don't know.

55:34 I think a lot of people are thinking about this right now because there's just a lot of

55:39 change.

55:40 One more thought before we move on and kind of wrap things up is like, I know a lot of

55:44 people have a lot of opinions on these things.

55:46 as you were just saying, I feel like a lot of people out there have a, I think a challenge

55:51 of talking about this, let's put it this way. A challenge of talking about this is two people

55:55 can believe they're speaking about the same thing. Like I use Codex and I built this and this is,

56:00 it's so amazing. Someone else says, Hey, I used AI to build this thing and it was so dreadful and so

56:06 wrong. I can't believe it. And my theory of the world is there's the people who are willing to

56:11 like go all in and kind of learn the skill and like really try it and pay 20 or 100 or whatever

56:18 dollars and use the absolute peak model in the last year or the people who are skeptical say well

56:23 i don't really believe in this but people keep saying it's good so let me try it so i'll try a

56:27 free coding agent that's got a much lower model comes out with a bad experience and it's a self

56:32 reinforcing feeling like oh look this i knew it was crappy look it is crappy it's like no no no

56:37 know these people who talk about what looks like the same experience is not the same experience

56:42 what do you think about that no no i think i think there's something to this and like um i look we're

56:46 all human and we all have like biases and different like i'm also look i work at open ai like i'm sure

56:51 i'm biased towards thinking these things are great right like i'm sure but there are also a lot of

56:55 people who don't want it to be the case that these are great useful at all and you know it's very easy

56:59 to find ways to to to confirm that but i think i don't know people can people like everyone's free

57:04 to do what they want. I think you're doing yourself a bit of a disservice if you're like completely

57:08 dismissive because it's, you know, it takes, again, it takes time to learn. And, you know,

57:15 at least for us, like one perspective I had on this for the team when I was being sort of like

57:20 really annoying, like CEO and like kind of like pushing agents on people and being like, we need

57:24 to be like trying this stuff. That's like every CEO right now is like super annoying. But I think

57:29 a very genuine thing that I like believe and said to the team was like all of our users,

57:34 not all of our users, a lot of our users are building with agents. And so if, if all the good

57:39 work we've ever done is ultimately rooted in like understanding our users and like how they work,

57:44 then like, we need to be like trying this stuff, even just to understand like what it's like to

57:48 build something. Yeah. Because I will tell you what, I am super thankful for rough in particular

57:53 rough in working with agents because I have in my rules, like, look, whenever you're done,

58:00 You run ruff format, you run ruff check.

58:02 And it's just another layer, especially for a non-compiled language like Python.

58:06 It makes the AI go, oh, I made a mistake.

58:08 It looks like that import's not really there.

58:10 You know, whatever, right?

58:11 It's really good.

58:12 Yeah.

58:12 And again, I think a lot of it's a skill.

58:15 I think weirdly, there's also like intuition to a lot of this, like that I don't know if I can explain.

58:20 Like sometimes I'll see people complain.

58:22 I mean, I think your point is exactly right, by the way,

58:24 which is people will be like, I tried AI and did X and it was great or it was terrible.

58:27 And it's like, they probably weren't doing quite the same thing.

58:30 But like, I'll see people say, how can these be useful?

58:33 I tried it once and like it hallucinated something.

58:35 And I don't know if I like, I don't think I've like dealt with like a real hallucination in

58:39 like a long time.

58:40 But like, if the model tells me something that it's like untrue, it's like, I can, I can,

58:44 if that does happen, I really think I can kind of tell.

58:47 And I don't know if I could explain to you why or how it's like, like, you just build

58:52 skills from this.

58:53 And I don't know.

58:54 I do think we're going to enter like a very strange time.

58:58 Like there's a bunch of, there's a bunch of things happening,

59:00 like sort of like escalating trends that I don't really know how to deal with.

59:03 Like, you know, I mean, one that gets talked a lot about a lot is like the,

59:07 the impact of agents on open source.

59:09 Like we feel this in our own projects.

59:11 We, the cost of putting up a plausible PR is like basically zero for like an

59:16 arbitrary contributor.

59:18 Like they can have the agent, you know, put something together that looks like it plausibly solves the issue.

59:22 And so it takes them one minute and then it takes us like an hour to like read and understand

59:27 the code, right?

59:28 Like that hasn't really gotten that much easier, the part where you actually read and verify

59:32 and understand.

59:33 Same with issues.

59:34 We see people posting clearly just LLM outputs.

59:37 And then if you reply and ask a question, they just paste the question back into the agent

59:41 and like paste the response back.

59:42 And it's like, what are we doing here?

59:43 Like, why is this a useful interaction, right?

59:46 And then that's like one big piece I think that we're seeing.

59:50 The other is like people are just going to start shipping.

59:53 Like you could imagine a world where every day there's like 10 people publishing a new

59:58 Python package manager written that's like fully built by an agent.

01:00:01 And some of those might be really good and some of them might be really bad.

01:00:04 I have no, but I don't think I'll be able to tell.

01:00:07 And so like I don't, it's like hard, it's a little bit hard for me sometimes to imagine

01:00:11 like what's going to happen to software.

01:00:13 Like if the cost of building something like that does really, in terms of time, does really

01:00:16 go down like so dramatically.

01:00:18 I don't think that we have a really good understanding of like what would change about the world.

01:00:22 Yeah.

01:00:23 Anyway, I think this is just, there's a lot of changing right now.

01:00:26 Not all good.

01:00:28 I think a lot good, but not all good.

01:00:30 And there are things that we're absolutely going to need to figure out over the next few years.

01:00:34 But it'll be a time of, yeah, enormous change.

01:00:37 Yeah.

01:00:37 It is an absolutely wild and weird time, both positive and negative.

01:00:41 I do think that, you know, take that example, if there's 10 random variations of Rust-based

01:00:48 package managers for Python, there becomes even more value in reputation, community,

01:00:55 and so on.

01:00:56 Yeah.

01:00:56 Right?

01:00:57 So I'm thinking like uv, Astral, I'm thinking Django, right?

01:01:01 You're like, oh, there might be a hundred new web frameworks, but Django actually has

01:01:05 conferences and fellows.

01:01:06 And like, there's a, there's not just somebody that vibe coded it until they got bored with

01:01:09 it.

01:01:10 but I think people will start to buy into multiple aspects of it,

01:01:14 and that might not just be pure code and functions.

01:01:17 Yeah, no, no.

01:01:18 And I think, I mean, to me, it kind of gets back to a little bit

01:01:20 of our team principles, which is we want to keep building things

01:01:23 that we think are great.

01:01:25 And by the way, on our team, we have an amazing team, I think.

01:01:29 There's a whole spectrum in terms of how much people use AI in their coding.

01:01:34 And some people are really effective with it.

01:01:35 Some people don't like it that much and are still trying to...

01:01:38 some people want to get better at it, but are still trying to learn

01:01:41 and figure out the ways to do it.

01:01:42 Like I, I'm not trying to be a person that's a serious say,

01:01:45 you shouldn't be opening your editor code.

01:01:47 But I do think like you should at least be curious about like what's happening.

01:01:53 You owe it to yourself and your career to at least track this stuff.

01:01:56 All right, Charlie, final thoughts.

01:01:58 Where are we?

01:01:59 Where are things going?

01:02:00 I guess let me, let me refine that a little bit.

01:02:02 I know that there's some people out there, some people who out there when they were,

01:02:06 they heard this announcement, like, whoop, that for uv, it's toast.

01:02:08 I don't think so. But maybe give some thoughts on just the specifically on the tooling,

01:02:14 the astral tooling, the community, the open source side of things as we wrap this up.

01:02:18 Yeah, definitely. I mean, I think we feel a lot of responsibility to our users. And like,

01:02:26 we've built something that has become very important to a lot of users and a lot of companies. And we

01:02:29 love working on it. The whole point of starting this company was to like help people build things.

01:02:34 And, you know, that like that remains true. Like, I think if you like the work we've done and you've been happy with how we've run our repos and our community, then like I think you will be happy with how things play out.

01:02:48 But, you know, but again, like I, it's easy for me to say these things now and we'll, we'll do our best to live up to the commitments that we've made to our users over time.

01:03:00 I do hope that we're able to ship some things that surprise people too.

01:03:06 But, but, you know, continuing to build the tools, the tools remain important and, you know, a crucial part of everything.

01:03:12 Wonderful. Well, again, congratulations to you and the whole team.

01:03:16 Thank you.

01:03:17 What a crazy and awesome experience.

01:03:19 And also just on the success of all the tools, UVRough, ty, those are very, very popular tools.

01:03:25 And they made a true dent in the Python ecosystem.

01:03:29 And they're still going.

01:03:30 Thank you.

01:03:31 Thank you, Michael.

01:03:31 It means a lot.

01:03:32 You bet.

01:03:33 Bye.

01:03:34 This has been another episode of Talk Python To Me.

01:03:36 Thank you to our sponsors.

01:03:37 Be sure to check out what they're offering.

01:03:39 It really helps support the show.

01:03:41 Take some stress out of your life.

01:03:42 Get notified immediately about errors and performance issues in your web or mobile applications with Sentry.

01:03:48 Just visit talkpython.fm/sentry and get started for free.

01:03:53 Be sure to use our code talkpython26.

01:03:56 That's talkpython, the numbers two, six, all one word.

01:04:00 If you or your team needs to learn Python, we have over 270 hours of beginner and advanced courses on topics ranging from complete beginners to async code, Flask, Django, HTML,

01:04:11 and even LLMs.

01:04:13 Best of all, there's no subscription in sight.

01:04:16 Browse the catalog at talkpython.fm.

01:04:18 And if you're not already subscribed to the show on your favorite podcast player,

01:04:22 what are you waiting for?

01:04:24 Just search for Python in your podcast player.

01:04:25 We should be right at the top.

01:04:27 If you enjoyed that geeky rap song, you can download the full track.

01:04:30 The link is actually in your podcast blur show notes.

01:04:32 This is your host, Michael Kennedy.

01:04:34 Thank you so much for listening.

01:04:35 I really appreciate it.

01:04:37 I'll see you next time.

01:04:51 We'll see you next time.