Why Python Still Dominates AI: Guido van Rossum on Readability and LLMs

TL;DR

• Python grew 49% year-over-year in 2025 despite TypeScript overtaking it on GitHub
• The NumPy → ML → LLM pipeline made Python the default language for AI development
• Guido van Rossum says AI should adapt to Python, not the other way around
• Python's readability and approachability remain its killer features as AI generates more code

The Big Picture

Python just lost its crown as GitHub's most-used language for the first time in years. TypeScript took over in August 2025. But here's the twist: Python still grew 49% year-over-year, and it remains the undisputed language of AI, data science, and education worldwide.

When GitHub shared this data with Guido van Rossum—Python's creator—his first reaction was surprise. Not concern. Surprise. Because while other metrics like the TIOBE Index tell a different story, GitHub's numbers reveal something specific: the explosion of TypeScript-scaffolded web projects and static sites flooding public repositories.

We sat down with Guido to understand why Python continues to dominate where it matters most. His answer cuts through the hype: Python won AI not through clever marketing, but through ecosystem gravity. Once NumPy existed, pandas followed. Once pandas existed, machine learning libraries followed. Once PyTorch existed, LLM tooling followed. Each layer built on the last, creating a compounding advantage that's nearly impossible to replicate.

This isn't a story about language wars. It's about design choices made three decades ago that accidentally built the foundation for the AI era. And it's about why, as AI tools like GitHub Copilot generate more Python than ever, the language's original values—readability, approachability, stability—matter more than they did in 1991.

How It Works

Python started as a practical solution to a painful problem. Guido was building utilities for a novel operating system in the early 1990s. His only option was C, where even reading two lines of input meant wrestling with buffer overflows and manual memory allocation. Shell scripts weren't expressive enough. C was too brittle. He needed something in between.

"I wanted something that was much safer than C, and that took care of memory allocation, and of all the out of bounds indexing stuff, but was still an actual programming language," Guido told us. That starting point—safety without sacrificing power—became Python's DNA.

The design choices that followed were deliberate. Indentation for grouping instead of braces. Friendly error messages that tell you what went wrong and where. A massive standard library that handles common tasks out of the box. Even the name—borrowed from Monty Python's Flying Circus—was a signal. "I wanted to express a little irreverence," Guido says. "A slight note of discord in the staid world of computer languages."

That irreverence translated into accessibility. Python doesn't produce core dumps for minor mistakes. It doesn't require a computer science degree to understand. And critically, it doesn't punish you for learning in public. Guido receives fan mail constantly with a common theme: "Python made my career. Without it, I wouldn't have gotten into software at all."

Fast forward to 2025, and Python's architecture is still evolving without breaking backward compatibility. The core team introduced soft keywords—context-sensitive syntax that preserves old code while enabling new features. It's a subtle engineering choice that lets enterprises stay stable while the language adapts to AI workloads, async patterns, and type hints.

But the real architectural win isn't in Python itself. It's in the ecosystem. NumPy provided foundational numerical arrays. Pandas made data manipulation approachable. PyTorch brought machine learning to scale. And now, projects like ollama are pushing local LLM inference forward—all in Python. Each layer compounds on the last, creating what Guido calls "ecosystem gravity." Once a language solves a problem well, it sparks an avalanche of new tools that take advantage of what already exists.

This is why Python dominates AI. Not because it's the fastest language (it's not). Not because it has the best type system (it doesn't). But because when researchers needed to prototype neural networks, PyTorch was already there. When data scientists needed to clean datasets, pandas was already there. When developers needed to run LLMs locally, the Python ecosystem had already solved the hard parts.

What This Changes For Developers

Python's position in AI creates a flywheel effect for developers. If you're building anything that touches machine learning, LLMs, or data pipelines, you're almost certainly writing Python. And if you're learning to code in 2025, Python is likely your entry point—especially in regions like India, which added 5 million developers to GitHub this year alone.

Guido sees this pattern constantly: "A lot of Python users and contributors do not have a computer science education … because their day jobs require skills that go beyond spreadsheets." Scientists, analysts, researchers, and tinkerers all gravitate toward Python because it gets out of their way. The syntax is clear. The error messages are helpful. The path from idea to working code is short.

This matters more as AI generates code. GitHub's Octoverse report shows that 80% of new developers use GitHub Copilot in their first week. When an LLM generates Python, it's generating a language designed for human readability. That's not an accident. It's a design choice from 1991 that pays dividends in 2025.

We asked Guido if Python needs stricter typing to handle AI-generated code better. His answer was immediate: "I don't think we need to panic and start doing a bunch of things that might make things easier for AI." He believes Python's optional typing system is "plenty." The real issue isn't Python's type system—it's the training data. "Most tutorials don't teach static typing," he says. "AI models don't see enough annotated Python."

But LLMs can improve. "If I ask an AI to add a type annotation," Guido notes, "it usually researches it and gets it right." His philosophy is clear: AI should adapt to developers, not the other way around. Python is for humans first. If AI struggles with that, the AI needs better training data.

For working developers, this means Python remains a safe bet. The ecosystem isn't fragmenting. The language isn't pivoting to chase trends. And the core team is obsessively focused on backward compatibility. "For every new feature, we have to very carefully consider: is this breaking existing code?" Guido says. That caution—often misinterpreted as reluctance—is exactly why Python has remained stable across three decades.

Try It Yourself

Python's AI ecosystem is accessible right now. If you want to see why developers choose Python for LLM work, here's a minimal example using Hugging Face Transformers to run a local model:

from transformers import pipeline

# Load a pre-trained sentiment analysis model
classifier = pipeline("sentiment-analysis")

# Run inference
result = classifier("Python's readability makes AI development approachable")
print(result)
# Output: [{'label': 'POSITIVE', 'score': 0.9998}]

This is three lines of actual logic. No manual tensor management. No CUDA configuration. No PhD required. The ecosystem handles the complexity, and you focus on the problem you're solving. That's the Python advantage in a nutshell.

If you're exploring AI-assisted development workflows, Python's clarity becomes even more valuable. When Copilot generates Python, you can read it, understand it, and modify it without deciphering cryptic syntax or hunting for type errors.

The Bottom Line

Use Python if you're building anything in AI, data science, or automation. The ecosystem is unmatched, the tooling is mature, and the community is massive. Skip it if you're building performance-critical systems where every millisecond counts—Rust or C++ will serve you better there. The real opportunity here isn't Python versus TypeScript. It's recognizing that Python's design choices from 1991—readability, approachability, stability—are exactly what AI-assisted development needs in 2025. As LLMs generate more code, the language that humans can actually read and maintain wins. Python won that race before it even started.

Source: GitHub Blog