#566: State of the art in Python 2026

Summary of #566: State of the art in Python 2026

by Michael Kennedy

1h 5m•October 17, 2026
Listen to Episode

Overview of #566: State of the art in Python 2026

In this episode of Talk Python to Me, Michael Kennedy and a panel of experienced Python practitioners take stock of the Python ecosystem in 2026. The big theme is that AI has reshaped almost every tooling decision: editors are becoming agent front-ends, terminals are more capable than ever, packaging has largely consolidated around uv, and even documentation, type checking, and hosting are increasingly being chosen with AI-native workflows in mind.

Main themes and takeaways

  • AI has changed the default workflow: Several panelists now spend more time directing agents than writing code line-by-line.
  • uv has become the packaging and environment winner: It replaced a lot of the friction around Python installs, virtual environments, and script execution.
  • Python tooling is increasingly agent-friendly: Type hints, structured docs, and CLI-based workflows all help coding agents produce better code.
  • The terminal is back in a big way: New terminal apps and multiplexers are thriving because agentic workflows need rich command-line environments.
  • Classic Python web choices still matter: Django, FastAPI, Flask, and newer options like Robyn all have a place depending on the project.
  • Postgres remains the default database, but DuckDB and SQLite are getting more attention for local, embedded, and analytical workloads.
  • Documentation is becoming machine-readable by design: Teams want docs that help both humans and LLMs.

Tooling trends by category

Editors and code-writing workflows

The most surprising shift was that “editor” is no longer always the primary place where code gets written.

  • Sydney Runkle said most of her work now starts in Slack, where she tags an agent and coordinates changes there before drilling into GitHub or local code only when necessary.
  • Michael and others noted the rise of Cloud Code-style workflows, where coding happens through agents more than through direct editing.
  • Traditional tools are still around:
    • VS Code
    • PyCharm
    • Cursor
    • Vim / NeoVim
    • Emacs
  • Some panelists use editors mostly as a fallback for inspecting or fine-tuning what the agent produced.

Terminals and shell workflows

There was a strong sense that terminal UX matters more than ever because so much AI tooling is CLI-driven.

  • Popular terminal choices mentioned:
    • Kitty
    • Ghostty
    • iTerm2
    • Warp
    • WezTerm-style alternatives were implied in the broader discussion
  • Multiplexing and session management are increasingly important:
    • tmux
    • Herder
    • cmux
  • The rise of terminals with built-in AI or agent support was highlighted as a major 2026 trend.

Packaging and Python environment management

This was the most unanimous category in the episode.

  • uv is the clear favorite
  • Reasons people like it:
    • Extremely fast
    • Handles Python version management, dependency installs, and tool execution
    • Hides much of the pain of virtual environments
    • Works well for both humans and agents
  • Related workflow ideas:
    • PEP 723 inline dependency declarations for single-file scripts
    • uv run / uvx for quick execution without manual environment setup
    • Some panelists emphasized that uv can bootstrap Python itself, which makes it especially useful for automation and AI agents

Web frameworks and data modeling

FastAPI, Django, Flask, and Robyn

The panel agreed there is no single “winner,” but the balance has shifted based on use case:

  • FastAPI
    • Loved for speed of development, validation, and OpenAPI integration
    • Still a great choice for clean APIs and AI-assisted workflows
  • Django / Django Ninja
    • Preferred when the project may grow into something larger
    • Strong option when you want a fuller framework with lots of batteries included
  • Flask
    • Still common for quick, simple apps
    • Frequently used where there is already lots of LLM training data and example code
  • Robyn
    • Mentioned as a personal-project choice
    • Noted as Rust-based and Flask-like, but with less code available for models to learn from

Pydantic’s role

Pydantic came up repeatedly as a core enabler of modern Python:

  • It provides structured validation in a language that is otherwise very flexible
  • It underpins FastAPI
  • It also helps with LLM output validation and structured agent workflows
  • Several panelists see it as the bridge between Python’s dynamic nature and the need for more predictable, machine-checked data

Type hints and static analysis

The panel was generally supportive of typing, though for different reasons.

  • Sydney is strongly pro-typing and emphasized the value for maintainability, AI code generation, and structured data
  • Calvin and others said they still appreciate Python’s dynamic roots, but use types more when working with agents
  • The practical consensus:
    • Use type hints for public APIs and places where correctness matters
    • Let tools like agents, IDEs, and validators benefit from the extra structure

Type checkers mentioned

  • Ty was the most enthusiastically discussed modern option
  • MyPy is still widely used and familiar
  • Pyrefly also got a shoutout for being fast and Rust-based

Databases

The consensus remained that Postgres is still the default “serious app” database.

Also discussed

  • SQLite
    • More production-friendly than many people used to think
    • Great for embedded and single-machine apps
  • DuckDB
    • Increasingly popular for local analytics and fast querying
    • Especially useful for structured data and Parquet/JSON workflows
  • MongoDB
    • Valued for operational simplicity and schema flexibility
  • ZODB, LMDB, and other niche options were mentioned as interesting alternatives

Emerging pattern

A lot of the panel’s thinking is now about pairing:

  • a relational system like Postgres for structured app data
  • with blob/object storage for large artifacts produced by agents or AI systems

Documentation: human-readable and AI-readable

Docs were a surprisingly important part of the discussion because they are now part of the AI toolchain.

Tools mentioned

  • MkDocs
  • Material for MkDocs
  • Zensical
  • Great Docs
  • Mintlify

Why docs matter more now

  • Agents need docs they can ingest directly
  • Good docs can include:
    • Markdown outputs
    • “copy as markdown”
    • LLM-friendly snippets
    • package “skills” or usage recipes
  • The panel liked tools that make documentation both polished for humans and useful for agents

Hosting and deployment

There was no single hosting winner, but the discussion showed a split between hyperscale and lightweight deployment models.

Common choices

  • AWS
    • Still dominant for larger production workloads
    • EKS, ECS, and related container systems are widely used
  • Cloudflare Workers
    • Very appealing for lightweight Python deployments and replacing small automation workflows
  • DigitalOcean
    • Praised for simplicity and good value
  • Hetzner
    • Mentioned as a solid option, though pricing changed as demand increased
  • Oracle Cloud / ZenEdge also came up in a CDN/WAF context

Key deployment trend

Containers remain important, but Cloudflare-style edge compute is becoming more practical for small services and automations.

AI tooling and agent workflows

This was the connective tissue across the whole episode.

Tools and ideas mentioned

  • Cloud Code
  • Pi
  • OpenCode
  • Kiro
  • Slack-based agents
  • Notion-based agents
  • Agents View
  • MCPs
  • skills
  • memory for agents

What the panel cares about now

  • Making agents use the right tools
  • Giving them structured context
  • Evaluating them with observability
  • Keeping them inside typed and testable boundaries
  • Teaching them project-specific skills rather than hoping they infer everything correctly

Practical recommendations from the episode

  • Use uv for new Python projects unless you have a strong reason not to
  • Prefer type hints on public-facing code and anything you expect agents to touch
  • Validate agent output with ty, ruff, and tests
  • Choose docs tooling that can serve both humans and LLMs
  • Use Postgres by default, then reach for SQLite or DuckDB when the workload is local or analytical
  • Consider agent-first workflows for tasks that are repetitive, multi-step, or well-supported by docs and CLI tools
  • Keep an eye on observability and cost when using AI coding tools heavily

Notable final impression

The episode’s biggest message is that Python in 2026 is still Python, but the workflow around it has changed dramatically. Instead of asking only “Which editor should I use?”, the more relevant question now is: Which tools help me collaborate best with AI agents while still keeping code correct, typed, testable, and maintainable?