Python Was Built for Humans. AI Just Changed Everything.

In October 2024, Wes McKinney started building software he didn't think he'd ever have time to build. 

The creator of Pandas (arguably the world's most popular data framework) was grinding through a mental backlog of projects he'd accumulated over 20 years. Personal finance tools. Home lab dashboards. Content processing pipelines. Things he'd never been able to justify spending time on because the return on investment simply didn't add up.

Then something clicked. The same feeling he'd had nearly two decades earlier when he discovered Python.

But this time, the breakthrough wasn't about moving from Java to Python. It was about moving from human-written code to agent-generated code. And as Data Talks on the Rocks host Mike Driscoll discovers in this conversation, that shift is forcing one of Python's most influential architects to rethink everything, including the language itself.

The Epiphany That Changed Everything Twice

There's a specific moment that shapes a developer's career forever.

For Wes, it happened in 2007 at AQR Capital Management during the financial crisis. He was a fresh MIT math grad who thought he'd be doing modeling and partial differential equations. Instead, he found himself drowning in data wrangling, fighting with Java boilerplate, and watching his colleague's Python solution solve an algorithms problem in 30 lines instead of his 300.

His reaction was visceral:

How could this possibly in 30 or 40 lines of code do the algorithm that was like my 300 or 400 lines of Java?

Python gave him a feeling of empowerment. The ability to sit down, write code, solve problems, and get things done without fighting the IDE. That frustration with working with data eventually became Pandas, the library that transformed Python into the dominant language for data science.

Fast forward to October 2024, and Wes is experiencing that exact feeling again. But this time, it's not about a programming language. It's about coding agents.

The AI Skeptic Who Became a True Believer

Until January 2025, Wes was firmly in the AI skeptic camp.

He'd tried autocomplete. He'd dabbled with Cursor. He'd used Windsurf. His assessment was consistent:

I kinda had this feeling like, I don't need this. Like I'm good at writing code. This is not like a 10x for me. Like maybe this saves me a little time, a little Googling.

Then Claude Code launched in April 2025. Combined with major improvements in foundation models like Codex 5.2 and Opus 4.5, something fundamentally changed. The coding agents weren't just slightly better. They were unlocking entirely new ways of working.

Wes describes it with the same language he used for Python:

I started feeling like I can just do things.

He built a personal finance tool called Money Flow. He renovated his entire home lab with custom dashboards. He completely overhauled his website, transcribing and summarizing 114 conference talks from the past 16 years with AI.

Then came Spicy Takes, a project that processes 22 blogs and several thousand posts, extracting 31,000 quotes and grading them for "spiciness" based on how contrarian, sharp, or memorable they are. The system automatically scrapes new content, runs LLM analysis, and maintains a searchable database of hot takes from industry figures.

This isn't prototype code. It's production software that would have taken months to build the old way.

Why Python Suddenly Became a Ball and Chain

The most controversial insight from Wes's experiments is blunt: Python is holding back agent productivity.

Not for humans. For humans, Python remains wonderful: readable, enjoyable, with a great ecosystem. But agents don't care about readability. They don't get frustrated by boilerplate. What they care about is the speed of the feedback loop.

Python is so successful because it's good for humans. But in a world where agents are writing all of the code, all these benefits that Python has (its readability, its human ergonomics) the agents don't care about that.

The bottleneck shifted. When Wes built early agent projects in Python, the test suite became the constraint. Not the runtime performance. The time agents spent waiting for tests to complete before they could iterate.

His solution? He started building in Go. A language he barely knew months ago. A language that takes more human effort to write but compiles instantly, produces static binaries, and runs tests orders of magnitude faster.

The trade-off that defined 15 years of Python dominance (sacrificing performance for developer happiness) suddenly reversed when the developers became machines.

The Code Review System That Never Sleeps

Building at speed creates a new problem: quality control.

Wes found himself doing human-in-the-loop QA, manually testing agent-generated code and reporting bugs back. It felt dehumanizing. Worse, it was ineffective. Tons of bugs lurked beneath the surface that human testing couldn't find.

His solution was Robo Rev, a continuous code review system that uses adversarial agents to find bugs in other agents' work.

Here's how it works: Claude Code writes software and commits it. Immediately, a different agent (typically Codex) reviews the commit and identifies issues. Wes copies the review into his Claude session, which fixes the bugs and commits again. The cycle repeats automatically.

If all of your code isn't being automatically reviewed by adversarial agents, you've got tons of bugs lurking that you can't possibly find through your own human QA.

He's run over 3,000 reviews in three weeks. The system caught bugs he never would have found manually. It suggests refactoring opportunities, identifies code smells, and maintains quality at a scale impossible for solo human review.

The key insight? Different agents have different perspectives. Claude made the code, so it's less likely to see its own bugs. But Gemini or Codex, reviewing the same work, spots patterns Claude missed.

The New Skill Set: Reading, Not Writing

The most profound shift isn't about tools or languages.

It's about what developers actually do.

We're gonna be spending a lot more time reading code and interacting with code at a very high level structural like design patterns type level. Learning to write code? Not that important now.

Instead, the critical skills are architectural thinking and code design. Understanding refactoring patterns. Recognizing what makes software sustainable at scale. Being able to articulate to agents what's wrong with code and what patterns to apply.

His reading list recommendation? Martin Fowler's refactoring work. Bob Martin's Clean Code. Design patterns. Not because you'll implement them by hand, but because you need to explain them to agents and evaluate their suggestions.

Computer science education is gonna be more like English literature. We're gonna be studying software programs and understanding what makes them good so that we can explain better to our agents what we want.

It's engineering management for machines.

The Composable Future That Took a Decade

This transformation comes after years of building the infrastructure to make it possible.

Wes spent much of the last decade working on Apache Arrow, a cross-language data representation format designed to eliminate the Tower of Babel problem in data systems. Everyone was reimplementing CSV readers, building bridges between systems, wasting resources on interoperability.

Arrow was a radical social experiment. Get everyone to adopt an open standard for data interchange so developers could focus on productivity instead of plumbing.

The industry's reaction? "That's a nice idea. We'll implement it whenever everyone else implements it. We don't want to be the first movers."

It took 10 years. But now, if you're not using Arrow, you're behind the curve. Databricks just released an Arrow-native ADBC driver. The ecosystem is shifting from vertically integrated walled gardens to composable, modular systems.

The parallel to today's agent revolution is striking. Both required being willing to "be the chicken." To take the first step before it was obvious, to build incrementally until the ecosystem reached critical mass.

What Happens When Agents Write 100x More Code

Python isn't dying. That's not the story here.

We're gonna be writing more of everything. Probably a hundred times, at least ten times more of absolutely everything in aggregate.

Python's absolute usage will explode. But its market share will likely drop from 50-55% to maybe 30% as Go, Rust, TypeScript, and other languages capture larger portions of a massively expanding pie.

The distribution shifts because the optimization target changed. When humans wrote code, optimize for human happiness. When agents write code, optimize for the feedback loop.

It's the same pattern that drove every previous platform shift. The underlying economics change, and the tools evolve to match.

The difference this time? The shift is happening in months, not years. Wes went from AI skeptic to building production agent systems in under six months. His workflow completely transformed. He's writing in languages he barely knew and building tools he never thought he'd have time for.

If you want to understand how the next generation of software gets built, this conversation is essential.

Watch the full episode on Data Talks on the Rocks.