Home
/
Podcast
/
Python for organizations with Josh Cannon from Anthropic

Python for organizations with Josh Cannon from Anthropic

February 12, 2025
Tools
Ankit speaks with Josh Cannon from Anthropic about the evolution and current state of Python, including its use in monorepos, the role of Pants, and challenges faced at scale.
Hosted by
Ankit Jain
Co-founder at Aviator
Guest
Josh Cannon
Technical Staff

About Josh Cannon

Josh calls himself many things: a software engineer, a build engineer, a developer productivity engineer, a spousal engineer, an offspring engineer, and on more than one occasion, “Dunder Seuss.” He works hard on things that are hardly working so that others don't have to work hard to get hard work done. That, combined with a sense for the "good" kind of clever has seen him help transform developers’ workflows from ordinary to extraordinary at notable tech companies big and small.

Josh on LinkedIn


On Python tooling, performance, and developer experience with Josh Cannon from Anthropic

Python is at an inflection point, says Josh Cannon, Pythonista working on the Developer Platform team at Anthropic, project maintainer at Pants, and sometimes a performer of edutainment on Python going by the name of Dunder Seuss.

He was also recently a guest on Aviator’s Hangar DX podcast where we discussed the evolution and current state of Python, its vibrant open-source community surrounding Python, the future of Python in AI, and the significance of developer tooling in the ecosystem.

Python has its baggage and history, but the developer experience has improved drastically in the last few years. According to Josh, the three main buckets of challenges are tooling, performance, and developer experience, which Python historically didn’t focus on.

Python’s rise in popularity—It overtook JavaScript as the top programming language in the GitHub Octoverse report—is the reason that all three have significantly improved recently.

There is no Standard

According to Josh, the lack of standardized tooling is the main thing affecting Python developer experience (or it’s just something he thinks about a lot).

Python doesn’t technically have a standard package manager. People are surprised when they hear that because pip exists. Pip is the de facto default, but it’s not the standard.
It’s a theme with Python, that there is no standard. It’s a good and bad thing. It’s an opportunity for companies like Astral to come and sweep Python developers off their feet with their uv, but it’s also the tragedy of the commons.
Python developers still have problems with virtual environments, teaching people how to set them up and where their Python code is being loaded from. Tools exist that try to solve these problems, but they’re still a problem.

Kill the GIL Project

When it comes to performance, Josh mentioned the speed improvements that the Faster CPython team at Microsoft has achieved. It gets better with each version, but it’s still not as good as with other languages like Go and Rust.

Python is a slow language. In some cases, that’s correct!
In some cases, Python is a bottleneck, but it’s not the bottleneck. Python is fast enough.

There is still the dirty three-letter word GIL, which makes Python inherently single-threaded. With tools like Asyncio developers have found a way to do asynchronous programming to get higher throughput, even with the GIL. And, of course, there is a recent ‘kill the GIL’ project taking off called freethreaded Python - from Python 3.13, you can download a version of Python with the GIL turned off and play around with it.

Move Fast Without Breaking Things

But when it comes to developer experience, Josh sees Python as the programming language that hits the sweet spot of moving fast without breaking things and being able to choose to break things without having to. Python is fun, but developers can still express themselves and get things done.

Python in Conflict with Itself

In Python, there is a natural challenge with what’s called research vs. engineering in the community. Python lends itself to more fluid, experimenting, just-want-to-get-something-done environments and mindsets, which is sometimes at odds with how you want to do engineering—creating something that you can own and maintain over time.

There is a broad trend of things where Python is in conflict with itself.

The Second Best Language for Everything

There is a saying that Python is the second-best language for everything, meaning Python is versatile enough to be used just about anywhere, but there is probably a better language you could use for any given situation.

Python works well enough. You can build entire organizations on top of Python and find success if you’re willing to find the stitches and smooth over them. It might not be the number one, greatest tool for that use case, but the fact that organizations can use one tool makes it valuable.

Easy to Pick Up, Easy to Mess Up

Python is easy to learn, but that’s a double-edged sword, says Josh. He experiences this the most when interviewing candidates for Python developer positions because there are people who claim they ‘know Python,’ but knowing Python is a spectrum.

Being able to write Python code is completely different from owning and maintaining Python libraries.

Python not being standardized is another double-edged sword, he says. Developers get to bicker and argue about which package manager should do what and for whom, but pip not being the standard allowed the UV to come along and take the Python world by storm.

Python at Anthropic

As an AI/ML company, Anthropic is mostly a Python company. Josh says that’s often seen in AI/ML companies - since they already use Python for their core research code, it happens naturally that the company uses Python for other forms of engineering.

We use Python by default, and only when Python breaks down we use something else.

Will LLMs write better code than humans?

It depends on what you mean by better, says Josh. Better performing, more readable, more maintainable? You get out what you put in, and LLMs are no different.

You have to think about what it is that you’re searching for in the generated code before you ride on your horse in the distance and let LLMs spew the code.

We use Python by default, and only when Python breaks down do we use something else.

Get notified of new episodes

Subscribe to receive our new podcast releases.

Listen on
Join Hangar DX
A vetted community of developer-experience (DX) enthusiasts.

Josh’s must-have Python tools, listen to the whole episode to learn what each of them does and why he likes them:

  • Astral - https://astral.sh/
    • ruff - https://github.com/astral-sh/ruff
      • And their typechecker, currently being built underneath `ruff` - https://github.com/astral-sh/ruff/issues/3893#issuecomment-2622505211
    • uv - https://github.com/astral-sh/uv
  • "Faster CPython team" - https://devblogs.microsoft.com/python/python-311-faster-cpython-team/
  • Some reference on "Freethreaded" Python (AKA "noGIL") - https://py-free-threading.github.io/
  • Pantsbuild - https://www.pantsbuild.org/stable/docs/introduction/welcome-to-pants
  • Libraries:
    • attrs - https://www.attrs.org/en/stable/init.html
    • pydantic - https://docs.pydantic.dev/latest/
      • And also pydantic-the-company: https://pydantic.dev/
    • fastAPI - https://fastapi.tiangolo.com/
    • Pallets org - https://github.com/pallets
      • flask - https://github.com/pallets/flask
      • jinja - https://github.com/pallets/jinja
      • click - https://github.com/pallets/click
    • typer - https://typer.tiangolo.com/
    • rich - https://github.com/Textualize/rich
    • textual - https://github.com/Textualize/textual

Chapters

00:00 Introduction to Python and Josh's Journey
02:54 The Case for Pants in Python Development
05:10 Anthropic's Use of Python
06:52 Scaling Python: Challenges and Solutions
09:50 The Role of Open Source in Python
11:59 Developer Experience in Python
14:00 Measuring Success in Python Development
16:33 Typing in Python: Benefits and Challenges
19:01 Performance and Multithreading in Python
21:04 The GIL and Python's Performance Challenges
23:13 Exploring Free-Threaded Python
24:30 Custom Build Systems in Python Development
24:49 Essential Tools for Python Developers
28:46 Standardization in Python Tooling
30:27 The Future of Python with AI and LLMs

Summary

Ankit speaks with Josh Cannon from Anthropic about the evolution and current state of Python, including its use in monorepos, the role of Pants, and challenges faced at scale. They discuss the vibrant open-source community surrounding Python, the future of Python in AI and the significance of developer tooling in the ecosystem.

Keywords

Python, Anthropic, Pants, Developer Experience, Open Source, AI, Developer Tooling.

Takeaways

  • Josh celebrated his 10th anniversary of learning Python.
  • Pants is particularly beneficial for Python monorepos.
  • Anthropic uses Python extensively for AI and ML applications.
  • Python's tooling and performance are improving significantly.
  • The open-source community for Python is vibrant and active.
  • Developer experience in Python is heavily influenced by tooling.
  • Python's GIL limits its multithreading capabilities.
  • AI is enhancing the usability of Python for developers.
  • Standardization in Python tooling is still a work in progress.
  • Venture capital is influencing the development of Python tools.

We use Python by default, and only when Python breaks down do we use something else.

Get notified of new episodes

Subscribe to receive new Hangar DX podcast releases.

We’ll be in touch with new episodes!