Ai on BlueberryPy

This Month for Pythonistas - September 2026

Zeyang Lin — Wed, 30 Sep 2026 13:00:00 GMT

from datetime import date

print(date.today().year, date.today().month)
# 2026 9

Welcome back Pythonistas! This is the September 2026 issue of “This Month for Pythonistas”, curating Python news, tutorials, articles, podcasts, repositories and community highlights for this month.

Before we continue, please note that this blog is synced across the following platforms:

Ready? Let’s get started!

RISC-V is now officially supported by CPython!

CPython now officially supports RISC‑V as a tier‑3 platform, thanks to months of community work and RISE project hardware. Contributors fixed architecture‑specific issues, improved builds, and added testing on real hardware. Ongoing CI integration and potential tier‑2 promotion are planned, plus architecture‑specific optimizations. Users with RISC‑V hardware are encouraged to build CPython, run workloads, and report issues to help improve support.

GPT-6.1 Sol

OpenAI introduced GPT‑6.1 Sol, an upgraded version of GPT‑6 Sol tuned for agentic coding, computer use and professional work, delivering performance close to flagship GPT‑6 Astra at roughly one‑fifth the price ($2/$10 per million input/output tokens, $0.10 cached). It gains +6.4 points on DeepSWE, beats Opus 5.5 on GDP.pdf and AutomationBench at far lower cost, improves OSWorld 2.0 by 7 points, more than doubles Terminal‑Bench Science scores, and lowers factual‑error rate to 4.1%, with stronger alignment.

Introducing Claude Opus 5.5

Anthropic introduces Claude Opus 5.5, the first model in its Claude 5.5 family — a new flagship roughly matching Claude Fable 5.1 while costing ~40% less than Opus 5 ($4/$20 per million tokens, $0.20 cache reads) and producing output 30%+ faster. It leads in agentic coding, computer use, knowledge work, and science benchmarks, with testers citing dramatic efficiency gains on long jobs like codebase migrations. It scores best-ever on Anthropic’s behavioral audit, resists prompt injection better, keeps biology/cyber safeguards via verification programs, and writes more clearly.

Introducing Claude Sonnet 5.5

Claude Sonnet 5.5 is the second model in the Claude 5.5 family: a faster, cheaper complement to Opus 5.5, best for well-scoped everyday tasks, bug fixes, and polished documents, slides, and spreadsheets. It runs 30%+ faster and costs up to 30% less per task than Sonnet 5 at unchanged pricing. Gains are dramatic — 70.6% versus 10.3% on Terminal-Bench 4.0, near-Opus results on GDPval-AA, OSWorld, and chart recognition, and it’s the first Sonnet to beat Pokémon Red from screenshots alone.

New Versions

Python 3.15.0 candidate 2 is here!

This release, 3.15.0rc2, is the final planned release candidate, containing around 144 bugfixes, build improvements and documentation changes from 76 contributors since 3.15.0rc1. The next release of Python 3.15 will be 3.15.0 final, scheduled for 2026-10-01.

PyTorch 2.14 Release Blog

PyTorch 2.14 is released, built from 2,995 commits by 487 contributors since 2.13. Highlights include NVGEMM (CuTeDSL-based CUTLASS GEMM kernels in Inductor with epilogue fusion and NVFP4 support), a preview of the rewritten “nccl2” NCCL backend from torchcomms, first-class fault tolerance in c10d with in-place process-group reconfiguration, one-sided RMA windows, and a backend-agnostic Flight Recorder. Apple Silicon gains native linear algebra (SVD, QR, Cholesky) plus more Metal kernels. New compiler features include torch.switch, graph-captured while_loop, declarative @dynamic_spec shapes, experimental complex-tensor compilation, Python 3.15/free-threaded wheels, and expanded ROCm 7.14, Intel XPU, and NVIDIA Rubin support.

PyPy v8.0.0 release

PyPy v8.0.0 is a major version shipping three interpreters: PyPy2.7, PyPy3.11 (likely the last 3.11 release), and a first-ever “beta”-quality PyPy3.12. The major bump reflects Linux builds moving to manylinux_2_28 (AlmaLinux 8, glibc 2.28, gcc14). Python 3.12 adds cp312-abi3 support by hiding PyPy’s internal ob_pypy_link field, so CPython limited-ABI wheels should work — though import machinery and pip/uv acceptance remain unfinished. RPython code generation improved via computed gotos, inlining, and source-mapping comments. The internal HPy backend was dropped, and the clang-based pyhdrdump tool was revived.

Tutorials

deeplearning.ai’s Building Adaptive AI Agents by Oracle

In this course, you’ll work with three adaptation layers. For behavior adaptation, you’ll build a skill induction pipeline that turns the agent’s traces, its conversations, tool calls, errors, and fixes, into reusable skills it applies the next time it sees a similar task, with a human in the loop approving each skill. For knowledge adaptation, you’ll build a code knowledge graph that connects files through imports, function calls, and co-edits in git history, so the agent retrieves context by navigating the structure of the codebase instead of relying on keyword search. For model adaptation, you’ll learn when it makes sense to adapt the model itself with techniques like fine-tuning.

deeplearning.ai’s Building AI Assistants with On-Device Memory by Qdrant

A cloud-based assistant can remember what it sees, hears, and is told, but only by staying connected and sending that data to a remote server. An assistant that runs on the device builds that memory locally instead. Every note, photo, or recording becomes a vector you can search by meaning, tag with context, and delete on command, all without leaving the device.

RealPython’s How to Write an AGENTS.md File for a Python Project

An AGENTS.md file gives your AI coding agent the context it needs to write code that fits your project’s guidelines. It’s a plain Markdown file at your project root where you can pin your Python version, dependency manager, coding conventions, and constraints. In this tutorial, you’ll build one of these files section by section and watch your agent go from sloppy output to clean, idiomatic code.

RealPython’s How to Review AI-Generated Python Code Efficiently

An AI coding agent writes code faster than any human can read it, which makes you the bottleneck. Your job and responsibilities stay the same, but the volume and speed increase. To manage this, you need to review the code with a plan. You can’t read every line, so focus on the parts where the risk is highest.

Articles

Speeding Up a Python Service with CinderX: JIT and Static Typing

This article examines CinderX, a CPython extension adding a full JIT compiler, “Static Python” typed subset, parallel garbage collector, and heap immortalization. Unlike CPython 3.14’s cheaper copy-and-patch tier 2, CinderX compiles entire functions through typed HIR/LIR SSA passes into machine code. Benchmarking a real recommendation service shows only typed kernels plus JIT meaningfully helped: throughput rose from 140 to 250 requests/second, p99 fell from 279ms to 13ms. Flags alone changed nothing; NumPy-bound endpoints gained zero. Types without JIT cost 3.4× more.

Soft-deprecating re.match()

This post from Hugo van Kemenade explains Python 3.15’s soft deprecation of re.match(), whose start-anchored-but-not-end-anchored behavior surprises many developers. Soft deprecation, introduced by PEP 387, is a documentation-only recommendation: no warnings, no removal, and it doesn’t graduate into hard deprecation. The release adds re.prefixmatch(), an explicit alias for match(), embodying “explicit is better than implicit.” New code should use prefixmatch() for prefix matching, re.search() for unanchored matching, or re.fullmatch() when both ends must match; existing code supporting older Pythons can keep match(). The post includes a comparison table and Ruff config to ban re.match().

Introducing wrapture

Wrapture is a Python library that wraps real code rather than replacing it, enabling observation, testing and monkey‑patching from a single mechanism. Bindings name target methods, a timeline records calls with arguments, return values and call‑graph nesting, and can be queried in tests or streamed to sinks (printer, JSON, OpenTelemetry). The same bindings also support stubbing, raising, argument/result transforms, and ad‑hoc tracing of running applications without code changes.

The Mullet Stack: JavaScript in the front, Python in the back.

The Mullet Stack guide pairs React + TypeScript frontend (Vite) with FastAPI + Pydantic backend, JavaScript in front, Python in back. It walks through parallel setup, defining/validating an Item model, contrasting TypeScript’s build-time structural typing with Pydantic’s runtime validation, testing with Vitest and pytest, handling CORS, and deriving frontend types from FastAPI’s OpenAPI schema via openapi-typescript to prevent drift, noting alternatives like Django, Next.js, GraphQL, and concluding codegen unifies the stack.

Making a Python interpreter in 1024 bytes

The author describes building a Python-like interpreter in just 1024 bytes of C code, targeting a FizzBuzz program with recognizable Python syntax (def, colons, indentation). His first 512-byte attempt failed. Rather than tokenizing/compiling like CPython, he uses global arrays for source and symbols, recursive-descent parsing that executes immediately, the C call stack for indented blocks, and backward jumps re-parsing the source for loops and function calls (even recursion). Heavy “code golf” tricks — single-letter names, ASCII comparisons, bitwise/ternary tricks, C89 implicit ints — shrank a 4800-byte readable version to 1024.

How Libraries Run Rust Inside Python (with PyO3)

The blog post explains how libraries like Pydantic v2 embed Rust in Python using PyO3, demonstrated with a hand-rolled JSON parser. Four steps get Rust into Python: write a Rust module, annotate it with #[pyfunction]/#[pymodule] macros, compile with maturin into a shared library, and import it. The parser returns a Rust JsonValue enum, which Python never sees directly. The key insight: .into_pyobject() must rebuild the entire tree as native Python objects, so on large documents this conversion can cost more than parsing itself. Errors translate via a From impl into Python exceptions. For scalar returns, port freely; for large structures, profile the boundary and consider lazy, Rust-backed views.

Creating temporary files in Python

This article by Trey Hunner explains creating temporary files and directories using Python’s standard-library tempfile module. NamedTemporaryFile creates a file deleted when its with block exits; use delete=False (or Python 3.12’s better delete_on_close=False) to keep the file so other code can use its name, then delete it manually. TemporaryDirectory offers an auto-deleted folder. TemporaryFile returns only a file descriptor, not a real filename, so a named file is usually preferable. Prefer pytest’s built-in temp utilities when available; otherwise use NamedTemporaryFile and TemporaryDirectory.

pytest plugins that actually change how you test in 2026

In this hands-on guide, the author recommends seven pytest plugins that reshape testing workflows in 2026: pytest-httpx mocks HTTP at the transport layer and fails tests when registered mocks go unused; pytest-randomly exposes order dependencies via randomized runs and reproducible seeds; anyio’s built-in plugin simplifies async tests across asyncio and trio backends; syrupy enables snapshot or golden-file testing; pytest-watch reruns tests on file save; freezegun deterministically freezes time, avoiding the outdated pytest-freezegun wrapper; and pytest-cov, configured with branch coverage, skip-covered reporting and thresholds, reveals real gaps. Together they form a free, no-subscription testing stack.

Agentic Engineering in Python: From Vibes to Evidence

This article introduces agentic engineering — delegating bounded coding tasks to AI agents while humans retain ownership of intent, constraints, review, and release. Unlike vibe coding, which accepts plausible-looking output, agentic engineering demands evidence. It centers on two loops: a fast agent execution loop and a slower human acceptance loop. Key tools include the eight-level Engineering Evidence Ladder (from code existing to CI integration) and the RECAP review checklist (Role, Edges, Contracts, Assumptions, Proof). The article also warns against implementation-mirroring tests, scope creep, poor audit trails, and excessive agent access.

Podcasts

🐍 RealPython Podcast

🍕 Python Bytes Podcast

📣 Talk Python to me

Repositories

BruceEckel/ThinkingInPython (CC BY-NC-ND 4.0)

An intermediate-to-advanced book for experienced programmers. It opens with a fast introduction for programmers coming from other languages.

reflex-dev/xy (Apache 2.0)

XY is an extremely fast, interactive, customizable Python charting library for the web, notebooks, and static exports. Charts are composed declaratively or through matplotlib conventions. You can fully customize them with Python, CSS, or Tailwind.

gi0baro/tonio (BSD-3-Clause)

TonIO is a multi-threaded async runtime for free-threaded Python, built in Rust on top of the mio crate, and inspired by tinyio, trio and tokio. It supports both using yield and the more canonical async/await notations, with the latter being available as part of the tonio.colored module.

Have time for some fun?

The Move to Python 3 Begins!

EVE Online has begun migrating its 2.4-million-line Stackless Python codebase from Python 2.7, unchanged since 2010, to Python 3 as part of the EVE Forever initiative. First Singularity-tested changes are now live, with success defined as invisibility to players. Motivations include major Python 3 performance gains, access to modern libraries, debuggers and profilers, and cleaner strings, integers and classes. The staged approach first uses Python-Future to make code parse under both versions — 95.9% already does, with only ~3,300 blocking lines — before tackling ~20,000 lines with changed behavior like division.

As we wrap up this journey together, I want to take a moment to express my gratitude for your reading. If you’ve enjoyed this issue and would like to help sustain this blog, please consider starring this blog on github, it would be great motivation for me to keep updating!

Alright, that concludes the September Edition of “This Month for Pythonistas”. Thank you again for reading my post and I hope you enjoy it or find something useful. Happy coding and see you in October! 👋

This Month for Pythonistas - August 2026

Zeyang Lin — Mon, 31 Aug 2026 13:00:00 GMT

from datetime import date

print(date.today().year, date.today().month)
# 2026 8

Welcome back Pythonistas! This is the August 2026 issue of “This Month for Pythonistas”, bringing you curated Python news, tutorials, articles, podcasts, repositories and community highlights for this month.

Before we continue, please note that this blog is synced across the following platforms:

Ready? Let’s get started!

DjangoCon US 2026

DjangoCon US 2026 took place in Chicago at the voco Chicago Downtown from August 24–28, 2026. It featured in-depth technical talks, hands-on workshops, Open Spaces, and community sprints. Key session topics spanned web development, Django 6.x features, API integration, deployment, security, testing, HTMX, and AI integration within the Django ecosystem. Attendees also engaged in networking, hallway discussions, and collaborative open-source contributions throughout the week.

Django is moving to an annual release cycle

Django’s Steering Council accepted DEP 20 to move Django to an annual release cycle starting January 2028, with one feature release per year carrying three years of LTS-level support and version numbers reflecting the release year (e.g., Django 2028, 2029). Every release becomes an LTS with three years of support (one year mainstream bugfixes, two years security fixes), retiring the old “LTS” label. The new cycle aligns better with Python’s annual October releases, with each Django version supporting the three latest Python versions. API stability and deprecation policies remain unchanged, and the transition begins with Django 6.1 (Aug 2026) and 6.2 LTS (Apr 2027) as the final releases under the old cycle.

Qwen3.8-Max: A New Bar for Coding and Cowork

Qwen3.8-Max is officially released as the most capable model in the Qwen family, scaling to 2.4 trillion parameters and delivering comprehensive improvements across coding, work, research, and long-horizon tasks. It is the first open-weight Qwen-Max-class model, with weights released on HuggingFace and ModelScope. Key capabilities include autonomous coding (building a self-evolving harness over 10+ days), reproducing and improving research papers (beating the original by +2.7 points on AIME24), and outperforming 87% of human teams in the WWW2025 challenge. It also excels at real-world work tasks, long-horizon planning (autonomous chip design, e-commerce operations), and multimodal agent tasks with visual feedback loops.

GLM-5.3: Frontier Coding with Emergent Cyber Capabilities

GLM-5.3 is a frontier coding model that uses the same base as GLM-5.2 but achieves major gains through scaled post-training alone. It is the most capable open-weights model for coding — 50% better than GLM-5.2 on Z.ai’s Code Bench and state-of-the-art on Terminal Bench 3.0 and Agents’ Last Exam — while also showing emergent cyber capabilities, scoring best on CyberGym and more than doubling GLM-5.2 on exploitation benchmarks. The model identified 2,436 vulnerabilities across 269 real-world projects, and its open-source weights will be released in two weeks.

Introducing Gemini 3.7 Flash

Gemini 3.7 Flash is Google’s most intelligent workhorse model for coding and agents, released three weeks after Gemini 3.6 Flash based on developer feedback. It delivers substantial improvements in software engineering, knowledge work, and web development at half the original 3.6 Flash cost. The model achieves strong gains in coding benchmarks (FrontierCode 1.1: 43.6% vs 34.4%; DeepSWE v1.1: 65.3% vs 49.0%), outperforms 3.6 Flash on WebDev Arena (Elo 1588 vs 1538), and excels in knowledge-dense fields like finance and law (GDP.pdf: 34.0% vs 22.0%).

New Versions

Python 3.15.0 candidate 1 is here!

This is the first of two planned candidate releases. Entering the release candidate phase, only reviewed code changes which are clear bug fixes are allowed between this release candidate and the final release. The next release of Python 3.15 will be 3.15.0rc2, scheduled for 2026-09-01.

The source tarballs and binary distributions can be downloaded here.

Python 3.14.7 and 3.13.15 are now available!

Python 3.14.7 is the seventh maintenance release of 3.14, containing around 499 bugfixes, build improvements and documentation changes from 86 contributors since 3.14.6. Python 3.13.15 is the fifteenth maintenance release of 3.13, containing around 400 bugfixes, build improvements and documentation changes since 3.13.14.

Python 3.12.14, 3.11.16 and 3.10.21 are now available!

These are new security releases for 3.12, 3.11 and 3.10, respectively, addressing numerous security vulnerabilities.

Tutorials

deeplearning.ai’s AI Coding Workflows: From Cloud to Local by Paul Everitt

You’ll use the same Python app to put each setup to the test: first from a Claude Code baseline, then with subagents that break the job into focused tasks, then with a cheaper model doing the routine work. From there you’ll switch to an open-source coding agent, connect it to different inference providers, and finally run models locally.

RealPython’s How to Integrate OpenTelemetry With a FastAPI App

Adding observability to your applications is crucial for diagnosing issues in production. In this tutorial, you’ll learn how to integrate OpenTelemetry — an open-source observability framework — into a FastAPI application. After following along, you’ll be able to instrument FastAPI with OpenTelemetry to export traces and correlate them with your application logs, allowing you to explore your telemetry in a dedicated dashboard.

Articles

Why the Hardest Concept for Python Devs Is Concurrency: asyncio vs threading vs multiprocessing

This article explains why concurrency is one of the hardest concepts for Python developers, covering how operating systems manage processes and threads, the role of the kernel and system calls, and how CPUs execute code in user and kernel modes. It explores Python’s Global Interpreter Lock (GIL), which prevents multiple threads from running Python bytecode simultaneously, and compares three concurrency approaches: asyncio (cooperative multitasking via an event loop for I/O-bound work), threading (preemptive multitasking for I/O-bound tasks that release the GIL), and multiprocessing (true parallelism for CPU-bound work). The article also discusses CPU vs. GPU specialization, Amdahl’s Law, profiling tools like Python 3.15’s Tachyon sampler, and practical guidance for choosing the right concurrency model in real applications like FastAPI.

Scaling NumPy on Free-Threaded Python

Scaling NumPy on free-threaded Python required eliminating multi-threaded bottlenecks that prevented linear scaling across cores. Profiling revealed five key issues: lock contention in tracemalloc (fixed with atomic operations), lock contention in the ufunc dispatch cache (replaced with a lock-free concurrent hash map), reference count contention on global PyCapsule objects (resolved by making the default memory handler immortal), module attribute lookup contention (enabled bytecode specialization for __getattr__ modules), and memory allocator contention (routed NumPy allocations through CPython’s raw allocator backed by mimalloc). Coordinated changes across both NumPy and CPython yielded dramatic results — multi-threaded performance at 32 workers improved from ~44 seconds to ~1.5 seconds, outperforming multi-processing by 4x.

Running subprocesses in Python

The article explains how to run subprocesses in Python using the subprocess module, primarily the subprocess.run() function. It covers launching external programs by passing commands as a list of arguments or a string with shell=True, capturing subprocess output using capture_output=True, decoding bytes to text with text=True, checking the returncode to detect errors, and using check=True to automatically raise CalledProcessError exceptions on non-zero exit codes. The article also recommends creating custom wrapper functions around subprocess.run() to reduce repetitive keyword arguments when running multiple subprocesses in a script.

Two lines of Python that segfault the interpreter

This post describes a CPython crash caused by a type confusion in the SET_ADD bytecode opcode, triggered by PEP 749’s conditional annotations feature. PEP 749 introduced lazy annotation evaluation, requiring a __conditional_annotations__ set to track executed annotations — but this set is an ordinary module global that user code can rebind. When reassigned to an int, SET_ADD (which skips type checks, assuming its operand is a stack-allocated set) casts the int to a PySetObject* and dereferences invalid memory, causing a segfault with no traceback. The fix differs by branch: on main, a dedicated add_conditional_annotation intrinsic with its own type check replaces SET_ADD for annotations; on released 3.14/3.15 branches, SET_ADD was patched to verify the operand is actually a set. The author notes that implicit compiler guarantees are fragile contracts — a safe invariant for one caller can silently become a vulnerability when a new caller appears.

When str.lower() is a security vulnerability in Python

This post from Seth Larson describes a Python security vulnerability (CVE-2026-17084) involving str.lower(). The IDNA 2003 standard (str.encode("idna")), built on StringPrep from RFCs 3491/3454, requires case-folding per Unicode 3.2.0 tables B.2/B.3. However, Python’s implementation calls str.lower(), which uses whatever newer Unicode version ships with the interpreter, causing certain characters (like Cherokee U+13A0) to encode differently than the specification requires — a divergence exploitable as a vulnerability. The fix added exception mappings emulating Unicode 3.2.0 behavior; credits go to Bitshift, Stan Ulbrych, Marc-Andre Lemburg, and Petr Viktorin.

Binary search in Python with bisect

Python’s bisect module provides built-in binary search for sorted lists, offering O(log n) performance far faster than linear iteration. The article explains binary search conceptually through a number-guessing game, clarifies that “bisect” means cutting into two pieces, and details the module’s core functions (bisect_left, bisect_right, insort_left, insort_right) and their aliases. It covers practical recipes like finding exact matches, counting duplicates, locating first/last matches, and finding the closest value, while emphasizing that binary search excels at inexact or range-based lookups that sets and dictionaries cannot handle efficiently.

Celery: from first task to advanced recipes

Celery is a mature distributed task queue system for Python that enables decoupled producer-consumer integration. This article covers its core concepts — brokers and backends, task definition, and worker configuration — along with practical recipes: running tasks from the command line and code (including remote calls via send_task), using Canvas signatures and groups for batch execution, configuring queues, setting time limits (timeout, expires, soft/hard limits), implementing retry logic for transient errors, preventing parallel execution with Redis locks, and awaiting task results asynchronously.

One agent, every surface: how we built the Kiro agent harness

Kiro consolidated three separate agent harnesses (IDE in TypeScript, CLI in Rust, web in Python) into a single unified agent harness running as a standalone server process. Previously, each client had its own agent with incompatible session formats, tools, and permissions, making cross-client session continuity impossible. The new harness communicates with all clients via the Agent Client Protocol (ACP), extended with Kiro-specific features like live steering and rich permissions. This eliminates duplicated effort, ensures consistent behavior across surfaces, and enables features like spec-driven development, custom agents, and hooks to work identically everywhere.

Building an Advanced Agentic Harness

The article explains how to upgrade a basic agentic harness into a production-grade system by composing small, testable primitives rather than hiding mechanics behind frameworks. It uses an air campaign analogy: just as real operations add mission planners, parallel squadrons, fuel budgets, flight recorders, and after-action reviews around a pilot, production agents need structure around a single LLM call. Key primitives include typed tools with Pydantic validation, a DAG-based planner for parallel execution, tiered memory, a verification hierarchy, multi-dimensional budgeting, and a tracer. Each primitive addresses a specific failure mode of naive agents (invalid arguments, silent errors, context bloat, cost runaway).

Designing Loops for Production-Grade Work

Liquid AI’s blog describes a late-2025 experiment testing whether coding agents could autonomously solve a production-grade problem from scratch. Two agents — Claude Opus 4.5 and Codex with GPT-5.2 — were tasked with building toktoktok, an open-source BPE tokenizer trainer capable of processing trillions of tokens on a single machine. Neither succeeded zero-shot on toy data, but through iterative loops against real production data and an external verification harness (checking tiktoken/Hugging Face compatibility), Claude Opus 4.5 delivered a working solution. Key lessons: write short, constraint-focused specifications leveraging agents’ multi-domain expertise, and design loops that converge against real-world constraints rather than self-reported tests.

The Shapes of Agent Memory – Files, Stores, and Experience

This article compares three architectures for agent memory that persists across sessions: files, structured stores, and trained experience.

File-based memory (used by Claude Code, Cursor, Cline) lets the model curate plain markdown files — a small index plus topic files — and relies on text search for retrieval. It’s easy to ship but limited in scalability.
Structured memory (mem0, Letta, Zep) mines every conversation turn into atomic, embedded facts stored in a vector index and temporal graph, retrieved via ranked similarity. It splits into two lineages: place-organized (MemPalace, files by location) and entity-and-time (Zep’s Graphiti, a bi-temporal knowledge graph).
Experience-based memory (MemHarness, the state of the art) banks episodes but trains the model’s retrieval and usage of them directly into its weights via reinforcement learning.

Key findings: The structured store beat files on both accuracy and token cost; files win when memory is small or when the right answer is “I don’t know.” A hybrid associative graph outperformed a plain vector index on long-haystack benchmarks, though no single benchmark ranks memory systems fairly. On agentic benchmarks, retrieved experience only helped weak actors with headroom; where reasoning alone suffices, a frontier model matched the trained system without memory, and where reward required practice, the trained policy stood alone.

Agent memory as a moat: how context compounds

This Redis blog argues that because LLMs are inherently stateless, persistent agent memory — storing facts, experiences, and procedures across sessions — transforms static RAG retrieval into a compounding learning system via a write-manage-read loop. Accurate, well-governed memory grows more valuable with use, creating switching costs and a defensible moat. But governance is essential: scoped namespaces per tenant, retention policies preventing context rot (poisoning, distraction, confusion, clash), and strict access controls against memory injection attacks. Redis supplies fast in-memory infrastructure — vector search, semantic caching, and managed Agent Memory — turning governed accumulated context into a durable competitive advantage.

Introducing Agent Plugins

Agent Plugins 1.0.0 is an open, vendor-neutral standard for packaging AI agent extensions into distributable plugins. It provides a common format using a plugin.json manifest and fixed directory structure for Agent Skills and MCP servers, allowing authors to package components once for use across multiple clients. Version 1 focuses on these two component types, leaving other features like commands and hooks to clients via a namespaced extension mechanism. Initiated by Vercel with AWS, Anysphere, GitHub, Microsoft, and OpenAI, it is supported across ChatGPT, Codex, Cursor, GitHub Copilot, Kiro, and VS Code, and is governed as an open, multi-vendor project.

Software Engineering fundamentals matter more than ever

Despite AI hype, software engineering fundamentals matter more than ever. The author argues that while agentic harnesses and LLMs can now generate working, testable code, they still fall short on the deeper craft: building software that is debuggable, maintainable, layered, and composable. LLMs predict rather than reason, making them vulnerable to prompt injection and poor judgment. The key skill remains carefully choosing abstractions, managing cognitive load, and thoughtfully designing how software components fit together over the long term. The best engineers aren’t those boasting about AI’s power, but those using it as a tool while applying timeless principles of good software craftsmanship.

2x, not 10x: coding with LLMs in 2026

The article argues that LLMs have improved coding productivity by roughly 2x, not 10x, because they excel at producing code that meets verifiable acceptance criteria but still struggle with higher-level questions like code maintainability and documentation quality. The author proposes a “staircase hypothesis”: once LLMs became reliable enough for automated feedback loops, further improvements yield diminishing returns — like being tall enough to climb stairs one step at a time versus two. LLMs are best used for rough drafts, with the author iterating heavily afterward, noting that a working implementation is now only about 20% done rather than 80%. Future gains will likely come from industry retooling around current capabilities rather than model improvements alone.

Podcasts

🐍 RealPython Podcast

🍕 Python Bytes Podcast

📣 Talk Python to me

Repositories

RyanCodrai/turbovec (MIT)

turbovec is a Rust vector index with Python bindings, built on Google Research’s TurboQuant algorithm — a data-oblivious quantizer with near-optimal distortion and no separate training phase.

Have time for some fun?

Gamescom 2026

GTA 6 — Take-Two and Rockstar skipped a traditional live stage demo at Gamescom, instead focusing on an extended gameplay breakdown that highlighted modern-day Vice City, its dynamic romance mechanics, and a criminal profile system.
Tomb Raider: Legacy of Atlantis — A 20-minute gameplay demo shown behind closed doors
The Witcher 3: Wild Hunt — CD Projekt Red surprised attendees with a full current-gen Remaster arriving September 2026, alongside a brand-new expansion titled Songs of the Past planned for 2027.
Gears of War: E-Day — Detailed with Unreal Engine 5 gameplay showcases focusing on its co-op campaign, Horde Siege, and multi-player modes.
Showa American Story — Developer NEKCOM Games debuted an absurd, high-energy Gamescom 2026 trailer for this post-apocalyptic B-movie style RPG. The footage showed off Choko fighting through a “Japanified” 1980s America using makeshift weapons like drill-arms and the American flag, alongside stat-boosting mini-games.

Alright, that concludes the August Edition of “This Month for Pythonistas”. Thank you again for reading my post and I hope you enjoy it or find something useful. Happy coding and see you in September! 👋

This Month for Pythonistas - July 2026

Zeyang Lin — Fri, 31 Jul 2026 13:00:00 GMT

from datetime import date

print(date.today().year, date.today().month)
# 2026 7

Welcome back Pythonistas! This is the July 2026 issue of “This Month for Pythonistas”, bringing you curated Python news, tutorials, articles, podcasts, repositories and community highlights for this month.

Before we continue, please note that this blog is synced across the following platforms:

Ready? Let’s get started!

EuroPython 2026

EuroPython 2026, held in Kraków, Poland from 13–19 July 2026, celebrated the conference’s 25th anniversary and brought together over 1,500 Python developers, researchers, and enthusiasts. The week featured tutorials, technical talks, community sessions, open-source sprints, and networking events. A highlight was its collaboration with EuroSciPy, including joint sprints that connected the wider scientific Python community. Hosted at the ICE Kraków Congress Centre, the event emphasized Python’s growing role in software development, AI, data science, education, and open-source collaboration across Europe and beyond.

Releases now reject new files after 14 days

PyPI now rejects new file uploads to releases older than 14 days, preventing older, long-stable releases from being poisoned if publishing tokens or workflows are compromised. This change, discussed since PEP 740 in January 2024 and accelerated after the LiteLLM and Telnyx supply chain attacks, was implemented on July 8, 2026. Data showed only 56 of 15,000 top projects had published Python 3.14 wheels more than 14 days post-release, indicating minimal disruption. The restriction reduces cleanup work for PyPI admins and prevents releases from ending in an indeterminate compromised state, though defined semantics for closed releases are still pending future standardization via PEP 694 and Upload 2.0.

Planned Updates to the PyPI User Interface

PyPI is rolling out user interface updates over the next few months, introducing a new Security tab for provenance and attestation data, horizontal navigation tabs, a right-placed metadata sidebar, trust-level labeling, and clearer status indicators. Changes are being deployed in four phases on TestPyPI first, allowing community feedback. These visual-only updates require no action from maintainers and automatically map existing attestations to the new UI.

Introducing Claude Sonnet 5

Anthropic announced Claude Sonnet 5, their most agentic Sonnet model yet, capable of planning, using tools like browsers and terminals, and running autonomously at levels previously requiring more expensive models. Its performance approaches Opus 4.8 but at lower prices, with substantial improvements over Sonnet 4.6 in reasoning, tool use, coding, and knowledge work. Safety assessments show fewer undesirable behaviors than its predecessor.

Introducing Claude Opus 5

Claude Opus 5 is now available as a thoughtful and proactive model that approaches the frontier intelligence of Claude Fable 5 at half the cost. It is the new state-of-the-art on coding and knowledge work benchmarks like Frontier-Bench and CursorBench, while remaining behind Mythos 5 on cybersecurity tasks. Opus 5 excels on software engineering, scientific research (especially organic chemistry and protein tasks), and visual outputs, while being the most aligned and safest model to date.

Redeploying Fable 5

After US export controls suspended access to Claude Fable 5 and Mythos 5 on June 12, the restrictions were lifted on June 30. Fable 5 is now available globally starting July 1, while Mythos 5 access resumed for select US organizations. Anthropic strengthened safeguards with improved safety classifiers, proposed a shared industry framework for assessing jailbreak severity, and deepened collaboration with the US government on pre-release testing, information sharing, and joint research.

GPT-5.6: Frontier intelligence that scales with your ambition

OpenAI launched GPT-5.6 series including flagship Solo, balanced Terra and cost-effective Luna across ChatGPT, Codex and its API with global gradual rollout. All models beat competitors like Fable 5 and Claude Opus 4.8 in coding, agent workflows, cyber defense, life science research and office document creation, delivering stronger performance at far lower costs and shorter latency.

It supports Programmatic Tool Calling and Ultra multi-agent parallel processing for complex tasks, boasting advanced UI design judgment and precise template-following document generation. Equipped with OpenAI’s most robust layered safety safeguards, it restricts high-risk cyber/biology features to verified users via Trusted Access without blocking legitimate defensive research. Tiered token pricing applies, alongside optimized prompt caching and beta multi-agent API functions for developers. Internal tests show it greatly accelerates AI research with doubled researcher token usage vs GPT-5.5.

Kimi K3: Open Frontier Intelligence

Kimi K3 is a new 2.8-trillion-parameter open model from Moonshot featuring native vision capabilities and a 1-million-token context window. Built on Kimi Delta Attention and Attention Residuals using Mixture of Experts (16 of 896 experts active), it excels at long-horizon coding, knowledge work, and reasoning. It demonstrated frontier-level performance across benchmarks, notably building a GPU compiler, designing a chip, and creating interactive research reports. The full model weights were then released on July 27, 2026.

Introducing Grok 4.5

Grok 4.5 is SpaceXAI’s smartest model, launched July 8, 2026, built for coding, agentic tasks, and knowledge work. Trained on tens of thousands of NVIDIA GB300 GPUs with curated datasets spanning coding, science, engineering, and math, it excels at engineering benchmarks. Served at 80 tokens per second with twice the token efficiency of leading models, it delivers intelligent results quickly and cost-effectively at $2/M input and $6/M output tokens. It’s available in Grok Build, Cursor, and via the SpaceXAI API console.

New Versions

Python 3.15.0 beta 4 is here!

This release, 3.15.0b4, is the final planned beta release, containing around 298 bugfixes, build improvements and documentation changes since 3.15.0b3. The next pre-release of Python 3.15 will be 3.15.0rc1, scheduled for 2026-08-04.

PyTorch 2.13 Release Blog

PyTorch 2.13 brings major performance and scalability improvements: FlexAttention lands on Apple Silicon with up to 12× speedups and gains deterministic backward on CUDA; CuTeDSL provides a second high-performance code path for Inductor; nn.LinearCrossEntropyLoss fuses linear and loss computation to cut peak GPU memory by up to 4×; a new torchcomms backend improves distributed training fault tolerance and debuggability; FSDP2 enables communication overlap for higher throughput; Python 3.15 wheel support is added; and broader platform gains include ROCm, Armv9-A, and Intel XPU updates.

Introducing Haystack 3.0: Agent Hooks, Skills and a Lighter Core

Haystack 3.0 is a major release of the open-source AI orchestration framework, putting agents at the center. It introduces pre-configured agents (deep research, advanced RAG), hooks for controlling agent behavior, first-class skills with progressive disclosure, built-in introspection and observability, and a leaner core with fewer dependencies.

Tutorials

Deeplearning.ai’s AI Code Reviews

You’ll start with practical techniques for getting more out of AI review, like reviewing before you open a pull request, giving the reviewer task and repository context, and triaging findings by risk. Then you’ll build a context-aware review system of your own, beginning with a context engine that retrieves the most relevant code and extending it into an ensemble of specialized agents.

RealPython’s LangGraph Tutorial: Build Stateful AI Agents in Python

Explore the full tutorial to gain hands-on experience with LangGraph, including setting up workflows and building a LangGraph agent that can autonomously parse emails, send emails, and interact with API services.

RealPython’s CrewAI in Python: Coordinating Teams of AI Agents

CrewAI is a Python framework that lets you build a crew of specialized AI agents, each focusing on one part of the job. For example, instead of cramming research, validation, and writing into a single prompt, you create a team. One agent researches, another validates, and a third writes. Each focuses on what it does best, working together to complete the task.

Articles

PEP 752 – Implicit namespaces for package repositories

PEP 752 is accepted. It introduces implicit namespace reservations for Python package repositories, allowing organizations to reserve name prefixes (e.g., google-cloud-, aws-cdk-) to prevent name-squatting, typosquatting, and dependency confusion attacks. Following the NuGet approach, it works within the existing flat namespace — no new package syntax or installer changes are required, and pre-existing packages are unaffected. Uploads matching a reserved namespace fail with HTTP 409 unless the uploader holds an active grant. The JSON API is upgraded to version 1.5 to expose namespace metadata. The PEP is accepted and has community support from organizations including Apache Airflow, Microsoft, Datadog, pytest, and Project Jupyter.

PEP 814: Add frozendict built-in type

Victor Stinner recounts the long journey to adding frozendict — an immutable, hashable dictionary type — as a built-in to Python 3.15. After his original PEP-416 was rejected in 2012 and PEP-603’s frozenmap stalled, Stinner and Donghee Na wrote PEP 814, which the Steering Council accepted in February 2026. Implemented in C and sharing most code with dict, frozendict preserves insertion order but comparison and hashing are order-independent. The article covers C API additions, stdlib integration (e.g., json, copy, pickle), garbage collector bug fixes, and migration guidance for both Python and C code.

What Every Python Developer Should Know About the CPython ABI

The CPython Application Binary Interface (ABI) underpins Python’s ability to call native C, C++, Rust, or Fortran code and vice versa. This post explains what an ABI is, how it differs from a C API (which is source-level), and details the five layers of the CPython C API—Internal, Private, Unstable, Version-Specific, and Limited. It covers ABI compatibility tags in wheel filenames (cp3XY for version-specific, abi3 for the stable ABI, cp3XYt for free-threaded, and abi3t for the new free-threaded stable ABI in Python 3.15+). The post also explains how the free-threaded build changes the PyObject struct layout, breaking backward compatibility, and how PEP 803 introduces abi3t to let a single wheel target both GIL-enabled and free-threaded interpreters going forward.

When to use classmethod, staticmethod, or instance method in Python

This article explains the differences between instance methods, classmethods, and staticmethods in Python. The key rule: if a method needs the instance (self), it’s an instance method; if it needs the class (cls) but not a specific instance, use @classmethod (e.g., alternative constructors like datetime.date.today(), registries); if it needs neither, use @staticmethod for namespaced helper functions. The author warns that with AI-generated code, methods may look plausible but be structurally wrong, so developers should critically evaluate whether each method truly belongs where it is placed.

Selecting `random` values in Python

The article explains how to generate random values in Python using the random module, which provides pseudorandom numbers via the Mersenne Twister algorithm. It covers randint and randrange for integers, random() for floats between 0 and 1, and choice/choices for picking items from sequences — the author’s most-used function. The deterministic nature allows reproducible results via seed(), useful for testing but risky for security. For cryptographically-secure randomness, Python’s secrets module offers choice, randbelow, and randbits, while the SystemRandom class provides a full secure counterpart to random’s API.

Stacks and queues in Python

Python lists are ideal for stacks (last-in, first-out) using append() and pop(), as they are optimized for adding/removing items at the end. For queues (first-in, first-out), use a deque (double-ended queue) from the collections module, which supports efficient append()/popleft() operations. While deque can also work as a stack, lists are recommended for stack-like needs and deque for queue-like needs in Python.

protobuf-py: Protobuf for Python, without compromises

Buf announced protobuf-py, a new Protocol Buffers library for Python written from scratch. It passes the full Protobuf conformance suite (proto2, proto3, editions), supports extensions, custom options, dynamic messages, and well-known types. Unlike Google’s C-based package, it stores messages as plain Python objects with readable generated code and no runtime dependencies. An optional Rust accelerator boosts parsing/serialization for production workloads. It offers complete spec coverage with an idiomatic Python API, addressing the gap between Google’s complete but clunky package and the nicer but incomplete betterproto.

Pip 26.2: –only-deps solves 16 years of app deployment hacks

pip 26.2 introduces the --only-deps flag, solving a 16-year problem of installing dependencies for application-style Python projects without installing the package itself. The author traces the history of workarounds — from pip freeze, manually cutting version pins, pip install -e ., to third-party tools like pip-chill, pipreqs, poetry, hatch, and uv — showing how community demand finally led to this native solution. Sebastian Höffner’s PR #13895 adds a global flag allowing pip install --only-deps . to install only project dependencies from pyproject.toml, eliminating years of fragile manual deployment hacks.

How to publish to PyPI using GitHub Actions securely

This article by Brett Cannon outlines three steps to securely publish Python packages to PyPI via GitHub Actions: (1) Use the zizmor tool to scan workflows for insecure defaults — set no permissions by default, disable persisted credentials after checkout, and pin actions to commit hashes rather than tags; (2) adopt Trusted Publishing to eliminate API token management and gain attestations; and (3) require manual approval through GitHub Environments to prevent accidental or malicious releases. These measures mitigate recent GitHub Actions security incidents.

uv in production: the speed is real, the integration isn’t free

The article discusses the author’s ~90-day production experience with uv, Astral’s Python package manager. While uv delivers a genuine ~10x speed improvement over pip in CI, the article highlights five key caveats: (1) it refuses to install without an active venv, (2) auto-installing Python is blocked by corporate firewalls (fixable via a mirror), (3) parallel installs get serialized due to locking, (4) it defaults to first-index mode (defense against dependency confusion), and (5) bytecode compilation is off by default, slowing cold starts. The author concludes uv is worth adopting but warns that its deliberate strictness — unlike pip’s leniency — requires budgeting time for integration.

Sandboxing an AI Agent

This post explores sandboxing AI agents by giving them isolated, disposable environments instead of running code directly on a host machine. He compares two architectures: a tool-backend model where the agent loop stays local and the sandbox executes commands remotely, versus the agent-in-the-box model where the entire agent lives inside the sandbox. He examines different isolation strengths—shared-kernel containers, gVisor’s software kernel, and Firecracker microVMs — and concludes sandboxes are becoming a default layer of the agent stack for containment, parallelism, reproducibility, and cheap recovery.

State of CLI Coding Agents, Mid-2026

The article surveys 35 CLI coding agents as of mid-2026, noting the terminal unexpectedly won over IDEs for serious AI coding work. Claude Code’s February 2025 research preview set the template — agentic loop, file/shell tools, memory, hooks, subagents — that everyone else cloned. The landscape spans lab agents (Claude Code, Codex CLI, Antigravity CLI, Grok Build), platform CLIs (Copilot CLI, Cursor CLI, Amp, Junie), and open-source harnesses (OpenCode, Goose, Aider, Cline, Pi/Omp). Open-weight models like GLM-5.2 and DeepSeek V4 narrowed the frontier gap dramatically, while free tiers retreated industry-wide.

What our AI guiding principles actually mean

Wagtail has refreshed its AI guiding principles, emphasizing that AI will remain optional in core with features living in separate packages. The five principles include: no AI dependency in core, a responsible approach focused on ethics and sustainability, model and provider agnosticism favoring open-weight smaller models, only adopting AI where it delivers real value, and maintaining human-in-the-loop control to preserve user autonomy. The article stresses that while the principles are set, the real challenge lies in their practical implementation as AI adoption continues to evolve.

How much can you delegate to agents?

This article presents a framework for deciding agent autonomy levels based on two factors: how easy the task is to check and how cheap it is to undo. It defines four levels—Level 0 (agent as assistant for hard-to-check, costly-to-undo tasks), Level 1 (human-in-the-loop for hard-to-check, easy-to-undo tasks), Level 2 (agent delegation for easy-to-check, costly-to-undo tasks), and Level 3 (self-driving mode for easy-to-check, easy-to-undo tasks) — with real examples from PostHog’s engineering work and practical advice on progressively increasing delegation safely.

The Short Leash AI Coding Method For Beating Fable

The Short Leash AI Coding Method advocates for expert developers to use AI agents cautiously in security-critical software. Unlike “vibe coding” where AI works autonomously, this method keeps the developer actively engaged — reviewing every proposed diff, denying undesired changes, and committing after each subtask. For reviews, both AI and human input are essential: AI catches common mistakes like a linter, while humans handle high-level issues. The key principle is never letting the AI work unsupervised to maintain quality and codebase understanding.

Skill engineering and the case against one-shot AI design

Paul Bakaus, creator of the open-source design skills system Impeccable, argues for “skill engineering” as a new discipline that gives AI agents a precise design vocabulary (e.g., “bolder,” “quieter”) instead of relying on one-shot AI design. He believes agents need domain knowledge and human steering, not full automation. His philosophy: AI quickly produces the first 80% of competent work, while humans own the final 20% where taste and context matter, rejecting the notion of “auto mode” entirely.

Podcasts

🥝 core.py

Episode 30: Live from EuroPython, an Interview with Guido van Rossum

🐍 RealPython Podcast

🍕 Python Bytes Podcast

📣 Talk Python to me

🚀 VS Code Insiders Podcast

Episode 23: VS Code’s Agent Host Protocol Explained with Connor Peet

Repositories

mozilla-ai/otari

Open-source, OpenAI-compatible LLM gateway you run yourself. One endpoint for 40+ providers, with virtual keys, budgets, and usage tracking.

Alright, that concludes the July Edition of “This Month for Pythonistas”. Thank you again for reading my post and I hope you enjoy it or find something useful. Happy coding and see you in August! 👋

This Month for Pythonistas - June 2026

Zeyang Lin — Tue, 30 Jun 2026 13:00:00 GMT

from datetime import date

print(date.today().year, date.today().month)
# 2026 6

Welcome back Pythonistas! This is the June 2026 issue of “This Month for Pythonistas”, bringing you curated Python news, tutorials, articles, podcasts, repositories and community highlights worth noting in this month.

Before we continue, please note that this blog is synced across the following platforms:

Ready? Let’s get started!

An announcement from the Steering Council regarding the JIT project

The Python Steering Council announced that the experimental JIT compiler in CPython must undergo formal review through a Standards Track PEP within six months. While acknowledging the developers’ valuable work and real performance gains, the Council noted the JIT lacks proper formal approval — PEP 744 was only informational. Until an accepted PEP addresses maintenance plans, compatibility guarantees, success metrics, and architectural stability, no new JIT features can be added to main (only bug/security fixes permitted). If no PEP is accepted within six months, the JIT code must be removed from CPython’s main repository.

EuroPython 2026 schedule is revealed 📣

The full schedule for EuroPython 2026, hosted in Kraków, Poland, has been released. Check it out on the official website.

Everything Security at PyCon US 2026

PyCon US 2026 featured its first-ever dedicated security track, “Trailblazing Python Security”, with seven talks covering phishing, zero trust, supply chain attacks, SBOMs, and more. The Python Software Foundation (PSF) delivered a security update highlighting a surge in malware and watering-hole attacks targeting PyPI. An Open Space session brought together open-source maintainers to discuss CI/CD hardening, the overwhelming flood of LLM-generated vulnerability reports consuming most of their time, and the need for contributor quality signals. Additionally, Alpha-Omega–sponsored security roles presented updates on Python Security Response Team governance reforms and efforts to combat supply-chain attacks on the Python ecosystem.

Building a hill-climbing machine: Launching seven new MAI models

Microsoft AI (MAI) announced seven new in-house models during Microsoft Build 2026, spanning reasoning (MAI-Thinking-1), coding (MAI-Code-1-Flash), image generation (MAI-Image-2.5), transcription (MAI-Transcribe-1.5), and speech (MAI-Voice-2). All are trained from scratch on clean data without distillation from third parties. MAI also introduced Microsoft Frontier Tuning, enabling organizations to adapt models to their own workflows using reinforcement learning. A partnership with Mayo Clinic was announced to co-develop a frontier healthcare AI model. MAI’s ultimate vision is “Humanist Superintelligence” — advanced AI designed to serve people, remain under human oversight, and never replace them.

Claude Fable 5 and Claude Mythos 5

Anthropic has launched Claude Fable 5, a Mythos-class AI model that is the most capable model they’ve ever made generally available, achieving state-of-the-art performance across software engineering, knowledge work, vision, and scientific research benchmarks. Due to its powerful capabilities, Fable 5 includes new safeguards that redirect sensitive queries on cybersecurity, biology, and chemistry to Claude Opus 4.8 instead. The company also released Claude Mythos 5, the same model with lifted safeguards for cyber defenders, deployed through Project Glasswing in collaboration with the US government.

Statement on the US government directive to suspend access to Fable 5 and Mythos 5

Shortly after Anthropic released Claude Fable 5 and Claude Mythos 5, the US government issued an export control directive citing national security concerns on June 12th, ordering Anthropic to suspend all access to its Fable 5 and Mythos 5 models for all users, including foreign nationals. Anthropic is complying but disagrees with the decision, stating the government’s evidence involves a narrow jailbreak revealing minor vulnerabilities already discoverable by other models. Anthropic argues its safeguards are robust and that applying this standard industry-wide would halt all frontier model deployments. The company believes this is a misunderstanding and is working to restore access as soon as possible.

MiniMax M3: Frontier Coding, 1M Context, Native Multimodality — All in One Model

MiniMax M3 is MiniMax’s latest frontier model combining three key capabilities: frontier-level coding/agentic performance, 1M-token context via MSA (MiniMax Sparse Attention), and native multimodality (image/video input and desktop operation). It surpasses GPT-5.5 and Gemini 3.1 Pro on SWE-Bench Pro, tops SVG-Bench and Claw-Eval, and excels at real-world tasks like independently reproducing research papers, optimizing CUDA kernels (achieving 9.4× speedup), and autonomously training models. Accompanying the release are MiniMax Code (an agent product), affordable Token Plans, and a tiered API. Model weights and a technical report have also been released.

Qwen3.7-Plus: Multimodal Agent Intelligence

Qwen3.7-Plus is Alibaba’s latest multimodal agent model that unifies vision and language into a versatile agent foundation. It operates as a “multimodal interactive hybrid agent,” capable of perceiving real-world scenes, operating GUIs and CLIs, writing code from visual references, and completing end-to-end tasks. It excels in coding agent benchmarks (Terminal Bench 2.0, SWE-Verified), general-purpose agent tasks, STEM reasoning, and multimodal benchmarks including visual reasoning, search-augmented QA, video understanding, and autonomous driving perception.

GLM-5.2: Built for Long-Horizon Tasks

GLM-5.2 is Z.ai’s latest flagship model designed for long-horizon tasks, featuring a solid 1M-token context window. It introduces IndexShare architecture, reducing per-token computation by 2.9×, and offers flexible effort levels to balance performance and latency. The model excels in coding benchmarks, ranking as the highest-performing open-source model across long-horizon evaluations like FrontierSWE and SWE-Marathon. GLM-5.2 uses advanced RL training with anti-hacking mechanisms and is released under an MIT license.

New Versions

Python 3.15.0 beta 3 is here!

This is the third of four planned beta releases of Python 3.15. Beta 4 is scheduled for 2026-07-18.

Beta 2 was also released earlier this month.

Python 3.14.6 and 3.13.14 are now available!

Python 3.14.6 is the sixth maintenance release of 3.14, containing around 179 bugfixes, build improvements and documentation changes since 3.14.5. Python 3.13.14 is the fourteenth maintenance release of 3.13, containing around 240 bugfixes, build improvements and documentation changes since 3.13.13.

Pyodide 314.0 Release

Pyodide 314.0 has been released, marking a major milestone for Python in the browser. The headline change is the acceptance of PEP 783, enabling package maintainers to publish Pyodide wheels directly to PyPI instead of relying on the Pyodide team to build and host 300+ packages. The project adopted a new Python-version-based versioning scheme (314 = Python 3.14). This release ships Python 3.14.2 and Emscripten 5.0.3, restores several standard library modules, converts Pyodide to a native ES module, adds experimental Node.js socket support, and introduces JavaScript interop improvements including proper bigint roundtripping and enhanced array-like proxy support.

Tutorials

DeepLearning.ai’s Fast & Efficient LLM Inference with vLLM from Red Hat

You’ll run the full optimize-deploy-benchmark workflow on a real model: compressing an open-source Qwen model with LLM Compressor, serving it with vLLM, and benchmarking your deployment under realistic traffic using GuideLLM and lm-eval.

DeepLearning.ai’s Voice for AI Agents and Applications from Vocal Bridge

Taught by Ashwyn Sharma, CEO and Co-Founder of Vocal Bridge (an AI Fund portfolio company), this course covers three practical integration patterns that meet you where you are: voice embedded in an application, voice layered onto an existing agent without touching its logic, and voice as a tool your LLM can call when it decides a conversation is the right modality.

Microsoft’s Rust for Python Programmers

A comprehensive guide to learning Rust for developers with Python experience. This guide covers everything from basic syntax to advanced patterns, focusing on the conceptual shifts required when moving from a dynamically-typed, garbage-collected language to a statically-typed systems language with compile-time memory safety.

If you feel comfortable after learning this book and wish to move on, there’s another book from Microsoft covering async Rust: Async Rust: From Futures to Production.

Articles

Free Threading internals: reference counting

This article by Victor Stinner explores Python’s free-threading reference counting challenges. Python uses reference counting (Py_INCREF/Py_DECREF) to track object lifetimes, requiring high efficiency. The “Gilectomy” project (2016-2018) initially used atomic operations but suffered severe performance issues — 18.9x slower on 7 cores due to lock contention. It later adopted buffered reference counting. The “nogil” project (2021-2026) solved this with Biased Reference Counting (BRC), which recognizes that most objects are accessed by a single thread. BRC uses fast non-atomic operations for the owning thread and slower atomic operations for other threads, achieving better performance at the cost of increased implementation complexity.

Free Threading internals: deferred reference counting

This article continues to explore CPython’s Free Threading internals, focusing on techniques to reduce reference counting contention. Immortal objects (PEP 683) skip Py_INCREF/Py_DECREF entirely, eliminating contention for commonly used singletons like small integers, strings, and built-in types. Deferred reference counting avoids reference count adjustments altogether, relying on the tracing garbage collector for deallocation. Stack references — tagged pointer-sized values introduced in Python 3.13 — allow the bytecode evaluation loop to skip most INCREF/DECREF calls. Together with Biased Reference Counting, these techniques resolve reference count contention, enabling Python threads to scale efficiently across CPU cores.

Free Threading internals: PyMutex

This is the third part in the series regarding Free Threading, in which Victor Stinner discusses PyMutex, a lightweight 1-byte lock introduced in Python’s free-threading implementation (PEP 703), which replaces the Global Interpreter Lock with per-object locks. Designed for efficiency, PyMutex uses only 2 bits and is based on WebKit’s WTF::Lock. It provides fast, inlineable lock/unlock operations using atomic compare-exchange for uncontended cases. Benchmarks show PyMutex is 1.4x to 4x faster than the previous PyThread_type_lock. The implementation uses _PyParkingLot APIs (futex-like) and supports various locking flags. In practice, the critical section API is preferred over direct PyMutex usage to avoid deadlocks.

Python 3.14 garbage collection rigamarole

Python 3.14.0 replaced its traditional generational garbage collector with an incremental GC that reduced maximum pause times by scanning only part of the old generation per collection cycle. However, by doing less work each run, the incremental GC caused memory to accumulate in certain workloads — especially those generating cyclic garbage — leading to significantly higher peak memory usage and potential OOM kills. After users reported “memory pressure”, the Python team reverted the change in Python 3.14.5. Notably, the GC change was not implemented as a switchable alternative and bypassed the standard PEP process, leaving users who benefited from it with no option to use it.

Two Python Scoping Bugs: A Lesson in Object Lifetimes

This blog post illustrates two Python scoping bugs caused by mismatched object lifetimes. The first is over-sharing: a module-level SQLAlchemy engine shared across tests causes state leaks (e.g., auto-increment IDs carry over). The fix is creating a per-test engine using an in-memory SQLite database. The second is under-sharing: a FastAPI dependency that instantiates a new FakeDataSource per request gives each browser tab its own diverging simulator state instead of a shared reality. Fixes include @lru_cache or app.state for shared runtime state.

Down The Iterator Rabbit Hole

This article explores Python iterator chains and how consuming values from one iterator affects others in the chain. Iterators don’t store data — they create lightweight streams that fetch from the original source on demand. When you chain iterators (e.g., a list → first_iter → second_iter → third_iter), calling next() on any iterator in the chain consumes values that propagate through all dependent iterators. The author demonstrates how this can cause unexpected behavior, since iterators are one-way streams. The key takeaway: when building iterator chains, only use the final iterator to avoid confusion. Independent iterators from the same source, however, remain unaffected by each other.

Choosing a Python task queue library in 2026

This article compares five Python task queue libraries in 2026: Celery, Dramatiq, FastStream, Taskiq, and Repid. It evaluates them across broker support, async vs. sync capabilities, throughput benchmarks for both I/O-bound and CPU-bound workloads, and features like dependency injection, result backends, AsyncAPI integration, and retry handling. The author (Repid’s creator) finds that async-native libraries like Repid, FastStream, and Taskiq outperform sync-first Celery and Dramatiq in I/O-heavy scenarios, while differences shrink for CPU-bound tasks. Recommendations: Celery for the largest ecosystem, FastStream for stream-processing patterns, and Repid for high-throughput asyncio-native workloads.

How and why to run modified Python code using the ast module

This Pydantic blog demonstrates how to use Python’s ast module to parse, transform, and execute modified Python code at runtime. Using the eval-type-backport library as an example, it shows how to convert newer type syntax like X | Y into typing.Union[X, Y] for older Python versions by manipulating abstract syntax trees with ast.NodeTransformer. The author shares how mastering AST metaprogramming helped him land jobs at Grist and Pydantic, and argues this skill is increasingly valuable in the AI era since it’s harder to automate and essential for inspecting and controlling code produced by AI agents.

Why I wrote PEP 832 – virtual environment discovery

Brett Cannon proposes PEP 832 which addresses the challenge of virtual environment discovery for tools like VS Code. The problem: editors struggle to know which workflow tool (Poetry, uv, Hatch, etc.) a project uses and where environments are stored, making it difficult to run code and analyze dependencies. Proposed solutions include using .venv directories for local discovery, a .python-envs file listing environment paths, and a [workflow] table in pyproject.toml with a workflow server protocol (WSP) for tool communication. The goal is creating a tool-agnostic standard that simplifies environment setup across all editors, not just VS Code.

Vulnerability and malware checks in uv

Astral announces two new security features for uv: uv audit, a native command that scans dependencies for known vulnerabilities and deprecated packages — serving as a 4x–10x faster alternative to pip-audit — and a lightweight malware check integrated into sync operations (uv add, uv sync, etc.) that queries OSV for known malicious packages, blocking installation before harmful code executes. Both features are currently in preview. The post explains the growing importance of supply chain security, distinguishes malware remediation from ordinary vulnerability patching, and outlines future plans including tighter tooling integration, improved finding precision, and support for additional vulnerability backends and packaging formats.

Give your agent its own computer

LangChain’s LangSmith Sandboxes solve a critical problem: AI agents need real computers to execute code, but giving them access to your infrastructure is dangerous. Containers aren’t secure enough for untrusted, model-generated code. LangSmith Sandboxes provide hardware-virtualized microVMs—each agent gets its own isolated computer with filesystem, shell, package manager, and persistent state. Features include instant startup, snapshots for forking sessions, pre-warmed blueprints, and secure credential injection. This enables production-ready coding assistants, CI agents, data pipelines, and RL training environments that can scale from zero to thousands of instances.

A Practical Guide to Becoming an AI-Native Engineer

This ByteByteGo article presents a practical guide for engineers transitioning to AI-native engineering. Rather than replacing engineers, AI shifts their role from code writers to orchestrators who command AI agents for 100x output. The guide outlines four core practices: context engineering (curating project-specific AI inputs), specification-driven development, critical verification (since ~45% of AI code contains security flaws), and problem decomposition. It recommends spending 40% of time on context-setting, 20% on generation, and 40% on verification. The article also details a three-phase individual transformation journey, team cultural foundations, an Agentic Development Life Cycle, and essential security guardrails against emerging AI-code threats.

Beyond code generation: rethinking engineering productivity in the age of AI agents

Dropbox’s blog post argues that AI coding tools, while boosting code generation, merely shift bottlenecks downstream — into code review, CI, validation, release coordination, and production operations. Their internal agent platform, Nova, now generates ~1 in 12 pull requests, handling tasks like migrations and bug investigation within guardrails. The key insight: AI doesn’t eliminate bottlenecks but relocates them. Dropbox rethinks productivity measurement through a four-stage model — Fuel, Adoption, Output, and Impact — emphasizing customer value over raw PR throughput. Engineers’ roles evolve toward defining intent and reviewing outputs. Ultimately, success depends not on having the best models but on building the best systems around them.

Don’t rely on instructions, use Agent Hooks to enforce guardrails

This blog post demonstrates “Agent Hooks” as deterministic guardrails for AI coding agents like Claude Code, arguing that text-based instructions (e.g., in CLAUDE.md) are unreliable since agents often ignore them. Unlike git hooks that run after code is written, agent hooks intercept the agent’s workflow in real time. The author demonstrates two practical hooks: a PreToolUse hook that blocks raw <input> tags, forcing use of custom design components, and a Stop hook that prevents the agent from declaring completion until a design-system ratchet test passes. Both provide guaranteed, deterministic enforcement that prompt-based instructions cannot.

How to Keep Your Developer Instincts When AI Writes the Code

The author argues that while AI tools promise to eliminate friction in software development, this friction is essential for building engineering intuition and judgment. He categorizes friction into three types: worth deleting (boilerplate), worth keeping (debugging, design decisions), and worth seeking out (deliberate practice). To avoid losing critical thinking skills, developers should adopt deliberate practices like forming expectations before prompting, carefully reviewing AI diffs, and coding without agents weekly. This routine is especially crucial for junior developers to build foundational skills and maintain the craft of engineering in an AI-driven era.

The Speed of Prototyping in the Age of AI

The author reflects on how AI coding agents have transformed his prototyping workflow. Previously, his bottleneck was the time needed to scaffold projects; now, AI removes that friction, enabling him to ship far more functional prototypes—citing projects like the Sakoa programming language, the Kato notation format, and others. He estimates roughly 4x faster output, but the bigger shift is qualitative: he now thinks at a higher abstraction level, focusing on system boundaries and specifications rather than line-by-line implementation. This skill — clearly delegating work — transfers to managing people too. However, he deliberately carves out time for manual coding to stay sharp, and remains cautious about AI’s broader environmental, financial, and social implications.

Domain Expertise Has Always Been the Real Moat

The article argues that domain expertise, not coding ability, has always been the true competitive moat in software development. Agentic AI has severed the link between understanding a domain and producing code, making code generation cheap while domain knowledge remains scarce. A domain expert with no coding background can now be remarkably effective with AI tools because they can verify whether outputs are correct. Conversely, a skilled generalist engineer lacking domain knowledge cannot distinguish plausible-but-wrong answers from right ones. The author advises experienced engineers to invest in deeply learning a real domain — whether regulatory, industrial, or scientific — as that verified domain model is the one thing AI cannot supply and is now the most valuable asset.

Software Is Not A Single-Player Game

This blog post argues that software development is inherently a multiplayer game, not a solo endeavor. The author contends that code review — not design docs — is where the most consequential engineering judgments are made. As AI makes producing code dramatically cheaper, the primary artifact of collaboration is shifting from abstract documents to real, working changes. Teams can now reason about actual implementations rather than proxies, making review more central, not less. While some decisions still require upfront planning, that boundary is shrinking. The author traces this collaborative pattern back to Linux’s early patch-review culture and concludes that building lasting software has always depended on groups exercising shared judgment together over concrete code changes.

AI’s brave new world of technical debt

This article argues that AI agents are creating a dangerous new form of technical debt in software development. Agents automate tasks by adding layers of delegation — MCP servers, prompts, and auto-managed dependencies — but each layer becomes a dependency and a security risk. Studies show AI agents select vulnerable package versions more often than humans and even hallucinate non-existent dependencies. While tools like Anthropic’s Claude Mythos can cheaply discover zero-day exploits in old code, the article urges teams to adopt disciplined practices: minimize their attack surface, version-control prompts, and treat all AI integrations as production dependencies requiring rigorous review and governance.

Vibe Coder vs Software Engineer

This article distinguishes between “vibe coders” and “software engineers” in the age of AI-assisted development. A vibe coder focuses on rapid prototyping and measuring time to a working demo, while a software engineer prioritizes “time to safe merge” — encompassing code review, testing, ownership, rollback, and long-term maintainability. The author argues that AI-generated code must meet the same standards as hand-written code, and that engineers must fully own and understand what they submit, since AI cannot take accountability. Vibe coding suits discovery and ideation, but production delivery demands engineering discipline, bounded tasks, and human judgment built through apprenticeship and system knowledge.

Podcasts

🐍 RealPython Podcast

🍕 Python Bytes Podcast

📣 Talk Python to me

Repositories

LvcidPsyche/auto-browser (MIT)

Auto Browser is an MCP-native browser control plane for authorized workflows. It gives MCP clients, LLM agents, and operators a shared Playwright browser with human takeover, reusable auth profiles, approvals, audit trails, and local-first deployment.

NVIDIA/SkillSpector (Apache-2.0)

Security scanner for AI agent skills. Detect vulnerabilities, malicious patterns, and security risks before installing agent skills.

microsoft/coreutils (MIT)

A Microsoft-maintained build of uutils/coreutils, findutils, and grep packaged as a single multi-call binary for Windows. The goal is to make moving between Linux, macOS, WSL, containers, and Windows frictionless.

Have time for some fun?

Sony’s State of Play (2026-6-2)

God of War: Laufey, the title from Santa Monica focusing on Kratos’ wife, is coming to PS5 with release date unknown.
Phantom Blade Zero, the fast-paced action RPG from S-Game, is delayed to October 29th, 2026 with full trailer and pre-order available soon in summer.
Control Resonant, the sequel to Control (2019), is coming September 24th, 2026.
Tomb Raider: Legacy of Atlantis, another “remake” of the first Tomb Raider game, is coming February 12th, 2027.
Onimusha: Way of the Sword from Capcom launches this September, with a playable demo available right now.
Ace Combat 8: Wings of Theve from Bandai Namco is coming this October.
Until Dawn 2 is announced, “featuring a brand new cast, a whole new world to explore, and gut-wrenching decisions”.

Summer Game Fest

Resident Evil Veronica, the remake of Resident Evil: Code: Veronica (2000) from Capcom, follows Claire Redfield searching for her brother Chris and is coming in 2027 to PS5, Xbox Series X|S, Nintendo Switch 2, and PC.
Final Fantasy VII Revelation, the third and final chapter in the FF7 Remake trilogy from Square Enix, adds Vincent and Cid as playable party members with a new Job Class system, and launches Spring 2027 on PS5, Xbox Series X|S, PC, and Nintendo Switch 2 with day-one multiplatform release.
Stellar Blade: Blood Rain, the sequel to Stellar Blade from Shift Up, introduces new protagonist Evie and continues the story beyond the first game, with Shift Up self-publishing this time and no platforms or release date confirmed yet.
Guild Wars 3 from ArenaNet, the first new entry in the franchise since 2012, is set over a thousand years before the original Guild Wars in the land of Orr, featuring momentum-based movement and coming to PC and PS5 (the series’ first console release) with beta in Fall 2027.
Trine 6: Together in Time from Frozenbyte, featuring two new playable characters Moira and Adrius alongside the classic trio, supports 1–4 player co-op and launches September 17, 2026 on PC, Nintendo Switch, Nintendo Switch 2, PS5, and Xbox Series X|S.
Alien: Isolation 2 from Creative Assembly and SEGA, set on a remote storm-ravaged colony world at Kurosaki Station with both interior and exterior environments, is coming in 2027 to PS5, Xbox Series X|S, Nintendo Switch 2, and PC.
Blood Message from 24 Entertainment and NetEase, the publisher’s first AAA single-player title, is a cinematic action-adventure set in 848 AD Tang Dynasty China where a nameless messenger and his son embark on a perilous 1,000-mile odyssey to Chang’an, coming to PC and consoles with no release date yet.
Hitman Classic Trilogy Remastered from Saber Interactive and IO Interactive, collecting Hitman: Codename 47, Hitman 2: Silent Assassin, and Hitman: Contracts with upgraded visuals and a graphics toggle, is coming to PC, PS5, and Xbox Series X|S in 2027.

Alright, that concludes the June Edition of “This Month for Pythonistas”. Thank you again for reading my post and I hope you enjoy it or find something useful. Happy coding and see you in July! 👋

[one-liner] Install OpenCode

Zeyang Lin — Mon, 29 Jun 2026 09:06:00 GMT

One-Liner series: OpenCode

source: OpenCode documentation

Install on Linux, macOS

curl -fsSL https://opencode.ai/install | bash

Install on Windows

Install with npm

npm install -g opencode-ai

Install with chocolatey

choco install opencode

Verify installation

opencode --version

Update

opencode upgrade

This Month for Pythonistas - May 2026

Zeyang Lin — Sun, 31 May 2026 13:00:00 GMT

from datetime import date

print(date.today().year, date.today().month)
# 2026 5

Welcome back Pythonistas! This is the May 2026 issue of “This Month for Pythonistas”, bringing you curated Python news, tutorials, articles, podcasts and community highlights.

Before we continue, please note that this blog is synced across the following platforms:

Ready? Let’s get started!

PyCon US 2026

PyCon US was held in Long Beach, California this May with 2000+ total attendees, 57% of which were first-time. It was a great success - thanks to PSF and the whole community - and I look forward to PyCon US 2027 already (still in Long Beach)! You can check out social media (X, Mastodon, BlueSky, etc.) for highlights.

The recordings of the conference would be published to PyCon US Youtube channel later this year.

Introducing Claude Opus 4.8

Anthropic introduced Claude Opus 4.8, an upgrade over Opus 4.7 with improved benchmark performance across coding, agentic skills, reasoning, and knowledge work, at the same price. Key improvements include greater honesty — Opus 4.8 is roughly four times less likely to let code flaws pass unremarked — and lower misaligned behavior rates. Launching alongside it are: dynamic workflows in Claude Code (enabling massive parallel subagent tasks like codebase-scale migrations), effort control on claude.ai (letting users adjust how deeply Claude thinks), and system entries inside the messages array via the API. Opus 4.8 defaults to high effort, with “extra” and “max” options for harder tasks. Anthropic also teased upcoming cheaper Opus-class models and a more intelligent “Mythos”-class model pending stronger safety safeguards.

New Versions

Python 3.15.0 beta 1 is here!

Python 3.15.0 beta 1 was released on May 7, 2026, marking the first beta and feature freeze. Developers encourage third-party projects to test the preview and report bugs, though it is not recommended for production. Major features include explicit lazy imports, new built-in types like frozendict and sentinel, a dedicated profiling package, default UTF-8 encoding, TypedDict improvements, and an upgraded JIT compiler delivering 8–13% performance gains. Other changes include frame pointers by default, unpacking in comprehensions, and stable ABI for free-threaded builds.

The tarball and binary distributions for beta 1 can be downloaded here. The next pre-release, 3.15.0b2, is scheduled for June 2, 2026.

Python 3.14.5 is out!

This is a very rare patch release due to a release candidate being released several days before the final release.

The incremental garbage collector shipped in Python 3.14.0 - 3.14.4 has been reverted back to the generational garbage collector from 3.13, due to a number of reports of significant memory pressure in production environments.

What’s new in pip 26.1 - lockfiles and dependency cooldowns!

pip 26.1, released April 2026, drops Python 3.9 support and introduces key features: experimental lockfile support via -r pylock.toml (PEP 751), dependency cooldowns with --uploaded-prior-to=P3D, and fixes to the 2020 resolver. Security updates patch archive handling vulnerabilities and upgrade urllib3 to 2.x. The legacy resolver moves closer to removal (planned 2027), and PIP_CONSTRAINT for build dependencies is deprecated for pip 26.2. A future pip sync command is planned to complete lockfile support.

Pyrefly v1.0 is here!

Pyrefly, Meta’s open-source Python type checker and language server, has reached its stable v1.0 release, marking it as production-ready after over 60 minor releases since its alpha launch in mid-2025. Already used at scale by Instagram, PyTorch, NumPy, Pandas, and JAX, Pyrefly delivers significant performance improvements — up to 125x faster incremental editor updates and 34% faster full type checks on large codebases. It offers both CLI and IDE extension support for consistent results across environments, with built-in support for Pydantic and Django, and an upcoming integration with Microsoft’s Pylance via a new Type Server Protocol. The tool supports gradual adoption through configurable presets, migration from Mypy/Pyright, and incremental type annotation via pyrefly infer. Looking ahead, Pyrefly is developing experimental tensor shape checking for ML frameworks and exploring integration into AI-assisted coding workflows.

PyTorch 2.12 Release Blog

PyTorch 2.12 has been released with 2,926 commits from 457 contributors. Key highlights include: batched linalg.eigh on CUDA is up to 100x faster; a new device-agnostic torch.accelerator.Graph API unifies graph capture across CUDA, XPU, and other backends; torch.export.save now supports Microscaling (MX) quantization formats for deploying compressed models; fused Adagrad optimizer joins Adam, AdamW, and SGD; and torch.cond control flow can now be captured within CUDA Graphs. ROCm users gain expandable memory segments, rocSHMEM symmetric memory collectives, and FlexAttention pipelining. TorchScript is now deprecated, with torch.export as its replacement.

Tutorials

DeepLearning.ai’s Build Interactive Agents with Generative UI from CopilotKit

You’ll work across the full Generative UI Spectrum, from hand-crafted components you control precisely, to declarative layouts the agent assembles from building blocks, all the way to open-ended experiences powered by MCP Apps. You’ll finish by building a canvas application where the agent works alongside the user on shared data. By the end, you’ll have a production-ready fullstack agent built on CopilotKit and AG-UI, an open protocol with first-party integrations across LangGraph, Google, AWS, Microsoft, and more.

DeepLearning.ai’s AI Agents for Image and Video Generation from Google

In this course, you’ll learn three complementary evaluation techniques, then combine them with image and video generation to build autonomous media agents. You’ll build an image agent that turns brand guidelines into UI mockups, and a video agent that plans multi-scene explainers, animates reference frames with synchronized audio, and checks consistency across scenes. In the final lesson, you’ll use Gemini CLI to build a generative media agent in natural language, packaging what you’ve learned into reusable agent skills.

Articles

PEP 661 – Sentinel Values

PEP 661 is accepted. It introduces a new built-in sentinel() class for creating unique sentinel values in Python. Sentinel values are special placeholder objects used when a distinct sentinel is needed that’s different from None. The new builtin addresses issues with common sentinel idioms like object() which have uninformative reprs, lack distinct types, and behave unexpectedly after copying or pickling. The sentinel(name) call creates a sentinel with a readable repr, proper identity preservation, pickling support, and type-checking integration. Sentinels are truthy and should be checked with is operator. The feature targets Python 3.15+ with both Python and C API implementations, providing a standardized way to define sentinels throughout the standard library and user code.

Python 3.15: features that didn’t make the headlines

This blog post covers lesser-known Python 3.15 features including: (1) asyncio TaskGroup cancellation — a new tg.cancel() method that simplifies graceful task group termination, replacing the awkward workaround of raising custom exceptions; (2) Context Manager Improvements — ContextDecorator now properly wraps the full lifecycle of async functions, generators, and async iterators, making context managers an ideal way to create decorators; and (3) Thread Safe Iterators — new threading.serialize_iterator and threading.synchronized_iterator functions that enable safe shared iteration across threads, solving issues with skipped values or broken iterator state when using threading or free-threading.

PyCon US 2026 Typing Summit Recap

The PyCon US 2026 Typing Summit featured eight talks and a Typing Council Q&A. Key highlights: Guido van Rossum argued PEP 484’s no-new-syntax rule is already broken and urged prioritizing user pain over power features, citing the 2025 Typing Survey. Jelle Zijlstra proposed intersection and negation types for the spec. Michael Sullivan presented PEP 827 for type manipulation (conditional/mapped types). Douglas Creager showed how ty’s constraint-set solver fixes a partial(choose, None) example all current checkers get wrong. Conner Nilsen found type-checker feedback helps AI agents on well-typed code but not lightly-typed codebases. Jia Chen formalized Python typing in Lean 4, and Avik Chaudhuri demoed tensor-shape types in Pyrefly. The council panel updated on checker landscape (Pyre and pytype winding down) and open spec issues.

I spent 2 years building the async Python task queue I wished existed

The author spent two years developing Repid v2, an async Python task queue that solves the lack of modern async background processing tools. The Python web ecosystem excels with frameworks like FastAPI, but task queues remained antiquated, requiring separate sync contexts and lacking automatic documentation. Repid v1 showed promise but had fundamental design flaws: it was too opinionated about broker capabilities and assumed features like delayed messaging were universal. Production issues with AMQP 0.9.1 prompted the author to write a custom AMQP 1.0 implementation. The v2 redesign embraces simplicity: user-defined message types, broker-agnostic AsyncAPI documentation, and support for multiple brokers including AMQP 1.0, SQS, Kafka, and Redis Streams. Despite modest adoption, the project represents the exact library the author wanted—a self-documenting, truly async message consumer that gets out of the developer’s way.

Learn concurrency - a deep dive into multithreading with Python

This blog post provides a comprehensive overview of concurrency in Python, covering key concepts like multithreading, multiprocessing, race conditions, and synchronization mechanisms such as locks. It explains the differences between sequential, concurrent, and parallel execution, with practical examples. The Global Interpreter Lock (GIL) is discussed as a major limitation preventing true CPU-bound multithreading in Python, though it doesn’t hinder I/O-bound tasks. The article highlights the drawbacks of GIL — such as inability to leverage modern multi-core hardware and the complexity of multiprocessing — and introduces the emerging “free-threaded” build (PEP 703) starting in Python 3.13, which allows developers to disable the GIL and achieve true parallel multithreading.

Behavior-Oriented Concurrency in Python

bocpy is a Python library implementing Behavior-Oriented Concurrency (BOC), a lock-less, deadlock-free paradigm for parallel programming. It uses “cowns” (concurrent-owned variables) to ensure temporal data ownership across sub-interpreters, eliminating traditional locks. Behaviors — decorated functions — declare required cowns and are automatically scheduled for parallel execution, simplifying concurrent code. The library includes a noticeboard for eventually-consistent state sharing and a Matrix class for high-performance numerical operations. bocpy achieves near-linear multi-core scaling via lock-free scheduling and zero-copy data transfer, offering an intuitive alternative to thread-based concurrency.

The Simplest MCP Example Possible in Python

This blog post by Al Sweigart demonstrates the simplest possible MCP (Model Context Protocol) example in Python, showing how to give a local LLM access to external tools. Using FastMCP and Ollama, the author creates an MCP server with two tools — get_current_time and get_current_date — that return the current time and date as formatted strings. A client script connects the Llama 3.2 model to these tools, allowing it to answer time-related questions. The post includes complete code for both the server and client, along with a sample conversation showing the model’s mixed results — correctly answering some questions but also exhibiting common LLM hallucinations, such as incorrectly converting 24-hour time and confidently stating the wrong day of the week.

Using LLMs to find Python C-extension bugs

The article describes how hobbyist Daniel Diniz used Claude Code to systematically discover 575+ bugs in 44 Python C-extensions covering nearly a million lines of code. His cext-review-toolkit employs 13 specialized agents targeting reference-counting, GIL handling, and exception state issues. The approach emphasizes maintainer control, providing high-quality reports with reproducers via secret GitHub gists and adapting based on feedback to minimize false positives. While the reaction has been positive, maintainers note concerns about bug severity and prioritization, suggesting improvements. The article presents this as a responsible example of LLM-assisted bug finding that avoids overwhelming maintainers.

uv is fantastic, but its package management UX is a mess

Astral’s uv is praised for its speed and ability to replace multiple Python tools with one binary, but the author argues its package management UX lags behind peers like pnpm and poetry. Key complaints include: no simple uv outdated command (only uv tree --outdated --depth 1 which displays a cluttered 50-line tree), unsafe default version constraints without upper bounds unlike pnpm’s caret syntax, and awkward upgrade commands requiring repeated --upgrade-package flags. The author welcomes the new --bounds option but notes it’s opt-in and a preview feature. Post-HN reader clarifications noted that uv pip list --outdated exists, --bounds can be set globally in pyproject.toml, and the no-upper-bounds default makes sense for libraries (to avoid dependency resolution issues) but not for applications.

Stop writing edge case tests. Let Hypothesis find them instead.

The author shares how they wrote 47 edge case tests for a URL normalizer, but when they used Hypothesis, it generated 10,000 test cases in 30 seconds and found a critical bug — an all-whitespace URL silently returned an empty string. Unlike conventional tests that check specific inputs, property-based tests define invariants that should hold for any input. Hypothesis generates diverse inputs, shrinks failures to minimal examples, and stores failing cases in a local database for regression testing. The author recommends adding one or two @given tests per function to catch bugs you didn’t know to look for, and provides examples of useful properties like round-trip invariants, idempotency, and monotonicity.

Announcing Genkit Middleware: Intercept, extend, and harden your agentic apps

Genkit, Google’s open-source framework for building AI-powered agentic applications, has introduced a middleware system to enhance reliability, security, and observability. Available in TypeScript, Go, Dart and Python, middleware allows developers to intercept generation calls and tool execution loops to inject custom behaviors. The system offers pre-built solutions including Retry for handling transient errors with exponential backoff, Fallback for switching to alternative models during failures, Tool Approval for human-in-the-loop confirmation of sensitive actions, Skills for dynamically loading contextual knowledge, and Filesystem for scoped file access. Developers can also create custom middleware to enforce specific business rules, such as preventing models from mentioning competitor products, providing a composable way to harden production-ready AI applications.

Inside the Microsoft Agent Framework: How we designed a layered SDK

Microsoft Agent Framework (MAF) is Microsoft’s layered SDK for building production-ready AI agents, which is organized around three core concepts. Agent loops are the fundamental execution cycle where an agent receives input, reasons, calls tools, and iterates until done. Workflows provide structured orchestration for multi-step, multi-agent, or business-critical processes, supporting patterns like sequential flows, handoffs, and author/critic loops. Harnesses supply reusable runtime capabilities — tools, context, memory, planning, permissions, and middleware — that surround the agent and make it practical for real-world use. The framework is provider-agnostic, working across models from Microsoft, OpenAI, Anthropic, and others, and is available for .NET and Python.

The Anatomy of an Agent Harness

This Langchain blog explains that an agent is composed of two parts: a model containing the intelligence and a harness that makes that intelligence useful. A harness includes all the code, configuration, and execution logic around the model. Key harness components include filesystems for durable storage and context management, bash/code execution for autonomous problem-solving, sandboxes for secure isolated execution, memory systems for continual learning, context compaction strategies to prevent context rot, and long-horizon execution features like planning and self-verification loops. The author argues that harness engineering will remain valuable even as models become more capable, as well-designed harnesses optimize model performance for specific tasks. The field continues evolving with active research into multi-agent orchestration, dynamic tool assembly, and self-improving systems.

Agent Skills

This article explores how AI coding agents skip essential senior-engineer practices — specs, tests, reviews, scope discipline — because they optimize for speed, not reliability. The project packages “skills” as workflow-driven markdown files injected into agent context, encoding six lifecycle phases (define, plan, build, verify, review, ship) with concrete exit criteria. Five principles guide design: process over prose, anti-rationalization tables rebutting plausible shortcuts, non-negotiable verification, progressive disclosure to limit context, and strict scope discipline. Skills embed Google-scale practices (Hyrum’s Law, test pyramids, DAMP tests, small PRs, trunk-based development) that agents otherwise ignore. Used as installed slash commands or lightweight runbooks, they force the scaffolding senior engineers provide, turning optional polish into mandatory guardrails for safe, reviewable, ship-worthy code.

How to Work and Compound with AI

The article outlines practical principles for working effectively with AI so that collaboration compounds over time. It argues that every finished artifact — code, docs, analysis, decisions — should become reusable context, while corrections update configurations that reduce future errors. Key practices include organizing work into clear directory structures so models can retrieve relevant context, maintaining annotated indexes and per-project onboarding docs (like CLAUDE.md and INDEX.md) so each session starts with the right knowledge, and separating persistent memory (project state) from personal preferences and workflows. Taste and behavior should be encoded as configuration (global, repo, and project-level CLAUDE.md files), split into lazy‑loaded guides and skills to avoid context bloat. Skills capture repeatable weekly tasks as markdown workflows, bootstrapped by doing a task once and refining it through session transcripts rather than direct edits. Verification is shifted left with deterministic checks, automated tests, and model‑run evals before human review, and long‑running tasks use a “pair programmer” session to detect execution and direction drift. To scale, delegate larger end‑to‑end tasks with clear success criteria and parallel sessions, and make work observable with status signals and remote‑control options. Finally, close the loop by sharing openly, mining transcripts for missing steps or corrections, and periodically refactoring configs to avoid contradictions—the same principles that apply to managing human teams.

Vibe coding and agentic engineering are getting closer than I’d like

Simon Willison distinguishes “vibe coding” — accepting AI‑generated code without review — from “agentic engineering”, where professionals use AI tools to build high-quality systems while maintaining security and maintainability. In this post he observes that the two practices are increasingly overlapping: because AI agents are becoming highly reliable, he now routinely ships production code he hasn’t reviewed, feeling uncomfortable about accountability. He also notes that AI makes it trivially easy to produce polished repos with tests and docs, so real evidence of value now comes from whether software has been actively used. Although AI has shifted bottlenecks from coding to design and evaluation, he believes the core difficulty of software engineering remains, and he doubts a widespread threat to enterprise SaaS since companies generally prefer proven, professionally managed solutions over DIY vibecoded projects.

How I use LLMs as a staff engineer in 2026

In 2026, the author has significantly expanded his use of LLMs compared to 2025. The biggest shift is that AI agents are now reliable enough to produce entire pull requests in areas he’s familiar with, and he uses them constantly for bug investigation (correctly diagnosing ~80% of issues), codebase research, testing, and local setup tasks. He still writes his own PR descriptions and all public communications by hand, believing humans better convey core ideas and signal genuine review. He also avoids using LLMs for UI testing or writing blog posts, though he uses them for draft feedback. His core job — shipping projects, exercising judgment, and navigating politics — remains unchanged, but agents have expanded his capacity to take on small tasks. He warns that many people either under-utilize agents (not delegating enough) or over-utilize them (trusting them with unreviewed sweeping changes), and finding the right balance remains key.

The bottleneck was never the code

The article argues that coding agents shift the bottleneck in software development from writing code to collaboration, decision-making, and context-sharing. While agents dramatically boost individual productivity, the real challenge for organizations is producing precise specifications and maintaining shared context — something humans acquire informally but agents require explicitly. The author emphasizes that focus (saying no to unnecessary features) and organizational coherence become more critical as code becomes cheaper to produce. Agents can help by reading exhaustively to extract implicit knowledge, but some tacit context remains unrecoverable. Ultimately, the companies that thrive will be those that treat coherence and context as maintainable artifacts, not just those with the best technical tools.

Agentic Coding is a Trap

The article argues that over-reliance on AI coding agents is a trap that erodes developers’ critical thinking and debugging skills while creating costly dependencies. It warns that “agentic coding” distances engineers from implementation, causing cognitive atrophy, vendor lock-in, unpredictable token costs, and fragile systems that must manage AI’s non-determinism. Junior and senior developers alike lose the friction essential for deep learning and ownership. Drawing parallels to past tech shifts, the author insists the risk is real and immediate. He advocates using LLMs as secondary aids for planning and research—not as autonomous orchestrators—while keeping hands-on coding central, ensuring competence, quality, and long-term value over short-term speed.

Podcasts

🐍 RealPython Podcast

🍕 Python Bytes Podcast

📣 Talk Python to me

🚀 VS Code Insiders Podcast

Episode 22: Agent-First Development Workflows in VS Code with Brigit Murtaugh

Repositories

pydantic/httpx2 (BSD-3-Clause)

With HTTPX itself seeing limited activity recently, Pydantic is picking up stewardship under the HTTPX2 name so that users have a reliably maintained path forward - including timely security updates for a library that sits in the critical path of so many production systems.

MinishLab/semble (MIT)

Semble is a code search library built for agents. It returns the exact code snippets they need instantly, using ~98% fewer tokens than grep+read. Indexing and searching a full codebase end-to-end takes under a second, with ~200x faster indexing and ~10x faster queries than a code-specialized transformer, at 99% of its retrieval quality.

microsoft/Webwright (MIT)

Webwright gives LLM a terminal where it can launch multiple browser sessions to inspect the page and complete a web task. It captures and inspects page screenshots/states only when needed. It enforces each web task to be completed end-to-end within a re-runnable Python script, i.e. your web agent browsing history is a single code file. No multi-agent system, no graph engine, no plugin layer, no hidden orchestration — just a terminal, a browser, and a model.

As we wrap up this journey together, I want to take a moment to express my gratitude for your reading. If you’ve enjoyed what you just read and would like to help sustain this blog, consider starring this blog on github, it would be great motivation for me to keep updating the blogs!

Alright, that concludes the May Edition of “This Month for Pythonistas”. Thank you again for reading my post. I hope you enjoy it or find something useful. Happy coding and see you in June! 👋

This Month for Pythonistas - April 2026

Zeyang Lin — Thu, 30 Apr 2026 13:00:00 GMT

from datetime import date

print(date.today().year, date.today().month)
# 2026 4

Welcome back Pythonistas! This is the April 2026 issue of “This Month for Pythonistas”, bringing you curated Python news, tutorials, articles, podcasts and community highlights.

Before we continue, please note that this blog is synced across the following platforms:

Ready? Let’s get started!

Reflecting on Five Years as the PSF’s First CPython Developer in Residence

The article reflects on Łukasz Langa’s nearly five-year tenure as the PSF’s first CPython Developer in Residence, highlighting contributions like transitioning to GitHub issues, automating the CLA process, introducing free threading, and modernizing the interactive shell. The role will continue with Meta’s sponsorship through mid-2027. The position has expanded from one to five full-time engineers, ensuring its stability. Łukasz expresses gratitude to the Steering Council and excitement about moving to Vancouver while joining Meta, emphasizing ongoing commitment to the Python community.

DjangoCon Europe 2026

DjangoCon Europe goes to Athens, Greece this year, from April 15th to 19th. More info can be found here.

Introducing GPT‑5.5

OpenAI released GPT-5.5 which excels in coding, knowledge work, scientific research and cybersecurity, matching GPT-5.4’s latency with stronger performance. It has higher token efficiency and stricter safeguards. Now available for Plus/Pro/Business/Enterprise users; API versions launch soon. GPT-5.5 Pro delivers better accuracy for complex tasks.

Introducing Claude Opus 4.7

Claude Opus 4.7, Anthropic’s latest model, is now generally available. It significantly advances Opus 4.6 in advanced software engineering, handling difficult coding tasks with greater autonomy, precision, and consistency. The model also features substantially improved vision, higher-resolution image understanding, and more creative, professional outputs. It demonstrates stronger reasoning, better instruction following, and enhanced multimodal capabilities. With safeguards for cybersecurity and expanded access across products and cloud platforms, Opus 4.7 aims to accelerate complex workflows while maintaining reliability and safety.

Qwen3.6-Plus: Towards Real World Agents

Qwen has launched Qwen3.6-Plus, a major upgrade featuring dramatically enhanced agentic coding capabilities and improved multimodal reasoning. The model now supports a 1M context window by default and excels in complex tasks like frontend development, terminal operations, and automated task execution. It demonstrates state-of-the-art performance across coding benchmarks (SWE-bench, Terminal-Bench 2.0), general agent tasks, and multimodal understanding (MMMU, document analysis, video reasoning).

GLM-5.1: Towards Long-Horizon Tasks

GLM-5.1 is Z.ai’s next-generation flagship model designed for agentic engineering tasks with significantly improved coding capabilities. It achieves state-of-the-art performance on SWE-Bench Pro and leads on NL2Repo and Terminal-Bench 2.0 benchmarks. Unlike previous models that plateau early, GLM-5.1 excels at long-horizon optimization, demonstrated by achieving 6× better results over 600 iterations on vector database optimization, sustaining 3.6× speedup over 1,000+ turns on ML workloads, and building a complete Linux desktop environment over 8 hours through continuous refinement.

Kimi K2.6: Advancing Open-Source Coding

Kimi K2.6 is an open-source model from Moonshot featuring advanced coding, long-horizon execution, and agent swarm capabilities. It demonstrates significant improvements over K2.5 in complex engineering tasks, autonomously handling multi-step workflows across programming languages like Rust, Go, and Python. The model excels at long-running tasks—such as optimizing financial engines and deploying models—with strong tool-calling accuracy (96.60%). K2.6 also enables coding-driven frontend design and full-stack development, while its Agent Swarm architecture scales to 300 sub-agents executing 4,000 coordinated steps. Used in proactive agents like OpenClaw and Hermes, it supports 24/7 autonomous operations and collaborative multi-agent systems through Claw Groups, achieving state-of-the-art performance on benchmarks like SWE-Bench and Terminal-Bench 2.0.

The next evolution of the Agents SDK

The article discusses the next evolution of OpenAI’s Agents SDK, introducing enhanced capabilities for building AI agents. The updated SDK enables developers to create agents that can inspect files, execute commands, edit code, and handle long-term tasks within controlled sandbox environments. Key features include configurable memory, sandbox-aware orchestration, filesystem tools, MCP integration for tool use, and native sandbox execution with providers like Blaxel and Daytona. The architecture separates harness from compute, supports durable execution through snapshotting, and provides standardized primitives for building reliable, scalable agent systems with improved security and performance.

New Versions

Python 3.15.0a8, 3.14.4 and 3.13.13 are out!

3.15.0 alpha 8 is expected to be the last alpha build before beta 1 comes out in May 2026. You can find the full release schedule of Python 3.15 here.

3.14.4 and 3.13.13 are bug fix releases for Python 3.14 and 3.13 respectively, both with binary as well as tarball distributions.

Tutorials

DeepLearning.ai’s Efficient Inference with SGLang: Text and Image Generation

In this course, you’ll build a clear mental model of how inference works (from input tokens to generated output) and learn why the memory bottleneck exists. From there, you’ll implement the KV cache from scratch to store and reuse intermediate attention values within a single request. Then you’ll go further with RadixAttention, SGLang’s approach to sharing KV cache across requests by identifying common prefixes using a radix tree. Finally, you’ll apply these same optimization principles to image generation using diffusion models.

DeepLearning.ai’s Spec-Driven Development with Coding Agents from Paul Everitt

In this course, you’ll write project constitutions, plan and validate features in iterative loops, and apply the same repeatable workflow to both fresh and legacy codebases. You’ll also see how specs preserve context across agent sessions, reduce cognitive debt, and improve intent fidelity, keeping your agent aligned with what you actually want.

DeepLearning.ai’s Building Multimodal Data Pipelines from Snowflake

Images, audio, and video make up a growing share of the data companies generate today, but most pipelines are still built for structured data alone. This course teaches you to build AI-powered pipelines that process multimodal data and turn it into LLM-ready text.

RealPython’s Variables in Python: Usage and Best Practices

In Python, “variables” are symbolic names that refer to objects or values stored in memory, created by assigning a value with the = operator. They are dynamically typed, so their type can change through reassignment, and naming follows rules like using letters, digits, and underscores but not starting with a digit, with snake_case preferred for readability. Variables can be used in expressions, as counters, accumulators, flags, loop variables, or data storage, and they exist in scopes (global, local, non-local, built-in) that determine accessibility. Python also supports type hints, multiple assignment, iterable unpacking, assignment expressions, and pattern matching for creating variables, while attributes in classes provide namespace-like behavior, and del can remove variables from scope.

Articles

Cutting Python Web App Memory Over 31%

The article from Michael Kennedy details how Michael Kennedy reduced his Python web app memory usage from 1,988 MB to 472 MB (over 31% reduction, saving 3.2 GB total) using five key techniques: migrating to Quart (async Flask) with a single Granian worker, replacing the MongoEngine ODM with a Raw+DataClass database pattern, isolating the search indexer into a subprocess (cutting it from 708 MB to 22 MB), moving heavy library imports like boto3 and pandas from global to local function-level imports, and shifting in-memory caches to disk-based caching using the diskcache library.

Python: introducing profiling-explorer

The author introduces profiling-explorer, a new Python tool for exploring profiling data from pstats files generated by Python’s built-in profilers. It provides a web-based interface with features like dark mode, sortable columns, search filtering, and navigation between callers and callees. The tool was motivated by the author’s optimization work where the command-line pstats interface felt clunky. The article also explains Python’s three profilers — profile (deprecated), profiling.tracing (cProfile), and the new sampling profiler Tachyon in Python 3.15 — and provides instructions for generating pstats files and using profiling-explorer to analyze them, sponsored by Rippling.

Django: fixing a memory “leak” from Python 3.14’s incremental garbage collection

The article details an out-of-memory error encountered when running Django migrations on Python 3.14, specifically on a resource-constrained Heroku server. Python 3.14 introduced incremental garbage collection to reduce pause times, but this algorithm struggled with Django’s cyclical objects, causing memory usage to spike beyond limits. The author implemented a workaround by extending Django’s migrate command to force full garbage collection after each migration using gc.collect(), which resolved the issue. Coincidentally, the Python core team announced they would revert incremental garbage collection in Python 3.14.5 due to widespread memory concerns, validating the problem and rendering the workaround temporary.

Using a `~/.pdbrc` file to customize the Python Debugger

The article explores customizing Python’s built-in debugger (pdb) via a .pdbrc configuration file. It details how to set up persistent aliases, command shortcuts, and environment adjustments to streamline debugging workflows. The author provides practical examples, such as defining custom commands and automating routine tasks, demonstrating how .pdbrc enhances productivity by reducing repetitive input. The piece also touches on best practices for organizing configurations and ensuring compatibility across different debugging sessions, making pdb more adaptable to individual developer preferences and complex project requirements.

Building a Python Library in 2026

This blog post provides a comprehensive guide to building Python libraries in 2026, emphasizing modern tools and best practices. The author recommends using uv from Astral as the central tool for project initialization, dependency management, building, and publishing. Key components include: a standard src layout, pyproject.toml metadata, linting/formatting with ruff, type checking with mypy (or alternatives), testing with pytest and coverage, CI enforcement via GitHub Actions, and pre-commit hooks. The author also explores publishing options beyond PyPI and examines real-world implementations from OpenAI and Polars, demonstrating how these tools streamline modern Python package development.

Why pylock.toml includes digital attestations

This blog post from Brett Cannon explains why pylock.toml includes digital attestations to enhance Python package security. Triggered by a recent PyPI project hack, the author highlights how trusted publishing allows continuous deployment systems to securely upload packages without exposing credentials. Digital attestations verify that a package genuinely originated from its expected CD system. When recorded in pylock.toml, publisher details for each package enable automated or manual verification to detect suspicious changes, such as missing or altered attestation data. Ultimately, the author recommends maintainers adopt trusted publishing with attestations, use lock files like pylock.toml, and regularly review attestation consistency to catch potential supply chain attacks.

Continual learning for AI agents

The blog post from Langchain explains that continual learning for AI agents can occur at three distinct layers: the model (weight updates using techniques like SFT or RL), the harness (optimizing the code and tools around the model), and the context (updating configuration, instructions, skills, or memory). While most discussions focus on model-level learning, the harness and context layers offer practical ways to improve agents over time. Traces — the full execution logs of agents — are central to all approaches, enabling analysis and improvement. The harness can be refined by reviewing traces to suggest code changes, while context can be updated at agent, user, or organization levels, either offline or in real-time. Tools like LangSmith and frameworks like Deep Agents support these patterns, allowing AI systems to continuously learn and adapt.

pixi: One Package Manager for Python and C/C++ Libraries

The article compares uv and pixi as Python package managers, explaining that while uv excels at fast dependency resolution and lockfiles for pure Python projects from PyPI, it cannot install compiled C/C++ system libraries like GDAL, requiring separate OS package managers. pixi solves this by managing both Python packages from PyPI and compiled libraries from conda-forge in a single tool, with automatic lockfiles, multi-platform support, built-in task running, and project-level environments. The author recommends using uv for simple Python projects and pixi when working with compiled dependencies, geospatial libraries, or needing unified package management across platforms.

Learning Rust Made Me a Better Python Developer

Learning Rust improved the author’s Python development by forcing explicit thinking about data ownership, error handling, and edge cases. Rust’s compiler enforces strict patterns that prevent common bugs: ownership rules stop unexpected mutations, Result types make failure explicit in return types, and exhaustive pattern matching ensures all cases are handled. Though Python’s type system can approximate these concepts, Rust’s compiler builds a disciplined reflex. The author now writes cleaner, more predictable Python — asking who owns data before mutating, modeling errors explicitly, and treating all possible states — even though Rust and Python serve different roles (performance vs. orchestration) and aren’t direct competitors.

What every dev should know about AI sandboxes

AI sandboxes are critical for safely running AI agents, protecting production systems from potentially harmful actions. The threat model has evolved: agents may confidently execute wrong instructions, not just malicious attacks. Isolation levels range from lightweight containers (fast but share kernel) to MicroVMs (hardware-level isolation but slower), gVisor (userspace kernel), OS-level primitives like Bubblewrap (zero overhead), and simulated environments. Trade-offs exist between speed and security. Vendors like E2B (Firecracker-based), Modal (gVisor), and Daytona (container-based) offer solutions. Building your own sandbox is discouraged unless it’s your core product, as managing security, observability, and lifecycle complexity distracts from primary goals.

Long-running Agents

Long-running agents are AI systems that maintain progress across hours, days, or weeks, overcoming the limitations of traditional chat-based agents that forget and fail over long tasks. They require solving three core problems: finite context windows, lack of persistent state, and unreliable self-verification. Leading approaches from Anthropic, Cursor, and Google converge on decoupling the model’s reasoning loop from execution sandboxes and durable session logs, while implementing patterns like checkpoint-and-resume, memory banks, and separate evaluators to ensure reliability. These systems enable economically feasible delegation of complex, multi-day work, though challenges remain around cost, security, alignment drift, and defining work that can survive autonomous execution.

Scaling Managed Agents: Decoupling the brain from the hands

Anthropic’s Managed Agents service decouples the “brain” (Claude and its harness) from the “hands” (execution sandboxes) and the “session” (event log) through stable, general-purpose interfaces. This architecture — inspired by operating system virtualization — addresses the fragility of earlier monolithic designs where components were tightly coupled in single containers. By treating each component as interchangeable “cattle” rather than precious “pets”, the system gains reliability, security (credentials are isolated from execution), and performance (reducing time-to-first-token by 60-90%). The meta-harness design is opinionated about interfaces but unopinionated about specific implementations, allowing it to evolve alongside model improvements.

Multi-agent coordination patterns: Five approaches and when to use them

The Claude blog outlines five multi-agent coordination patterns for teams building AI systems. The generator-verifier pattern loops output between generation and validation for quality-critical work. Orchestrator-subagent uses a lead agent to delegate clear, bounded subtasks. Agent teams employ persistent workers for independent, long-running parallel work. Message bus routes events through publish-subscribe for evolving pipelines. Shared state lets agents collaborate through a common knowledge store. The authors recommend starting with orchestrator-subagent as the simplest pattern, then evolving as needs clarify, emphasizing that patterns are building blocks often combined in production systems rather than mutually exclusive choices.

Managing context in long-run agentic applications

The article discusses managing context in long-running agentic systems, focusing on Slack’s approach to maintaining coherence across multi-agent investigations. It addresses challenges posed by limited language model context windows and proposes three complementary channels: the Director’s Journal for structured memory, the Critic’s Review for credibility-scored findings, and the Critic’s Timeline for consolidated, evidence-based chronology. These mechanisms enable specialized agent roles while preserving alignment and creativity, allowing systems to operate effectively over extended interactions. The solution emphasizes online summarization rather than accumulating message history, ensuring scalability and trustworthiness.

Components of A Coding Agent

This article by Sebastian Raschka explains the core components of coding agents (like Claude Code and Codex CLI) that make LLMs more effective for programming tasks. The author describes six key building blocks:

(1) Live Repo Context - understanding the project structure and environment; (2) Prompt Shape and Cache Reuse - efficiently packaging and caching stable information; (3) Tool Access and Use - enabling structured tool calls with validation; (4) Minimizing Context Bloat - compressing and deduplicating history; (5) Structured Session Memory - maintaining both full transcripts and distilled working memory; and (6) Delegation with Subagents - splitting tasks into bounded subtasks.

The article emphasizes that the harness layer often matters as much as the underlying model itself, explaining why coding agents feel significantly more capable than the same models in plain chat interfaces.

All your agents are going async

The post argues that AI agents are shifting from synchronous chat to asynchronous, background workflows, breaking HTTP request‑response transport. Async agents need durable state and push-based delivery because they outlive connections, push unprompted updates, switch devices, and serve multiple users. Current solutions like Anthropic Channels, Cloudflare Sessions, and OpenClaw’s WhatsApp model address state or delivery but often rely on polling or custom backends. The author advocates a durable, realtime session layer—bi‑directional, multi‑device, and resilient—that separates conversation state from transport, enabling reliable async collaboration between humans and agents.

Why we’re rethinking cache for the AI era

Cloudflare’s analysis reveals that 32% of network traffic originates from automated sources, including AI bots and crawlers. Unlike human users, AI traffic exhibits high-volume sequential requests targeting long-tail content across websites, significantly raising cache miss rates and straining CDN infrastructure. This has caused real-world impacts like Wikipedia’s 50% surge in bandwidth usage and service slowdowns across platforms like SourceHut and Fedora. Current cache algorithms such as LRU struggle under AI’s constant scanning behavior. Cloudflare proposes AI-aware solutions including alternative cache replacement algorithms (SEIVE, S3FIFO), machine learning-based caching, and ultimately a separate cache layer dedicated to AI traffic to maintain performance for human users.

Your harness, your memory

Agent harnesses — the systems that coordinate LLMs with tools and data — are becoming the standard way to build AI agents, and they are fundamentally tied to memory management. Using closed, proprietary harnesses means surrendering control of your agent’s memory to third parties, which creates significant lock-in. Memory is what allows agents to learn from interactions and deliver personalized experiences, making it a crucial competitive advantage. The article argues that both memory and harnesses should be open and independently owned to maintain flexibility and avoid platform dependency. To address this, the author introduces Deep Agents as an open-source, model-agnostic framework that gives developers full control over their agents’ memory storage and retrieval.

Oh Memories, Where’d You Go

Engram is Weaviate’s memory product (in private preview) designed to store context beyond what fits in Claude Code’s built-in MEMORY.md file (~200 lines). The author tested it by building an MCP server integration but initially found Claude ignored Engram because MEMORY.md loads with zero latency. The solution involved categorizing memories (communication-style, domain-context, tool-preferences, workflow) and integrating at specific session lifecycle points. Testing showed Engram excelled at “decision archaeology” (30% faster with reasoning chains recalled), but failed on planning tasks where Claude defaults to forward-moving. Key improvements needed include fire-and-forget saves, automatic memory capture pipelines, and deterministic retrieval hooks at session start.

The Spec Layer

The blog advocates for spec-driven development (SDD) to constrain AI agents’ execution freedom and prevent “wrong kind of correct” mistakes. Unlike humans, agents make locally valid errors like disabling tests or reusing existing patterns. Written specs provide durable intent that narrows choices at implementation time. Historical protocol examples (RFCs for IP, HTTP, TLS, HTML) demonstrate how specs enable multiple implementations over decades. The ideal spec should be declarative, layered, and cheap to revise, with mechanical enforcement moved to lint, schemas, and tests. The goal is a narrow interface between human intent and machine execution: smaller specs, harder checks, and less guessing.

I Still Prefer MCP Over Skills

The author argues that MCP (Model Context Protocol) is superior to Skills for connecting LLMs to external services because it’s an API abstraction where the LLM only needs to know the “what”, not the “how”. MCP offers zero-install remote usage, seamless auto-updates, proper authentication handling, true portability, sandboxing, and smart tool discovery. Skills, however, require CLI installation, can’t work in many environments like ChatGPT or Perplexity, create deployment and secret management nightmares, and bloat the context window. He concludes that MCP should be the standard for connecting to services, while Skills should only be used for teaching LLMs knowledge about existing tools or workflows — not as replacements for actual service connectors.

The Beginning of Programming as We’ll Know It

The article discusses the impact of AI coding assistants on the programming profession. While AI tools like Claude and Codex can now complete significant coding tasks in minutes, the author argues that human programmers remain essential during this transitional period. Humans bring unique qualities like taste, wisdom, and caution that AI lacks. The author emphasizes that AI-generated code must be reviewed and corrected by humans before it can be considered real work. Despite AI’s impressive capabilities, there’s a “reality distortion field” around AI outputs that can mislead developers. The conclusion is that programmers who embrace AI while maintaining skepticism and human oversight will be better equipped than ever, while those who refuse these tools will fall behind.

The Cult Of Vibe Coding Is Insane

This article criticizes the “vibe coding” trend where developers avoid examining underlying code, instead relying solely on vague AI conversations. After Claude’s source code leak revealed poor quality, the author argues that “pure vibe coding” is a myth — human contributions still occur through language and infrastructure frameworks. Bad software isn’t inevitable with AI; it’s a conscious choice. The author explains that AI excels at cleaning up technical debt when given proper guidance through collaborative dialogue, and developers should actively steer AI toward high-quality outcomes rather than accepting mediocrity. The core message: poor software quality is a decision, not a necessity.

Claude Is Not Your Architect. Stop Letting It Pretend.

The article warns against using AI like Claude as a software architect, arguing that while AI agents are excellent implementers, they cannot make real architectural decisions. AI is “pathologically agreeable” — always validating ideas enthusiastically without the crucial ability to say “no” or push back on complexity. It produces generic “Jenga tower” architectures that look sound but aren’t tailored to specific teams, constraints, or production realities. The real danger is that engineers are reduced to implementing AI-designed tickets, while accountability vanishes — when systems fail, humans stay up debugging decisions they didn’t make. The solution: humans must design, AI must implement.

Podcasts

🥝 core.py

Episode 29: Is CPython developed with AI now?

🐍 RealPython Podcast

🥧 Python Bytes Podcast

🦜 Talk Python to me

🚀 VS Code Insiders Podcast

Episode 21: Inside The Agent Loop with Pierce Boggan

Repositories

NousResearch/hermes-agent (MIT)

The self-improving AI agent built by Nous Research. It’s the only agent with a built-in learning loop — it creates skills from experience, improves them during use, nudges itself to persist knowledge, searches its own past conversations, and builds a deepening model of who you are across sessions.

dropseed/plain (BSD-3)

Forked from Django, plain is an opinionated Python web framework which is ready for the AI Agent age. You can visit their official website for more information.

smelloscope/smello (MIT)

Capture outgoing HTTP requests from your Python code and browse them in a local web dashboard — including gRPC calls made by Google Cloud libraries.

Alright, that concludes the April Edition of “This Month for Pythonistas”. Thank you again for reading my post. I hope you enjoy it or find something useful. Happy coding and see you in May! 👋

This Month for Pythonistas - March 2026

Zeyang Lin — Tue, 31 Mar 2026 13:00:00 GMT

from datetime import date

print(date.today().year, date.today().month)
# 2026 3

Welcome back Pythonistas! This is the March 2026 issue of “This Month for Pythonistas”, bringing you curated Python news, tutorials, articles, podcasts and community highlights.

Time flies! It has been a whole year since the first issue of “This Month for Pythonistas”. I’m excited to kick off another year of informative content and community engagement, and I can’t wait to see what you have in store for this month.

Before we continue, please note that this blog is synced across the following platforms:

Ready? Let’s get started!

OpenAI acquires Astral

OpenAI has announced its acquisition of Astral, the company behind popular Python developer tools including uv, Ruff, and ty. This deal aims to integrate these widely-used open source tools into OpenAI’s Codex ecosystem, which has grown to over 2 million weekly active users with 3x user growth and 5x increased usage since the start of the year. The acquisition will help expand Codex beyond simple code generation to participate in the entire software development workflow, from planning changes to maintaining software over time. The deal is subject to regulatory approval, and Astral’s team will join OpenAI’s Codex team after closing.

Astral founder Charlie Marsh announced that this acquisition will accelerate their mission to make programming more productive by combining Astral’s tooling expertise with AI innovation at the frontier of software development. OpenAI will continue supporting Astral’s open source tools after the deal closes, maintaining their commitment to building in the open alongside the Python community for broader ecosystem impact.

PyCon US 2026 Schedule Revealed

The PyCon US 2026 schedule has been released! Besides, the keynote speakers are announced: Lin Qiao, Pablo Galindo Salgado, amanda casari, Rachell Calhoun, as well as Tim Schilling.

The Python Insider Blog Has Moved!

The Python Insider official blog has moved from Blogger to blog.python.org, with all 307 past posts migrated and old URLs auto-redirecting; RSS readers will update automatically without action. Shifting to Markdown/Git pull requests lowered contribution barriers vs. the prior Blogger/Google account setup. New site features include filtered/paginated posts, author/tag pages, Ctrl+K search, dark mode, and static Astro hosting.

Guido van Rossum Interviews Thomas Wouters

This interview with Thomas Wouters, conducted by Guido van Rossum, chronicles Wouters’ journey from discovering Python via LambdaMOO in the late 1990s to becoming a core Python developer. He contributed augmented assignment operators (+=) and range literals (PEP 203), while participating in pivotal discussions about backward compatibility and nested scopes that led to future imports. Wouters reflects on the friendly Python community during the Usenet era, mentioning key figures like Tim Peters, Fredrik Lundh, and Jeremy Hilton. He also discusses the founding of the Python Software Foundation in 2001 and the challenges of organizing the first PyCon, highlighting how Python evolved from individual use to corporate deployment while maintaining its collaborative spirit.

Guido van Rossum Interviews Brett Cannon

This interview with Python core developer Brett Cannon, also conducted by Guido van Rossum, explores Brett’s journey into the Python community. In 2000, philosophy student Brett discovered Python at UC Berkeley while seeking an object-oriented language for a CS course. After reading the tutorial and an O’Reilly book, he fell in love with the language. During a gap year before grad school, he submitted a pure-Python strptime implementation to python-dev, which led to his first core contribution in 2002. He volunteered to write the python-dev summaries, became PSF member, gained commit rights in April 2003, and was involved in major projects like importlib and Python 3 (PEP 3000/3100). Brett reflects on the early community’s small, passionate nature, the transition from volunteer contributions to paid maintainers, and Python’s evolution through CVS, Subversion, Mercurial, and Git on SourceForge to GitHub.

Py AI Conference

Hosted on March 10th at San Francisco, California, this one-day conference is for Python teams shipping AI to production. Keynote speakers include Guido van Rossum, Sebastián Ramírez (FastAPI) and more.

Gemini 3.1 Flash-Lite: Built for intelligence at scale

Google has launched Gemini 3.1 Flash-Lite, its fastest and most cost-efficient AI model in the Gemini 3 series. Priced at just $0.25 per million input tokens and $1.50 per million output tokens, it delivers 2.5x faster response times and 45% higher output speed compared to its predecessor 2.5 Flash. The model achieves a 1432 Elo score and outperforms competitors on reasoning and multimodal benchmarks. Available via Google AI Studio and Vertex AI, Flash-Lite is optimized for high-volume workloads like translation, content moderation, and UI generation, with adaptive thinking levels for developer control.

Gemini Embedding 2: Our first natively multimodal embedding model

Google has also released Gemini Embedding 2, its first natively multimodal embedding model that maps text, images, videos, audio, and documents into a single unified embedding space, supporting over 100 languages. The model handles up to 8192 text tokens, 6 images, 120 seconds of video, native audio without transcription, and PDFs up to 6 pages per request. It supports interleaved multi-modal inputs in a single request and uses Matryoshka Representation Learning to offer flexible output dimensions (3072, 1536, or 768).

Introducing GPT‑5.4

OpenAI has launched GPT-5.4, their most powerful and efficient frontier model for professional workloads. The model combines advanced reasoning, programming, and agent capabilities with native computer use functionality and 1M token context support. GPT-5.4 introduces “Thinking mode” in ChatGPT, providing transparent reasoning plans, and features improved web search, tool search, and higher accuracy with 33% reduced hallucinations. Performance benchmarks show significant improvements across knowledge work, coding, and complex tasks.

MiniMax M2.7: Early Echoes of Self-Evolution

MiniMax M2.7 is a groundbreaking AI model that deeply participates in its own self-evolution, capable of building complex agent harnesses and completing elaborate productivity tasks. It excels in professional software engineering with 56.22% accuracy on SWE-Pro benchmark, demonstrates top-tier office software capabilities with the highest ELO score among open-source models (1495 on GDPval-AA), and maintains 97% skill adherence across 40 complex skills. The model shows enhanced character consistency and emotional intelligence for entertainment applications.

New Versions

Python 3.15.0 alpha 7

This is the seventh and possiblly the second last alpha release for 3.15 series before the scheduled beta phase begins in May 2026.

Besides, Python 3.12.13, 3.11.15 and 3.10.20, the security bugfix releases for 3.12, 3.11 and 3.10 respectively with only tarball distributions, are also available.

Tutorials

DeepLearning.ai’s Agent Memory: Building Memory-Aware Agents from Oracle

You’ll design a complete memory system that stores and retrieves different memory types, scales tool access using semantic search, and builds write-back loops that allow agents to update their own memory autonomously. By the end, you’ll have assembled a fully stateful Memory Aware Agent that loads prior context at startup, assembles relevant context, state, tools, and outputs and improves across sessions.

Real Python’s Pydantic AI: Build Type-Safe LLM Agents in Python

Pydantic AI is a Python framework for building type-safe LLM agents that return validated, structured outputs using Pydantic models. It eliminates the need for error-prone string parsing by defining schemas with type hints, letting the framework handle validation automatically. The framework uses @agent.tool decorator to register Python functions that LLMs can invoke based on user queries and docstrings. It also supports dependency injection with deps_type for type-safe runtime context like database connections without using global state.

Articles

Thoughts on OpenAI acquiring Astral and uv/ruff/ty

uv stands out as the most impactful tool with 126 million+ monthly downloads, becoming essential for Python environment management. The author discusses potential risks of a major company owning critical infrastructure, parallels to Anthropic’s Bun acquisition, and concerns about OpenAI’s limited track record maintaining open source projects. The author notes that due to permissive licensing, forking remains a viable exit strategy if maintenance deteriorates after the transition.

Python 3.15’s JIT is now back on track

Python 3.15’s JIT compiler has achieved its performance goals ahead of schedule, delivering 11-12% speed improvements on macOS AArch64 and 5-6% on x86_64 Linux compared to the interpreter. The article recounts how the original JIT in Python 3.13 and 3.14 was often slower than the interpreter, and funding cuts to the Faster CPython team made the project’s future uncertain. The author attributes the revival to community-led development, lucky technical choices like trace recording with dual dispatch and reference count elimination, and strong teamwork. Daily performance tracking and breaking complex problems into manageable tasks helped attract contributors, transforming the JIT from an opaque project into something newcomers could contribute to.

The Optimization Ladder

This article presents a comprehensive benchmark of Python optimization techniques, demonstrating a spectrum of approaches from simple to complex. CPython’s dynamic design makes it fundamentally slow (177-875x slower than C for compute benchmarks). The “optimization ladder” shows increasing speedups at higher effort levels: upgrading Python (1.4x), alternative runtimes like PyPy/GraalPy (6-66x), compilation tools like Mypyc (2.4-14x), Numba (56-135x), Cython (99-124x), and JAX (up to 1,633x). For real-world JSON processing, gains were more modest. The author emphasizes that the choice depends on your specific problem - Python as an orchestration layer with NumPy can achieve near-compiled speeds, while pure compute loops benefit most from aggressive optimization.

When to make a class in Python

This article outlines when to use Python classes. Most developers first use classes when required by frameworks like Django for database models. Classes excel at bundling related data and functionality — for example, replacing functions passing a shared server object with an IMAPChecker class. They also clarify data, like shutil’s terminal size class over a bare tuple. While much Python code avoids custom classes, classes improve readability by grouping state and methods together.

Invent your own comprehensions in Python

This article explains how to create “custom comprehensions” in Python using generator expressions. While Python has built-in comprehensions for lists, sets, and dictionaries, it lacks tuple, frozenset, and other specialized collection comprehensions.

The solution is to pass generator expressions to callable functions or classes that accept iterables. For example:

tuple(n**2 for n numbers) acts as a “tuple comprehension”
frozenset(w.strip(...) for w in words) acts as a “frozenset comprehension”
Counter(w.strip(...) for w in words) acts as a “Counter comprehension”

Generator expressions also work with reducer functions like sum(), any(), all(), and join(). The key insight is that any iterable-accepting callable can essentially become a custom comprehension tool.

Fire and forget (or never) with Python’s asyncio

The article discusses a critical issue with fire-and-forget tasks in Python’s asyncio. Starting in Python 3.12, asyncio.create_task() can silently garbage collect tasks before they execute because the event loop only maintains weak references. This means tasks that aren’t explicitly referenced may never run, creating subtle bugs. The solution is to store task references in a set and register a done_callback to clean them up after completion. This non-obvious workaround violates Python’s “one obvious way” principle but prevents tasks from disappearing mid-execution, ensuring reliable background task execution in async applications.

Reinventing Python’s AsyncIO

The author discusses reinventing Python’s asyncio due to its complexity and limitations around the GIL. After discovering tinyio — a simple event loop implementation — the author created TonIO, a new async runtime built in Rust centered on two simple primitives: Event and Waiter. Unlike asyncio, TonIO leverages free-threaded Python to run code across multiple threads without worrying about the main thread. Benchmarks show TonIO is 2-3.5x faster than asyncio for both computation and I/O operations. The author advocates for “reinventing the wheel” to truly understand low-level concepts, encouraging developers to build rather than just ship code.

What Python’s asyncio primitives get wrong about shared state

This blog post discusses problems with Python’s asyncio primitives (Event, Condition, Queue) when coordinating concurrent tasks around shared state.

The author explains that while asyncio.Condition seems to solve the problem of waiting for specific states, it suffers from a lost update bug under real concurrency: when a state changes rapidly (e.g., “closing” → “closed” in the same event loop tick), consumers wake up and check against the current value, missing the intermediate state they were waiting for.

The solution is per-consumer queues: instead of waking consumers and asking “is the current state what you want?”, buffer every state transition into each consumer’s queue. This ensures no intermediate states are missed.

The author provides a ValueWatcher class implementation (about 300 lines) with features like thread safety, timeouts, predicate-based matching, and atomic registration.

CLI subcommands with lazy imports

Brett Cannon’s article discusses using lazy imports (PEP 810 in Python 3.15) with CLI subcommands to improve startup performance. While lazy imports allow importing only needed modules per subcommand, traditional argparse patterns break this: storing lazy imports in dicts or as default function arguments triggers their reification, defeating the purpose. Solutions include using a match statement instead of a dict for dispatching, or wrapping lazy imports in lambdas to add an indirection layer. Both approaches prevent accidental reification while keeping code organized.

The Story of Python’s Lazy Imports: Why It Took Three Years and Two Attempts

This blog post tells the story of Python’s lazy imports feature, which took three years and two attempts to implement. The problem: running simple commands like mytool --help forces Python to load heavy libraries (PyTorch, NumPy, pandas) even when unnecessary. Companies like Meta and Hudson River Trading built their own forks with lazy imports, achieving 50-70% startup time improvements.

PEP 690 (2022) proposed a global -L flag to make all imports lazy by default, but the Steering Council rejected it, fearing it would create “two Pythons” and break the ecosystem.

At the 2023 Language Summit, Thomas Wouters was the only attendee who said he could “never” support lazy imports.

PEP 810 (2025) changed the design: instead of a global flag, it uses an opt-in lazy import keyword with proxy objects—avoiding changes to Python’s internal dictionary structure. Wouters himself became a co-author. The Steering Council unanimously accepted PEP 810 in November 2025, and it will arrive in Python 3.15.

Python Type Checker Comparison: Typing Spec Conformance

This article compares Python type checkers’ conformance to the typing specification, presenting test pass rates: Pyright (97.8%), Zuban (96.4%), Pyrefly (87.8%), mypy (58.3%), and ty (53.2%). It explains that conformance measures how closely checkers follow formal typing rules, with lower conformance forcing developers to work around limitations. However, the article notes conformance has limitations — it doesn’t assess type inference, narrowing behavior, performance, IDE integration, error clarity, or third-party package support. The conclusion recommends considering multiple factors beyond conformance when selecting a type checker, as overall developer experience depends on many dimensions.

Rewriting a 20-year-old Python library

The author recounts rewriting akismet, a 20-year-old Python library for spam filtering originally created by Michael Foord. The rewrite, completed in 2024-2025, separated the library into SyncClient and AsyncClient classes to support both synchronous and asynchronous operations, introduced an enum-based response system to handle “blatant” spam detection, and switched from requests to httpx for better async support and testability. The codebase was reorganized into multiple files, added comprehensive type hints, pytest fixtures, and test client variants. The author dedicated the work to Foord, who passed away in 2025, hoping to honor his legacy by ensuring the library remains maintainable for decades to come.

Replacing tox with UV

This blog post discusses replacing tox with UV for testing Python libraries across multiple Python versions. The author was upgrading libraries to Python 3.10+ and needed to run tests on different Python versions. While tox and nox are common tools for this, UV offers a more convenient single-tool solution.

Key features of UV for testing include:

Using uv run -p 3.10 pytest to test with specific Python versions
Specifying extras and dependency groups with --extra and --group flags
Overriding package versions with --with or -w options
Using --isolated to avoid contaminating the development virtual environment
Running tests in parallel with commands like parallel "uv run -p {} --isolated pytest" ::: 3.{10..14}

The author concludes that while tox remains useful, UV provides a faster, more streamlined approach for debugging version incompatibilities.

Unit testing your code’s performance, part 2: Catching speed changes

This article presents a technique for using unit tests to detect performance changes in code by measuring CPU instruction counts rather than elapsed time. The method involves using libraries like py-perf-event or Valgrind’s Cachegrind to count instructions during test runs. If the instruction count changes beyond a threshold, the test fails, providing early warning to developers before committing changes. The approach requires reducing noise through consistent environments, hash seeds, and disabling ASLR. While not a replacement for benchmarks, these tests offer immediate feedback during development. The technique has caveats: it may not work in virtualized CI, and results vary across hardware, but can help catch accidental performance regressions early.

Defense in Depth: A Practical Guide to Python Supply Chain Security

The article offers a practical guide to Python supply chain security, advocating defense in depth. Key strategies: use ruff security linting; pin dependencies with cryptographic hashes via uv; run pip-audit in CI; generate SBOMs with CycloneDX; adopt Trusted Publishing (OIDC) instead of long-lived tokens; audit GitHub Actions with zizmor; consider delayed ingestion for internal mirrors. It covers threats like dependency confusion, account takeover, and malicious packages, and provides a phased implementation roadmap. The core message: no single control is perfect, so layer multiple defenses.

Building shared coding guidelines for AI (and people too)

This StackOverflow blog post explains how to create effective coding guidelines for AI coding agents. Unlike human developers who absorb tacit knowledge, AI agents lack contextual understanding and require explicit, unambiguous instructions. Guidelines should cover naming conventions, formatting, error handling, and comments using clear, simple language without idioms. Providing both correct and incorrect code examples, plus a “gold standard” reference file, helps agents learn patterns. Errors should be treated as feedback to iteratively improve guidelines collaboratively with the team. Ultimately, these guidelines should be stored in agent configuration files while still using traditional tools like linters to catch basics.

When AI Writes the World’s Software, Who Verifies It?

This post notes AI is already writing a growing share of global software — 25-30% of Google/Microsoft’s new code, plus a 100k-line C compiler in two weeks. It warns unvetted AI code risks widespread security flaws and supply chain attacks, with current poor software quality costing the US $2.4T annually. The solution is formal mathematical proofs, and Lean has emerged as the leading platform to guarantee correct, secure AI-generated code.

AI Coding is Gambling

AI coding generates impressive initial results but behaves like gambling — pulling a slot machine hoping for a jackpot. While AI makes codebase changes trivial and reduces cognitive burden, it often produces plausible yet flawed solutions. The process is addictive but lacks the traditional coding rewards: deep thinking, clever problem-solving, and the satisfaction of making things work. AI offloads the mental work that nurtures the soul, transforming coding from creative problem-solving into mindless slot-pulling, leaving developers to merely clean up poorly implemented code rather than genuinely building solutions.

Is AI Killing Software Engineering Jobs?

The article argues that AI is not responsible for declining software engineering jobs. The downturn actually began in May 2022, before ChatGPT’s launch, triggered by rising interest rates following pandemic-era cheap money. Hiring has been recovering (~5% growth recently). The apparent job shortage stems from reduced employee churn and fear-driven narratives, not AI replacing engineers. Despite layoffs, the developer population continued growing. Businesses claiming to replace engineers with AI still hire them. The author criticizes fear-mongering “AI thought leaders” and predicts demand will recover as it has after previous bust cycles, addressing the temporary pain of those who lost jobs.

Reports of code’s death are greatly exaggerated

The article argues against the notion that AI will eliminate coding. The author explains that English specifications feel precise until complexity reveals their vagueness, using examples like collaborative text editors. The solution to managing complexity is abstraction—compressing many details into single concepts. Even with AGI, code will remain essential because human thinking requires precise abstractions to master complexity, similar to how ChatGPT hasn’t replaced novelists. AI will actually enhance coding by helping create better abstractions and higher-quality code, not make it obsolete. The article concludes that code is just getting started, not dying.

Read Less, Steer More

The blog post argues that with AI coding agents, developers should focus less on reading generated code and more on steering the AI precisely. The author recommends treating AI as a fast typist executing your specifications rather than as an autonomous teammate, demanding justification when something doesn’t make sense. “Vibe coding” is a trap — instead, maintain active involvement to reduce cognitive burden. Beginners should practice without “accept edits” to train intuition, while recognizing that genuine discovery still requires human-speed creation and cannot be rushed. The key mindset shift: don’t accommodate the AI’s output; steer it to match your exact vision.

“Design Me a Highly Resilient Database”

This article argues that there’s no such thing as a “highly resilient database” in the abstract — it always depends on the specific use case. The author recounts failing a job interview by asking clarifying questions about data types, query patterns, and failure modes instead of simply naming a database like “Cassandra”. The piece explains that different databases serve different purposes: PostgreSQL provides ACID compliance essential for financial transactions, Cassandra handles write-heavy workloads with eventual consistency for IoT data, and Redis works best for caching. The author emphasizes that the CAP theorem forces tradeoffs between consistency and availability, and choosing the wrong database — like eventual consistency for ledgers — can lead to audit failures and regulatory issues. The right approach starts with questions, not product names.

Podcasts

🐍 RealPython Podcast

🥧 Python Bytes Podcast

🦜 Talk Python to me

🍕 Pybites Podcast

#218: Why Python developers are learning Rust

🚀 VS Code Insiders Podcast

Episode 20: Autopilot Mode with Justin Chen

Repositories

agentscope-ai/ReMe (Apache-2.0)

ReMe is a memory management framework designed for AI agents, providing both file-based and vector-based memory systems.

It tackles two core problems of agent memory: limited context window (early information is truncated or lost in long conversations) and stateless sessions (new sessions cannot inherit history and always start from scratch).

alibaba/OpenSandbox (Apache-2.0)

OpenSandbox is a general-purpose sandbox platform for AI applications, offering multi-language SDKs, unified sandbox APIs, and Docker/Kubernetes runtimes for scenarios like Coding Agents, GUI Agents, Agent Evaluation, AI Code Execution, and RL Training.

NVIDIA/OpenShell (Apache-2.0)

OpenShell is the safe, private runtime for autonomous AI agents. It provides sandboxed execution environments that protect your data, credentials, and infrastructure — governed by declarative YAML policies that prevent unauthorized file access, data exfiltration, and uncontrolled network activity.

Gen-Verse/OpenClaw-RL (Apache-2.0)

OpenClaw-RL is a fully asynchronous reinforcement learning framework that turns everyday conversations into training signals for personalized AI agents, and supports training general agents with large-scale environment parallelization.

Alright, that concludes the March Edition of “This Month for Pythonistas”. Thank you again for reading my post. I hope you enjoy it or find something useful. Happy coding and see you next month! 👋

This Month for Pythonistas - January 2026

Zeyang Lin — Sat, 31 Jan 2026 04:00:00 GMT

from datetime import date

print(date.today().year, date.today().month)
# 2026 1

Welcome back Pythonistas and Happy New Year 🎉! This is the first issue of 2026, and I’m excited to kick off another year of “This Month for Pythonistas” with curated Python news, tutorials, articles, podcasts and community highlights. And as a “special” issue it would cover also retrospectives of 2025 and expectations for 2026.

Before we continue, please note that this blog is synced across the following platforms:

Ready? Let’s get started!

EuroPython 2026 Location Revealed

EuroPython 2026 will take place in Kraków, Poland from 13th to 19th July, 2026. The CFP (Call for Proposals) is open now until 15th of February. This is also the 25th anniversary of EuroPython. Learn more here.

Anthropic invests $1.5 million in the Python Software Foundation and open source security

Anthropic invests $1.5M over two years in the Python Software Foundation (PSF). Funds will enhance Python ecosystem security (e.g., automated PyPI package reviews to ward off supply-chain attacks) and sustain the PSF’s core work supporting CPython, its global community and infrastructure.

2026 Python Developers Survey

This is the nineth official Developer Survey by PSF, in partnership with JetBrains. Completing the survey contributes to understanding the state of Python development and the Python community.

PEP 686 - Make UTF-8 mode default

PEP 686 is Final. Starting from Python 3.15, Python will use UTF-8 mode by default in text encoding. This change represents a significant step toward modernizing Python’s text handling while maintaining backward compatibility through opt-out mechanisms and warnings.

New Versions

Python 3.15.0 alpha 5

Here comes the fifth of ~~seven~~ eight planned alpha releases of Python 3.15, just a couple of days after alpha 4 was released.

Pandas 3.0.0

Pandas 3.0.0 is the long-awaited major release which brings significant improvements to pandas, but also features some potentially breaking changes. The release notes can be found here.

FastMCP 3.0.0 beta 1

FastMCP 3.0 introduces a redesigned framework for building Model Context Protocol servers. Built around three primitives — Components, Providers, and Transforms — it transforms from simple tool servers into dynamic “Context Applications” that intelligently manage information for AI agents. Read more at What’s New in FastMCP 3.0.

Tutorials

Deeplearning.ai’s Document AI: From OCR to Agentic Doc Extraction from LandingAI

This course shows you how to build agentic workflows that process documents the way humans do: breaking them into parts, examining each piece carefully, and extracting information through multiple iterations.

Deeplearning.ai’s Gemini CLI: Code & Create with an Open-Source Agent from Google

In this course, you’ll apply Gemini CLI to software development and creative tasks by building features for an AI conference. You’ll develop a website session catalog, create a data dashboard combining local and cloud data sources, and generate social media content from recordings. You’ll master context management, integrate MCP servers, and orchestrate across multiple services with Gemini CLI extensions.

RealPython’s How to Build a Personal Python Learning Roadmap

This tutorial will help you craft a personal Python learning roadmap so you can track your progress and stay accountable to your goals and timeline.

Articles

Python Numbers Every Programmer Should Know

This article from Michael Kennedy outlines key Python performance and memory metrics for developers. Latency benchmarks include fast attribute reads (14 ns), dict lookups (22 ns), and FastAPI’s quick JSON responses (8.63 µs). Memory usage notes are striking: small ints/floats take 28/24 bytes, empty Python processes use ~15.7 MB, and slots-class instances (5 attributes) consume 212 bytes (vs 694 bytes for regular classes). Other stats highlight list append speed (28.7 ns) and SQLite query efficiency. These numbers aid in optimizing performance-sensitive algorithms.

Recent optimizations in Python’s Reference Counting

The article discusses Python 3.14+ optimizations for reference counting in CPython. It introduces a new bytecode instruction LOAD_FAST_BORROW that avoids incrementing reference counts when loading local variables in hot loops, reducing memory management overhead. This optimization uses static lifetime analysis to ensure safety - borrowed references must be consumed within one code block, used for simple operations, and the source value can’t change during execution. The optimization is similar to Rust’s lifetime analysis and immutable borrowing concept. Additionally, there are ongoing efforts to eliminate redundant reference counting in JIT compiled code, though this is experimental and disabled by default.

The Hidden Cost of Python Dictionaries (And 3 Safer Alternatives)

This article explains the hidden dangers of Python dictionaries: typos in keys cause silent bugs, and type errors lead to data corruption. It presents three safer alternatives with increasing protection:

NamedTuple – Fixed structure with IDE autocomplete; immutable
dataclass – Mutable fields, safe defaults, custom validation via __post_init__
Pydantic – Runtime type enforcement, automatic type coercion, built-in constraints

The author recommends using dicts for quick prototyping and Pydantic for production code where safety matters.

Implicit string concatenation

Python automatically concatenates string literals placed next to each other without any operator - called “implicit string concatenation”. This feature is mainly used for breaking long strings across multiple lines using parentheses for implicit line continuation. However, it can cause bugs when commas are accidentally omitted in lists or function calls. The article recommends avoiding this feature in favor of explicit concatenation with + or using multiline strings with textwrap.dedent(), and suggests using linters to prevent accidental usage.

What async really means for your python web app?

Python async web benchmarks reveal surprising results: synchronous Django with database connection pooling consistently outperforms async alternatives. Testing static content, database reads, and contentious writes shows that FastAPI excels only when it’s the sole bottleneck. For typical web services that directly access databases, the database — not the web service — is usually the bottleneck. Async Django shows 10x slower performance than sync Django for static content, while database pooling eliminates sync latency issues without code changes. The article concludes that for most services directly connecting to databases, optimized sync configurations deliver better performance than async alternatives.

Asyncio is neither fast nor slow

This article critiques misleading benchmarks comparing Python’s async vs sync web frameworks. The author discovered that performance discrepancies often stem from implementation bugs (like SQLAlchemy fetching all results) rather than asyncio itself. After proper configuration, async and sync perform similarly.

The key takeaway: asyncio’s advantage isn’t speed but resource efficiency — achieving comparable performance without extra threads/processes. The author advises against taking benchmarks at face value and encourages testing for your specific requirements. Performance depends more on implementation details and connection pools than the async/sync paradigm itself.

How to Type Hint a Decorator in Python

This article explains how to properly type hint Python decorators. Using TypeVar causes mypy errors. Instead, use ParamSpec with TypeVar to capture generic parameter and return types. For Python 3.12+, PEP 695 offers simplified syntax using square brackets (e.g., def info[**P, R]) to implicitly declare ParameterSpec. Both approaches maintain type safety for decorated functions while preserving their original signatures.

Static Protocols in Python: Behaviour Over Inheritance

This article explains static protocols in Python - a way to check object behavior rather than inheritance. Protocols enable structural typing where objects are validated by having required methods/attributes, not by class hierarchy. The author contrasts this with traditional “goose typing” using isinstance(), showing how protocols reduce coupling and enable static type checking. A real-world ML example demonstrates using a Predictable protocol for models with predict_top_k methods. Static protocols (Python 3.8+) provide type safety while maintaining flexibility, allowing different coding styles to work together without complex inheritance trees. They catch errors at development time rather than runtime.

Unit testing your code’s performance, part 1: Big-O scaling

This article explains how to unit test your Python code’s performance by testing Big-O scalability. It introduces the bigO library to empirically determine and test algorithm complexity. The author demonstrates how to track function performance, generate reports showing time/memory bounds (like O(n) or O(n²)), and write automated tests that fail when scalability changes. This approach catches critical performance regressions where algorithms become less efficient, which is especially important for processing large datasets. The method is presented as a starting point for performance testing, with plans to cover additional efficiency testing in future articles.

How we made Python’s packaging library 3x faster

Python’s packaging library was optimized to achieve 3x faster performance in version 26.0rc1. Key improvements include: Version construction became 2x faster, SpecifierSet operations up to 3x faster, and some operations up to 5x faster. Optimizations involved removing redundant NamedTuple structures, eliminating duplicate Version creation, using faster regex patterns, replacing singledispatch with if statements, and implementing better caching. The team used Python 3.15’s statistical profiler and PyPI metadata to measure performance. These changes significantly speed up dependency resolution for tools like pip, which creates millions of Version objects during package installation.

WebAssembly as a Python extension platform

This blog post explores using WebAssembly (Wasm) as a Python extension platform. The author discusses two main use cases: (1) replacing Python functions with faster C-compiled-to-Wasm code for 10x performance improvements, and (2) embedding secure crypto libraries like Monocypher in Python applications. Key challenges include handling pointers as unsigned integers, managing memory allocation between host and guest, and working around wasmtime-py limitations.

The author provides detailed examples showing how to create Python bindings for Wasm modules while avoiding common pitfalls like negative pointer arithmetic. Despite rough edges like large binary sizes and API instability, this approach enables distributing architecture-independent Python packages without requiring native toolchains.

The Emperor Has No Clothes: How to Code Claude Code in 200 Lines of Code

This article reveals that AI coding assistants like Claude Code aren’t magic — they’re built on a simple 200-line Python architecture. The core concept is a conversation loop between an LLM and a toolbox of three essential functions: read files, list files, and edit files.

The process works by having the LLM decide when to use tools, sending structured tool calls, executing them locally, and feeding results back. The LLM never directly touches the filesystem—it just requests actions that your code performs.

While production tools add features like better error handling, streaming, and more tools, the fundamental architecture remains this simple request-execute-respond cycle. The author demonstrates how anyone can build a functional coding agent using this straightforward pattern, proving that sophisticated AI coding tools are built on surprisingly simple foundations.

The Future of Software Development is Software Developers

The article argues that despite claims that AI (especially LLMs) will replace software developers, history shows new technologies don’t reduce programming needs but increase demand. The hard part of programming is translating human ambiguity into precise code, which AI struggles with. LLMs often slow development and produce unreliable code. While AI may assist in prototyping or inline completion, developers will remain essential. The current AI hype will likely fade, and businesses should hire and train developers now. The future will see AI as a tool, not a replacement, with more demand for skilled programmers.

Agent-native Architectures

This guide outlines a revolutionary approach to software development where AI agents are first-class citizens, not just add-ons. The core principle: build applications where features aren’t code you write, but outcomes you describe that agents achieve using tools in loops.

Five key principles govern this architecture: Parity (agents can do everything users can via UI), Granularity (atomic tools enable flexible composition), Composability (new features emerge from prompt combinations), Emergent capability (agents accomplish unanticipated tasks), and Improvement over time (apps get better through context and prompt refinement).

The approach shifts from traditional feature-by-feature development to creating a capable foundation and observing what users request, then formalizing patterns. Files serve as the universal interface due to their transparency and agent-friendliness.

This architecture enables applications that are simple to start but endlessly powerful, discover latent user demand organically, and improve without code updates. The ultimate test: can your agent accomplish domain-specific outcomes you never explicitly built features for?

Demystifying evals for AI agents

This article explains how to effectively evaluate AI agents, whose autonomy and flexibility make them harder to assess than traditional models. Good evaluations prevent reactive debugging cycles by catching issues before they affect users.

The authors outline a comprehensive evaluation framework with key components: tasks (individual tests), trials (multiple attempts), graders (scoring logic), transcripts (complete interaction records), and evaluation harnesses (infrastructure). They recommend combining three grader types: code-based (fast, objective), model-based (flexible, nuanced), and human (gold standard validation).

Different agent types require tailored approaches: coding agents use unit tests and static analysis; conversational agents need multidimensional scoring including interaction quality; research agents require groundedness and coverage checks; computer use agents need outcome verification in real environments.

The article provides a practical roadmap: start early with 20-50 real-world tasks, build robust harnesses with stable environments, design thoughtful graders, and maintain long-term through transcript review. When combined with production monitoring, A/B testing, and user feedback, evaluations create a comprehensive quality system that accelerates development rather than slowing it down.

How to build self-improving coding agents

Part 1

To build self-improving coding agents without changing model weights, the author proposes modifying the agent’s environment using two key levers: AGENTS.md as repository memory and skills as reusable playbooks.

AGENTS.md helps agents navigate codebases quickly through code maps and encodes repo-specific corrections and norms, preventing repeated mistakes. When agents discover mismatches or receive user feedback, they should update the documentation automatically, creating a durable feedback loop. This operational approach reduces repetitive guidance and makes agents improvement without constant babysitting.

Part 2

The second explores “skills” for coding agents—reusable prompt folders (SKILL.md + assets) that streamline repetitive tasks. Skills explicitly define when to use them, steps to follow, and expected outputs. Examples include GitHub debugging, release announcements, ML model reports, and domain-specific troubleshooting. Skills evolve through iteration and feedback, making them easier to refine than starting from scratch. While distribution is less mature than MCP servers, tools like OpenSkills now help with installation and updates.

Part 3

Part 3 combines repo memory (AGENTS.md) and skills into a practice with a maturity model: ad hoc prompting → repo-local memory → global personal skills → shared team skills. Watch agent traces to identify patterns—repo-specific go into AGENTS.md, reusable workflows become skills. Markdown becomes executable when agents turn instructions into tool calls. The key distinction: AGENTS.md for how a repo works; skills for repeatable, on-demand procedures. The meta skill is metacognition—watching yourself work to systematize repeated tasks. Coding agents are evolving beyond coding tools into general-purpose teammates across all intellectual work.

AI writes code faster. Your job is still to prove it works.

AI accelerates coding but shifts the burden from writing to proving code works. By 2026, 30% of senior developers ship mostly AI-generated code, which has 75% more logic errors. Solo developers rely on automated testing as safety nets, while teams use human review for security, context, and accountability. AI generates 45% of code with security flaws and increases PR volume by 18%, creating review bottlenecks. The new “PR contract” requires authors to provide evidence of working code through tests and manual verification. AI serves as first-pass reviewer, but human judgment remains essential for quality control and responsibility.

AI Makes Exploration Cheap, Not Decisions Easy

AI makes exploration cheaper, not decisions easier. The key insight is that AI accelerates the exploration phase of creative work, allowing designers and developers to try more options in less time, but it doesn’t eliminate the need for human judgment.

Great work requires “wasted work” - trying multiple approaches that don’t work to discover what does. AI compresses this process from days/weeks to hours, enabling rapid prototyping and experimentation. However, AI cannot make final decisions because it lacks context about users, brand, constraints, and past experiences.

The human role shifts to Director-Curator-Craftsman: setting vision, selecting from AI-generated abundance, and applying taste and judgment. The real benefit is faster learning - each failed attempt teaches something valuable about the problem.

The trap is letting AI make decisions for you. Instead, use AI to multiply exploration, then apply critical thinking to choose the best option. Your value lies in knowing what should get built and why, not in the mechanical production work.

Top Python libraries of 2025

Tryolabs’ 11th 2025 top Python libraries list balances LLM-focused tools and broader ecosystem innovations (performance, security, dev experience). It includes 10 top general picks (e.g., Rust-powered ty type checker) and 10 AI/ML/Data tools, plus runners-up for each category to reflect real-world AI system building.

PyPI in 2025: A Year in Review

The PyPI 2025 Year in Review highlights major growth and security improvements. Key statistics: over 3.9 million new files, 130,000 new projects, 1.92 exabytes transferred. Security enhancements included improved 2FA (52% of active users), trusted publishing (50,000+ projects), email verification, phishing protection, and zipfile security. Organizations grew to 7,742 created with 9,059 projects managed. The team processed 2,000+ malware reports (66% resolved in 4 hours), handled 2,221 account recoveries, and resolved 500+ name retention requests. New features included project archiving, new Terms of Service, and enhanced incident reporting transparency.

2025: The year in LLMs

2025 was a transformative year for LLMs, with key trends including “reasoning” as a dominant feature—models like OpenAI’s o3 and o4-mini excelled in multi-step problem-solving and tool integration. Agents emerged critical, particularly coding agents (e.g., Claude Code, Codex CLI) handling asynchronous tasks, generating $1B in run-rate revenue. Chinese open-weight models (GLM-4.7, Qwen3) outperformed competitors, ranking highly. Prompt-driven image editing tools (GPT-4o, Google’s Nano Banana) drove viral adoption. Meta’s Llama 4 underperformed, and long tasks advanced, with models completing hours-long assignments. Agents streamlined search, and async coding tools became mainstream. Leadership shifted, with OpenAI and Google innovating, while Chinese models challenged Western dominance.

Five Takes to End 2025

Parker Ortolani’s year-end tech analysis covers five key takes:

OpenAI risks distraction by over-productizing instead of focusing on core AI models;
Google’s dominance is resurgent with successful AI initiatives;
departing Apple designer Alan Dye deserves more credit for his influential 12-year tenure;
software-on-demand through AI coding tools is disrupting traditional app development;
while Apple delivered excellent hardware in 2025, they must launch a spectacular AI Siri in 2026 after delays.

Software Engineering in 2026

The article explores how 2025’s AI coding advances will reshape software engineering in 2026. LLM tools have significantly reduced the marginal cost of producing quality code, shifting bottlenecks elsewhere. Key changes expected: infrastructure abstractions become more valuable, CI infrastructure needs higher quality, human-guided abstractions grow crucial for preventing technical debt, code review must evolve to focus on high-impact decisions, and project timeline estimates will increase in variance. While building code becomes cheaper, operating systems and high-value projects remain less LLM-amenable, requiring deeper human expertise.

17 predictions for AI in 2026

This article presents 17 AI predictions from experts with confidence scores, focusing on technology advancement and economic impact. Key predictions include Big Tech exceeding $500B in capital expenditures, OpenAI/Anthropic hitting 2026 revenue goals ($30B/$15B), context windows stabilizing around 1M tokens, and US GDP growth remaining under 3.5%.

Other notable predictions include Tesla offering driverless taxi service, Chinese companies potentially surpassing Waymo’s robotaxi fleet, and AI avoiding major catastrophes.

Overall, the authors expect steady AI improvement but modest real-world economic impacts, dismissing both AI bubble fears and rapid “fast takeoff” scenarios, instead predicting gradual integration across industries.

Podcasts

🥝 core.py

Episode 28: 2025 In Review

🐍 RealPython Podcast

🥧 Python Bytes Podcast

🦜 Talk Python to me

🍕 Pybites Podcast

🚀 VS Code Insiders Podcast

Episode 18: Orchestrating Multiple Agents in VS Code with Ben & Peng

Repositories

adamchainz/tprof (MIT)

tprof is a targeting profiler for Python 3.12+ that only measures the time spent in specified target functions. You can use it to measure your program before and after an optimization to see if it made any difference, with a quick report on the command line.

Alright, that concludes the January Edition of “This Month for Pythonistas”. Thank you again for reading my post. I hope you enjoy it or find something useful. Happy coding and see you in February! 👋

This Month for Pythonistas - December 2025

Zeyang Lin — Wed, 31 Dec 2025 08:00:00 GMT

from datetime import date

print(date.today().year, date.today().month)
# 2025 12

Welcome back Pythonistas! It’s the final month of 2025 (happy holidays!), and we have a lot to catch up on before the new year rings in.

Before we continue, please note that this blog is synced across the following platforms:

Ready? Let’s get started!

Investing in the Python ecosystem

Vercel has announced a significant expansion into the Python ecosystem by hiring the team behind Gel Data, led by renowned Python core developer Yury Selivanov and contributor Elvis Pranskevichus. Known for creating high-performance tools like uvloop and asyncpg, this team will spearhead Vercel’s efforts to bring world-class Python support to its AI Cloud.

This move marks a strategic shift for Vercel beyond its JavaScript and TypeScript roots, aiming to make Python deployment as seamless and fast as its existing frontend workflows. As part of this initiative, Vercel plans to improve Python framework support and actively contribute to the open-source tools the community relies on.

To demonstrate its commitment, Vercel is investing directly in the Python community through several initiatives:

Becoming a Maintaining-level sponsor of the Python Software Foundation (PSF).
Sponsoring core developer Serhiy Storchaka for a full year to support his work on the interpreter and standard library.
Funding key conferences, local meetups, and a planned hackathon.

Regarding the acquisition, Vercel clarified that the Gel Data platform itself will wind down by January 31, 2026, though its open-source components will remain available. The deal is focused strictly on acquiring Python expertise rather than entering the database market; Vercel intends to continue partnering with existing database providers via its marketplace.

Why developers still flock to Python: Guido van Rossum on readability, AI, and the future of programming

Despite TypeScript recently overtaking Python in GitHub popularity, Python creator Guido van Rossum remains optimistic about his language’s future. In this interview, he attributes Python’s enduring success —- including a 49% year-over-year growth —- to its core philosophy of readability and developer friendliness.

Guido highlights Python’s critical role in the AI boom, driven by a massive ecosystem (NumPy, PyTorch) rather than just syntax. He argues against enforcing strict typing for AI’s sake, believing tools should adapt to humans. Ultimately, Python’s accessibility to non-CS backgrounds and commitment to backward compatibility ensure it remains a foundational tool for the next generation of developers.

The Rise and Rise of FastAPI

Sebastián Ramirez, the creator behind FastAPI, talks about his background, motivation, inspiration, and surprise at the meteoric rise of his open source project in this short documentary produced by CultRepo.

AWS re:Invent 2025

Nova 2: Lite, Pro, Sonic and Omni, all with multi-modal capabilities
Nova Forge: blend proprietary data with Amazon Nova-curated training data and host custom models securely on AWS.
Kiro Powers:
strands-agents: TypeScript variant now in preview
Frontier agents: autonomous, scalable agents which can work for hours or days without intervention
AWS Lambda durable functions: build resilient multi-step applications and AI workflows that can execute for up to one year
AWS Transform custom: AI-powered custom modernization for code, APIs, etc.

Introducing GPT-5.2

OpenAI introduced GPT-5.2, their “most powerful” model series designed for professional knowledge work and persistent agents. The model significantly enhances capabilities in spreadsheet creation, presentation design, coding, image recognition, long-context understanding, and complex multi-step projects.

Key benchmarks show substantial improvements: GDPval knowledge work tasks at 70.9% (vs. 38.8% for GPT-5), SWE-Bench Pro software engineering at 55.6%, GPQA Diamond scientific questions at 92.4%, and near-perfect long-context reasoning (100% accuracy on 4-needle MRCR tests up to 256k tokens). Visual understanding and tool calling also saw major advances.

Three variants are available: GPT-5.2 Instant for daily tasks, Thinking for complex work, and Pro for highest-difficulty problems. The models are rolling out to paid ChatGPT users and available via API. Safety improvements include better responses to sensitive topics like mental health. Early partners like Notion, Box, Shopify, and Databricks report strong performance in real-world applications.

Gemini 3 Flash: frontier intelligence built for speed

Google introduced Gemini 3 Flash, a high-speed AI model in Gemini 3 family designed to deliver “frontier intelligence” with industry-leading efficiency. It combines Gemini 3 Pro-grade reasoning with Flash-level latency, significantly outperforming the 2.5 series. On benchmarks like GPQA Diamond, it achieves a 90.4% score while remaining 3x faster and more cost-effective ($0.50/1M input tokens) than previous models.

Key Features and Capabilities:

Agentic Workflows: Optimized for the new Google Antigravity platform, it excels at complex coding and agentic tasks, scoring 78% on coding evaluations.
Real-Time Multimodal Reasoning: It supports near-instant interactions, such as live sketching assistance, golf swing analysis, and “voice-to-app” creation without manual coding.
Ecosystem Integration: It is now the default model for the Gemini app and AI Mode in Search, providing more nuanced and visual responses globally.

Donating the Model Context Protocol and establishing the Agentic AI Foundation

Anthropic has donated its Model Context Protocol (MCP) to the newly established Agentic AI Foundation (AAIF), a directive fund under the Linux Foundation.

The AAIF was co-founded by Anthropic, Block, and OpenAI, with support from industry leaders like Google, Microsoft, and AWS. Its mission is to ensure the development of agentic AI remains transparent, collaborative, and in the public interest through shared open standards.

Key details include:

MCP’s Role: Launched a year ago, MCP serves as a universal open standard for connecting AI applications to external systems. It has already seen massive adoption, with over 10,000 active servers and support from major platforms.
Strategic Donation: By transferring MCP to the AAIF, Anthropic aims to maintain the protocol as a neutral, vendor-agnostic, and community-driven standard, preventing any single company from controlling the ecosystem.
Future Growth: MCP will be a founding project of the AAIF alongside Block’s “goose” and OpenAI’s “AGENTS.md.” Anthropic remains connected to the project and will continue to contribute to its development.

Cloudflare outage on December 5, 2025

On December 5, 2025, Cloudflare experienced a 25-minute service outage (08:47–09:12 UTC) affecting approximately 28% of its HTTP traffic. The incident resulted in widespread HTTP 500 errors but was not caused by a cyberattack.

The outage was triggered during an update intended to mitigate a critical React vulnerability (CVE-2025-55182). While attempting to disable an internal testing tool via a global configuration change, engineers inadvertently activated a dormant bug in Cloudflare’s Lua-based rules engine. A “killswitch” applied to a specific rule type (action “execute”) caused the code to attempt to access a non-existent object, resulting in a runtime error.

This error impacted customers using Cloudflare’s legacy FL1 proxy with Managed Rulesets. The outage ended once the configuration change was reverted. Cloudflare has apologized and is prioritizing resiliency measures, such as “fail-open” error handling and safer configuration rollout mechanisms, to prevent recurrence.

New Versions

Python 3.15.0 alpha 3

Here comes the third of seven planned alpha releases of Python 3.15.

Additionally, Python 3.14.2 and 3.13.11 (yet another two expedited releases) are also available.

Django 6.0

The highlights of this major release include: Template Partials, Background Tasks, Content Security Policy (CSP), Modernized Email API, and more. The full release notes can be found here. Read on and you can find articles down below that highlight this release.

ty 0.0.8

ty，the extremely fast Python type checker and language server from astral.sh, has reached its beta phase. Both the CLI and the VSCode extension are now updated.

Tutorials

deeplearning.ai’s Building Coding Agents with Tool Execution from E2B

In this course, you’ll build agents that write and execute code to accomplish tasks, going far beyond predefined function calls. Instead of limiting your agent to a fixed set of tools, you’ll let it access Python’s entire ecosystem, and write multi-step code sequences. Plus, you’ll learn to run this generated code safely in sandboxed cloud environments, protecting your systems from potentially harmful operations.

deeplearning.ai’s Nvidia’s NeMo Agent Toolkit: Making Agents Reliable

Nvidia’s open-source NeMo Agent Toolkit (NAT) provides the building blocks you need to harden your agents for production, whether built in raw Python, LangGraph, CrewAI, or any other framework.

RealPython’s How to Build the Python Skills That Get You Hired

This tutorial provides a strategic approach to building Python skills for career success. It outlines a three-step framework:

Step 1: Identify Skills Employers Value Research job listings to find recurring patterns. Common requirements include Python fundamentals, Git, unit testing, debugging, and increasingly familiarity with AI coding tools (GitHub Copilot, Claude Code, etc.). Different paths exist: web development (Flask/Django), data science (NumPy, pandas), or machine learning (PyTorch).

Step 2: Map Your Learning Path Create a skill roadmap worksheet tracking your current proficiency (1-5 scale), job relevance, and specific next actions. Use SMART criteria—make goals Specific, Measurable, Achievable, Relevant, and Time-bound. Prioritize high-impact, high-urgency skills first.

Step 3: Build Sustainable Practice Design weekly practice sessions (distributed learning works better than marathon sessions). Build complete projects demonstrating skills, practice coding challenges for interviews, and learn to use AI tools effectively. Focus on demonstrating judgment when reviewing AI-generated code.

Articles

PEP 810 - Explicit lazy imports

PEP 810 is accepted. It introduces syntax for explicit lazy imports in Python, allowing developers to defer module loading until the imported names are first used. This PEP is now targeted for Python 3.15.

Eventual Rust in CPython

Core Python developers Emma Smith and Kirill Podoprigora proposed integrating Rust into CPython, initially for optional modules but eventually as a build requirement. They cited benefits like memory safety and attracting new contributors, a sentiment supported by Guido van Rossum.

However, the proposal faced pushback regarding increased build complexity, potential community friction similar to “Rust for Linux”, and difficulties for niche architectures like those supported by Gentoo. Consequently, the authors scaled back the plan, indefinitely postponing mandatory adoption. They will focus instead on a gradual introduction via optional extension modules to build infrastructure and experience first.

Module compression overview

This article from Rodrigo Girão Serrão teaches Python 3.14’s new compression package, covering 5 modules: bz2, gzip, lzma, zlib, and zstd. It explains basic compression/decompression, file operations, and incremental processing. The modules offer simple compress/decompress functions plus advanced options. Zstd is new to Python 3.14 and shows superior compression ratios.

Generalising `itertools.pairwise`

This article explains Python’s itertools.pairwise, a tool for creating overlapping pairs of consecutive elements from an iterable. While often implemented with slicing, the post suggests a more robust approach using collections.deque.

The main focus is generalizing this to nwise, which generates tuples of n consecutive items. Three implementations are demonstrated:

Adapting the deque method with maxlen=n.
Using itertools.tee to manage multiple independent iterators.
A recursive solution that builds nwise by repeatedly applying pairwise.

Django: what’s new in 6.0

Django 6.0 introduces four headline features to the web framework:

Template Partials: A new tag allows defining and reusing named fragments within templates, greatly simplifying workflows with libraries like HTMX.
Tasks Framework: A standard, built-in API for defining and enqueuing background tasks, designed to work with various task runner backends (like django-tasks).
Content Security Policy: Native middleware and settings for CSP help prevent XSS attacks, including automatic nonce generation for scripts.
Modern Email API: The internal email system now uses Python’s modern EmailMessage library, fixing bugs and improving MIME support.

A first look at Django’s new background tasks

Django 6.0 introduces django.tasks, a standard API for background tasks, though it intentionally lacks a built-in worker mechanism for execution. While not immediately replacing robust tools like Celery, it unifies task definitions.

The article demonstrates creating a custom database-backed task queue and worker to send notifications via ntfy.sh. It details defining tasks using the @task decorator, enqueuing them, and retrieving results. Although the native framework currently lacks automatic retries and complex orchestration, the specific implementation shown adds these features, suggesting django.tasks successfully standardizes the majority of common background processing use cases.

Python Workers redux: fast cold starts, packages, and a uv-first workflow

Cloudflare has significantly enhanced Python Workers with three major improvements. First, they’ve achieved dramatically faster cold starts using memory snapshots, reducing average start times to 1.027 seconds - 2.4x faster than AWS Lambda without SnapStart and 3x faster than Google Cloud Run. Second, they’ve integrated comprehensive package support using the uv package manager, allowing developers to use any Pyodide-compatible package (both pure Python and those with dynamic libraries). Third, they’ve created a Python-native developer experience with tools like pywrangler for easy deployment and type hint generation.

The technical innovations include sophisticated memory snapshotting that handles entropy challenges and WebAssembly state preservation. These advancements enable Python developers to deploy applications like FastAPI globally in under 2 minutes, with examples ranging from HTML templating with Jinja to WebSocket-based chat rooms using Durable Objects. The improvements also include sharding to reduce cold start frequency and plans for even faster performance and expanded package support.

Automate Python package releases

This article explains how to fully automate Python package releases using GitHub Actions. The author previously handled releases manually but now uses a workflow that automatically runs tests, lints code, builds the package, publishes to PyPI, and creates GitHub releases with changelogs when a new tag is pushed. The process can be simplified further using tbump to handle version bumps and tagging in one command.

Deprecations via warnings don’t work for Python libraries

Seth Larson discusses how Python’s DeprecationWarning system failed for urllib3, a top-3 Python package. Despite emitting warnings for over 3 years about deprecated APIs, major libraries like Kubernetes client, Fastly client, and Airflow were still broken when the APIs were removed. It concludes that DeprecationWarning doesn’t work for Python libraries because warnings are ignored by default. Possible solutions include creating custom warning categories or adopting SemVer with frequent major version releases instead of relying on warnings for API deprecations.

30 things I’ve learned from 30 years as a Python freelancer

After 30 years as a Python freelancer, Reuven Lerner shares 30 lessons: freelancing requires business skills beyond coding, kindness matters more than brilliance, specialization beats generalization, and personal relationships drive success. He emphasizes continuous learning, work-life balance, fair pricing for global access, and the importance of family time. Despite earning less than corporate peers, he values autonomy, minimal meetings, and helping others learn.

Python Typing Survey 2025: Code Quality and Flexibility As Top Reasons for Typing Adoption

The 2025 Typed Python Survey, conducted by JetBrains, Meta, and the Python typing community, gathered 1,241 responses (15% increase from 2024). Key findings:

Adoption: 86% of respondents “always” or “often” use type hints, with highest adoption (93%) among developers with 5-10 years of Python experience. Most respondents have substantial Python and typing expertise.
Top Benefits: Code quality and flexibility are primary reasons for adoption. Developers value optional gradual adoption, improved readability, enhanced IDE tooling, bug prevention, and system expressiveness.
Major Challenges: Third-party library support issues, complexity of advanced features (generics, TypeVar), tooling ecosystem fragmentation, lack of runtime enforcement, verbosity, and integration with legacy code.
Tooling: Mypy remains dominant (58%), but Rust-based checkers like Pyrefly, ty, and Zuban are gaining traction (20% collectively). VS Code leads as the most popular IDE.
Learning Resources: Official documentation is the top resource, followed by blog posts. LLMs are increasingly used for help (400+ users). Reddit has become a key channel for discovering new developments.
Future Needs: Better library type coverage, improved documentation, tooling consistency, TypeScript-inspired features, runtime type enforcement, and enhanced generics support.

Writing a good `CLAUDE.md`

The CLAUDE.md file helps onboard AI coding agents (like Claude Code) to a codebase by providing essential context—what the project does, why it exists, and how to work on it (e.g., tools, tests). However, LLMs ignore irrelevant instructions, so the file should be short (<300 lines), universally applicable, and avoid overloading with commands or style rules. Use progressive disclosure (separate docs for specific tasks) and rely on linters for formatting. Focus on high-level guidance to maximize relevance and performance.

How uv got so fast

The article explains that uv’s speed advantage over pip stems primarily from design decisions rather than just being written in Rust.

Key factors:

Modern standards (PEP 518, 517, 621, 658) enabled static metadata, eliminating the need to execute code to discover dependencies — a “chicken-and-egg” problem that forced pip to run untrusted setup scripts.
Dropped legacy features: uv eliminates support for .egg files, pip.conf, bytecode compilation, and system Python installation. It enforces stricter specs, ignores overly defensive Python version upper bounds, and uses “first-index-wins” for multiple indexes.
Language-agnostic optimizations: Parallel downloads, global caching with hardlinks, HTTP range requests for metadata, Python-free resolution by parsing TOML directly, and the PubGrub resolver algorithm (which applies conflict-driven clause learning from SAT solvers).
Rust-specific benefits: Zero-copy deserialization, thread-level parallelism (avoiding Python’s GIL), no interpreter startup costs, and compact version representation.

Conclusion: uv is fast mainly because it starts fresh with modern assumptions and drops 15 years of legacy compatibility constraints, not because of Rust alone.

Effective harnesses for long-running agents

Anthropic researchers developed a two-part solution to enable AI agents to work effectively across multiple context windows. The approach uses an “initializer agent” to set up the environment on the first run and a “coding agent” that makes incremental progress in each session while leaving clear artifacts for the next. Key components include feature lists, git commits, progress tracking files, and structured testing. This addresses problems where agents try to do too much at once, declare victory prematurely, or leave environments in buggy states between sessions.

Why I Ignore The Spotlight as a Staff Engineer

Lalit Maganti, a Senior Staff Engineer at Google, advocates for a career specifically focused on “stewardship” rather than chasing the “spotlight.” Contrasting his infrastructure role with product engineers who must pivot frequently for executive visibility, Maganti argues for long-term ownership of stable systems.

By building internal developer tools like Perfetto, he operates “bottom-up,” solving deep technical problems for other engineers rather than chasing quarterly business metrics. Maganti asserts that treating engineers as fungible assets destroys context. Conversely, staying with a system unlocks “compounding returns,” enabling systemic innovations—such as his creation of Bigtrace—that require deep historical knowledge to identify.

This long-term reliability grants the political capital to resist hype cycles, such as unnecessary AI integration, thus protecting product integrity. He proposes an alternative path to promotion based on a “Shadow Hierarchy,” where success is measured by how much critical internal teams rely on your tools, rather than executive acclaim. Ultimately, valid high-impact careers in Big Tech can represent a choice for depth, patience, and building lasting foundations over rapid, flashy launches.

2025 LLM Year in Review

In his “2025 LLM Year in Review”, Andrej Karpathy highlights six paradigm shifts that redefined AI:

RLVR (Reinforcement Learning from Verifiable Rewards): Moving beyond RLHF, models now train against objective rewards (e.g., math/code), fostering spontaneous reasoning strategies and “thinking time” scaling laws, pioneered by OpenAI’s o1/o3.
Ghosts vs. Animals: Karpathy describes LLM intelligence as “summoning ghosts”—jagged, non-human entities that excel in verifiable domains but remain vulnerable to simple failures. This has led to a loss of trust in traditional, easily “gamed” benchmarks.
The LLM App Layer: Cursor exemplifies a new “thick” application layer that orchestrates complex LLM workflows, context engineering, and custom GUIs for specific verticals.
Local Agents: Claude Code demonstrated the power of agents living directly on a user’s computer, prioritizing local context and low-latency interaction over cloud-only deployments.
Vibe Coding: AI has enabled “vibe coding,” where natural language allows anyone to create software. This makes code disposable, ephemeral, and accessible to non-professionals.
LLM GUIs: Models like “Gemini Nano Banana” suggest a shift from text-heavy chat to visual/spatial interfaces (infographics, apps), aligning AI output with human visual preferences.

Karpathy concludes that while LLMs are both smarter and dumber than expected, the field remains wide open with vast untapped potential.

Software Engineering in 2026

Progress in AI-powered coding tools, especially using large language models (LLMs), has significantly reduced the time and cost of producing quality code. However, the real bottlenecks in software engineering are shifting from coding to system design, evolution, and operations, which are less affected by AI.

Key trends for 2026:

Infrastructure must be abstracted and self-service, easy for both humans and LLMs, minimizing the need for dedicated infrastructure engineers.
Continuous Integration (CI) tooling grows in importance as AI agents generate more code, pushing for deeper automated testing and verification.
Human-guided abstractions and “system taste” remain crucial; without them, LLM-generated code risks increasing technical debt.
Human code reviews are a new bottleneck, focusing mainly on sensitive or performance-critical changes. Junior engineers need to develop review intuition earlier.
Project timeline estimates will vary more, as some tasks are aided by LLMs while complex, context-heavy work is less suitable for automation.
The cost reduction in coding may tip some SaaS “build vs buy” decisions towards building for larger tech firms, but infrastructure/compliance needs will likely remain outsourced.

Podcasts

🥝 core.py

Calling Things, Part 1

🐍 RealPython Podcast

🥧 Python Bytes Podcast

🦜 Talk Python to me

🍕 Pybites Podcast

🚀 VS Code Insiders Podcast

Repositories

agentskills

This repo contains the specification, documentation, and reference SDK for Agent Skills, which recently goes open.

mistralai/mistral-vibe (Apache-2.0)

Mistral Vibe CLI is an open-source command-line coding assistant powered by Devstral, Mistral’s “next-generation coding model”. It explores, modifies, and executes changes across your codebase using natural language—in your terminal or integrated into your preferred IDE via the Agent Communication Protocol.

raine/workmux (MIT)

workmux is a command-line tool designed to streamline parallel development workflows by integrating Git worktrees directly with tmux windows.

Zero-Friction Parallel Dev: It allows you to spin up isolated development environments instantly. One command creates a new git worktree (a separate checkout of your project) and a dedicated tmux window for it.
Automated Setup: Through a configuration file (.workmux.yaml), you can define exactly how that tmux window should look (e.g., split panes with an editor open in one and a shell in the other) and what commands to run immediately (like installing dependencies).
Environment Management: It handles the tedious parts of creating new environments, such as copying or symlinking .env files or node_modules to the new worktree so you don’t have to set them up manually.
Cleanup: When you are finished with a task, a single merge command merges your branch, deletes the worktree, and closes the tmux window, keeping your workspace clean.
AI Agent Focus: The documentation highlights that this workflow is particularly perfect for running multiple AI agents in parallel without them conflicting with each other.

Have time for some fun?

The Game Awards 2025

The Game Awards (TGA) 2025 was held on December 11th, 2025 at Peacock Theater in Los Angeles, California. Clair Obscur: Expedition 33, with a record-breaking 12 nominations, took home the award for Game of the Year (GOTY) along with 8 other awards. Check out the official website for everything you want to know.

Alright, that concludes the December and this year’s last edition of “This Month for Pythonistas”. Thank you again for reading my posts for this whole year! I hope you enjoy them or find something useful. Happy coding, Merry Christmas 🎄, and see you in 2026! 👋

This Month for Pythonistas - November 2025

Zeyang Lin — Sun, 30 Nov 2025 13:00:00 GMT

from datetime import date

print(date.today().year, date.today().month)
# 2025 11

Welcome back Pythonistas! I’m glad to see you back reading the ninth issue of my “This month for Pythonistas” series which curates the news, articles, tutorials, podcasts, and more Python stuff worth noting in this month.

Before we continue, please note that this blog is synced across the following platforms:

Ready? Let’s get started!

PyCon US 2026 CFP is Open

The 2026 PyCon US call for proposals (CFP) for Talks, Charlas, Tutorials and Posters is open until December 19th, 2025. Don’t miss out on the largest Python conference in the world!

PyCon Ireland 2025

PyCon Ireland this year took place November 15-16 in UCD O’Reilly Hall, Dublin, featuring two talk tracks and two workshop tracks on both days.

20th anniversary of first ever Django release

For the past twenty years, Django has shipped over 440 releases, making it among the most popular and successful Python web frameworks. You can read more about it here.

New Versions

Python 3.15.0 alpha 2

This is the second developer preview of the upcoming Python 3.15 release. It is available for download here.

Django 6.0 RC 1

Django 6.0 release candidate 1 is now available. The provisional release notes can be found here.

Provided no major bugs are discovered that can’t be solved in the next two weeks, Django 6.0 will be released on or around December 3.

pytest 9.0

pytest 9.0 brings significant improvements including native TOML configuration support, a new strict mode for better testing practices, and the long-awaited subtests feature.

Tutorials

DeepLearning.ai’s Jupyter AI: AI Coding in Notebooks by Andrew Ng and Brian Granger

In this course, you’ll build a book research assistant using the Open Library API, and create a stock market data analysis workflow, all with the help of Jupyter AI. You’ll learn how to provide API documentation as context so the LLM generates accurate syntax for code that wasn’t part of its pretraining.

DeepLearning.ai’s Semantic Caching for AI Agents from Redis

In this course, you’ll build a semantic cache that makes your AI agents faster and more cost-effective by recognizing when different questions mean the same thing. For example, when someone asks “How do I get a refund?” and another asks “I want my money back”， your cache will reuse the answer instead of making another API call, reducing the need for redundant model calls.

DeepLearning.ai’s Design, Develop, and Deploy Multi-Agent Systems with CrewAI

Disclaimer: This course contains a small portion of content which requires a paid PRO subscription to access.

Learn how to build multi-agent systems that automate complex, end-to-end workflows. You’ll create intelligent agent teams that plan, reason, and collaborate using tools, memory, and guardrails, and learn how to scale them for production.

RealPython’s Python MarkItDown: Convert Documents Into LLM-Ready Markdown

The MarkItDown library lets you quickly turn PDFs, Office files, images, HTML, audio, and URLs into LLM-ready Markdown. In this tutorial, you’ll compare MarkItDown with Pandoc, run it from the command line, use it in Python code, and integrate conversions into AI-powered workflows.

Build a coding agent with GPT 5.1

In this guide, we’ll use the Agents SDK to build a coding agent that can scaffold a brand-new app from a prompt and refine it through user feedback.

Articles

Why Performance Matters in Python Development

Disclaimer: This article contains promotional content regarding JetBrains products.

The blog from JetBrains emphasizes Python performance optimization as a strategic business imperative, not just technical concern. Despite Python’s interpreted nature and GIL limitations, most bottlenecks stem from code-level inefficiencies. Performance impacts user experience, scalability, infrastructure costs, and development velocity. Key optimization areas include algorithmic improvements, proper data structures, I/O batching, and appropriate parallelism (threading for I/O-bound, multiprocessing for CPU-bound tasks). The article dispels myths about Python being universally slow, emphasizing profiling-driven optimization over intuition.

await is Not a Context Switch: Understanding Python’s Coroutines vs Tasks

This blog post clarifies a critical distinction in Python’s asyncio: unlike JavaScript or C#, awaiting a coroutine does not automatically yield control to the event loop. In Python, await synchronously executes a coroutine until a suspension occurs; true concurrency and interleaving mainly happen with explicitly created Tasks (asyncio.create_task). This means critical sections without internal await statements are atomic relative to the event loop. Understanding this prevents unnecessary locking, as race conditions only occur at specific suspension points, not at every async function call.

__slots__ for optimizing classes

Python classes store instance attributes in a __dict__ dictionary by default, allowing dynamic addition but consuming memory. Defining __slots__ = ('attr1', 'attr2', ...) replaces __dict__ with a fixed, efficient array-like structure. Benefits: restricts attributes (no extras allowed), reduces memory usage (e.g., from 271KB to 176KB for 1M Point objects), and speeds up attribute lookups. Ideal for classes with many instances or frequent access.

Choose the Right Text Pattern Tool: Regex, Pregex, or Pyparsing

This article compares three Python text pattern matching tools: regex (regular expressions), pregex (human-readable regex alternative), and pyparsing (grammar-based parsing). It teaches when to use each tool for extracting emails, phone numbers, and parsing structured data. The guide helps developers choose the right approach for different text processing scenarios in Python.

How to use UUIDv7 in Python, Django and PostgreSQL

This guide explains using UUIDv7 – time-ordered IDs for better index locality than UUIDv4 – in Python 3.14 (uuid.uuid7()), Django 5.2 models, and PostgreSQL 18 (native uuidv7() generation and uuid_extract_timestamp() via GeneratedFields). Covers setup, migrations, client-side (SQLite) vs. DB-side generation, testing, and considerations for other databases like MySQL/Oracle. Recommends masking (UUIDv47) for public APIs to hide timestamps.

Python package managers: uv vs pixi?

This post compares Python package managers uv (fast Rust pip reimplementation for PyPI) and pixi (next-gen conda for PyPI + conda-forge). uv suits scripts, apps, libraries; pixi excels in AI/CUDA/science with compiled deps. Historical evolution: pip → conda binaries → mamba speed → declarative locking. Author’s recommendations: uv for most, pixi for GPU/research, conda+uv for interdependent libs.

Introducing GPT-5.1 for developers

OpenAI has released GPT-5.1 for the API platform, a model designed to balance intelligence and speed for agentic and coding tasks. It features adaptive reasoning, where the model dynamically adjusts thinking time based on task complexity—processing simple requests significantly faster while remaining persistent on difficult problems.

Key updates include:

No Reasoning Mode: A setting for ultra-low latency tasks like tool calling and search, behaving like a standard non-reasoning model but with GPT-5.1’s intelligence base.
Extended Prompt Caching: Supports up to 24-hour cache retention to lower costs and latency for long-context workflows.
New Developer Tools: Introduces apply_patch for reliable, structure-aware code editing and a shell tool for executing local commands.
GPT-5.1 utilizes a more steerable coding personality and outperforms GPT-5 on benchmarks like SWE-bench Verified (76.3%). It is available immediately to developers on paid tiers, with pricing matching GPT-5. Specialized codex versions were also released for agentic coding workflows.
A new era of intelligence with Gemini 3

Google has introduced Gemini 3, its most intelligent and capable AI model to date. Gemini 3 Pro delivers state-of-the-art performance in multimodal reasoning, coding, and long-horizon planning, outperforming previous models on major benchmarks like Humanity’s Last Exam.

Key features include:

Enhanced Reasoning: The model offers deeper nuance and reduced sycophancy. A new Deep Think mode, coming soon to Ultra subscribers, pushes reasoning capabilities even further for complex problem-solving.
Developer Tools: Google launched Antigravity, a new agentic development platform where AI agents can autonomously plan, code, and validate software.
Practical Applications: Gemini 3 helps users learn by synthesizing diverse inputs (like video and text), build complex apps via “vibe coding,” and handle multi-step planning tasks for daily life.
Gemini 3 is available immediately across Google products, including the Gemini app, AI Studio, Vertex AI, and within Google Search’s AI Mode. The release emphasizes robust safety testing and improved resistance to misuse.
ADK architecture: When to use sub-agents versus agents as tools

This blog post compares sub-agents vs. agents as tools in multi-agent AI systems. Agents as tools are stateless, reusable for discrete tasks (e.g., NL2SQL, DB execution) with isolated context. Sub-agents are stateful, collaborative for complex workflows (e.g., data visualization, travel planning) sharing parent context. Decision matrix: Use tools for low-complexity/reusable tasks; sub-agents for high-complexity/stateful processes. Real-world cases include data analysis and trip planning.

The Learning Loop and LLMs

The article argues that software development is fundamentally a learning process, not an assembly line. While LLMs excel at removing friction and generating code, they cannot replace the essential learning loop of observe-experiment-apply. True expertise comes from hands-on experience and understanding, not just AI-generated solutions. LLMs are best used as brainstorming partners, not autonomous builders, to avoid the “maintenance cliff” where systems become unmaintainable due to lack of deep understanding.

why agents DO NOT write most of our code - a reality check

The article provides a reality check on AI coding agents. Despite building AI agents themselves, Octomind finds that most of their code is still written by humans. Through practical experiments, the author reveals that AI agents struggle with maintaining codebase mental models, produce overly verbose code (1000+ line PRs), lack self-reflection about their limitations, and often miss critical issues like transaction handling. While AI is valuable for brainstorming, debugging, and small tasks, the dream of agents writing most production code remains far from reality.

Becoming a Core Developer

Stefanie Molin became a numpydoc core developer by creating a pre-commit hook for docstring validation. Starting from fixing docstrings at a Scikit-Learn sprint, she developed AstValidator using Python’s ast module for static analysis, avoiding code execution. This led to numpydoc-validation (v1.6.0+), with CLI linting and config via pyproject.toml. After PR merge and improvements, she joined as core dev in April 2024.

What caused the large AWS outage?

A major AWS outage on October 20, 2025 was caused by a DynamoDB DNS failure in us-east-1. The 14-hour incident started when race conditions between DNS enactors emptied DynamoDB’s DNS records, making the database appear offline. This cascaded to EC2’s droplet management system, causing capacity shortages and network connectivity issues that took 12+ hours to fully resolve.

Cloudflare outage on November 18, 2025

On November 18, 2025, Cloudflare experienced a significant outage starting at 11:20 UTC that disrupted traffic across its network, causing widespread HTTP 5xx errors for customer websites and impacting services like Workers KV, Access, and the Dashboard.

The outage was not caused by a cyberattack but by an internal configuration error. A change to database permissions caused a query to generate duplicate entries in a “feature file” used by Cloudflare’s Bot Management system. This doubling in file size exceeded a hardcoded memory limit within the core proxy software, causing the system to crash (panic) globally.

Cloudflare engineers initially suspected a DDoS attack but soon identified the corrupt file. They resolved the issue by halting the bad file’s propagation and manually reverting to a known good version. Core traffic began flowing normally by 14:30 UTC, and all systems were fully restored by 17:06 UTC. Cloudflare has apologized and is implementing new safeguards, such as stricter file validation and global kill switches, to prevent future occurrences.

Podcasts

🐍 RealPython Podcast

🥧 Python Bytes Podcast

🦜 Talk Python to me

🍕 Pybites Podcast

🚀 VS Code Insiders Podcast

Repositories

hyperflask (MIT)

hyperflask is a Flask-based (very) opiniated full-stack web framework where all the tech choices have been made. It combines multiple Flask extensions and frontend libraries into a seamless experience.

langchain-ai/deepagents (MIT)

Primarily inspired by Claude Code, deepagents is an agent harness built on langchain and langgraph, which is equipped with a planning tool, a filesystem backend, and the ability to spawn subagents - making them well-equipped to handle complex agentic tasks.

MoonshotAI/kimi-cli (Apache 2.0)

Kimi CLI is yet another command-line agent but built within Python ecosystem unlike other Claude Code-alike tools. Apart from agentic coding, it can also be switched to “shell mode” where you can run (some of) shell commands.

MemMachine (Apache 2.0)

MemMachine is a open-source, “universal” memory layer for AI agents which persists across multiple sessions, agents, and large language models. It provides Python SDK, RESTful API as well as MCP for easy integration with agents.

OpenRouterTeam/python-sdk (Apache 2.0)

This is OpenRouter’s official Python SDK, a type-safe toolkit for building AI applications with access to 300+ language models through a unified API. You can find the docs here.

Have time for some fun?

Golden Joystick Awards 2025

The Golden Joystick Awards revealed its winners for 2025 on November 20th! Congratulations to the winners, especially Clair Obscure Expedition 33 which was crowned the Ultimate Game of the Year (UGOTY) along with other six thophies, for their outstanding contributions to the video game industry!

Alright, that concludes the November Edition of “This Month of Pythonistas”. Thank you again for reading my post. I hope you enjoy it or find something useful. Happy coding and see you in December!

[one-liner] Install Ollama

Zeyang Lin — Wed, 17 Jul 2024 05:33:41 GMT

One-Liner series: Ollama

source: ollama.com

Install on Ubuntu

curl -fsSL https://ollama.com/install.sh | sudo sh

Install a specific version

curl -fsSL https://ollama.com/install.sh | OLLAMA_VERSION=0.2.5 sudo sh

Alternative source (possibly not up-to-date with offical release)

pip install modelscope

modelscope download --model=modelscope/ollama-linux --local_dir ./ollama-linux

cd ollama-linux

chmod +x ./ollama-modelscope-install.sh

./ollama-modelscope-install.sh`

Update on Ubuntu

Run the same command as above

curl -fsSL https://ollama.com/install.sh | sudo sh

Uninstall on Ubuntu

sudo systemctl stop ollama
sudo systemctl disable ollama
sudo rm /etc/systemd/system/ollama.service

sudo rm $(which ollama)

sudo rm -r /usr/share/ollama
sudo userdel ollama
sudo groupdel ollama

MOJO Series #1: Install SDK on UBUNTU

Zeyang Lin — Fri, 08 Sep 2023 10:00:00 GMT

So, THAT 35000-times-faster-than-python language, mojo, released its SDK today. This means you can install Mojo in your own environment and run mojo programs.

And here in this post, I will show you how to do it on Ubuntu.

System Requirements

Ubuntu 20.04 and later
x86-64 CPU and minimum 4 GB RAM
Python 3.8 - 3.10
g++ or clang++ compiler

My environment

Kubuntu 22.04.3
AMD CPU with 16GB RAM
Python 3.10.12
g++ 11.4.0

Install steps

1. Install Modular CLI

# switch to root first
sudo -u root -i

# then run the following command
apt-get install -y apt-transport-https &&
  keyring_location=/usr/share/keyrings/modular-installer-archive-keyring.gpg &&
  curl -1sLf 'https://dl.modular.com/bBNWiLZX5igwHXeu/installer/gpg.0E4925737A3895AD.key' |  gpg --dearmor >> ${keyring_location} &&
  curl -1sLf 'https://dl.modular.com/bBNWiLZX5igwHXeu/installer/config.deb.txt?distro=debian&codename=wheezy' > /etc/apt/sources.list.d/modular-installer.list &&
  apt-get update &&
  apt-get install -y modular

# switch back to normal user
exit

2. Verify `modular` is installed

which modular

/usr/bin/modular

3. Install Mojo SDK

modular auth <YOUR AUTH KEY> && modular install mojo

# Found release for https://packages.modular.com/mojo @ 0.2.1, installing to /home/******/.modular/pkg/packages.modular.com_mojo
# Downloads complete, setting configs...
# Configs complete, running post-install hooks...

..................<OMITTED>

Successfully installed ansiwrap-0.8.4 attrs-23.1.0 certifi-2023.7.22 charset-normalizer-3.2.0 entrypoints-0.4 fastjsonschema-2.18.0 find_libpython-0.3.0 idna-3.4 jsonschema-4.19.0 jsonschema-specifications-2023.7.1 jupyter-core-5.3.1 jupyter_client-8.3.1 nbclient-0.8.0 nbformat-5.9.2 papermill-2.4.0 platformdirs-3.10.0 python-dateutil-2.8.2 pyzmq-25.1.1 referencing-0.30.2 requests-2.31.0 rpds-py-0.10.2 tenacity-8.2.3 textwrap3-0.9.2 tornado-6.3.3 tqdm-4.66.1 traitlets-5.9.0 urllib3-2.0.4
WARNING: Running pip as the 'root' user can result in broken permissions and conflicting behaviour with the system package manager. It is recommended to use a virtual environment instead: https://pip.pypa.io/warnings/venv
Testing `MODULAR_HOME=/home/******/.modular`
* `/home/******/.modular/pkg/packages.modular.com_mojo/bin/mojo`...
TEST: `mojo --help`... OK
TEST: `mojo run --help`... OK
TEST: `mojo build test_mandelbrot.mojo`... OK
TEST: `mojo build test_python.mojo`... OK
TEST: `mojo demangle`... OK
TEST: `mojo format`... OK
TEST: `mojo package`... OK
TEST: `mojo test_mandelbrot.mojo`... OK
TEST: `mojo test_python.mojo`... OK
TEST: `mojo repl`... OK

🔥 Mojo installed! 🔥

Now run the following commands if you are using bash:

echo 'export MODULAR_HOME="/home/******/.modular"' >> ~/.bashrc
echo 'export PATH="/home/******/.modular/pkg/packages.modular.com_mojo/bin:$PATH"' >> ~/.bashrc
source ~/.bashrc

If you are using ZSH, run the following commands:

echo 'export MODULAR_HOME="/home/******/.modular"' >> ~/.zshrc
echo 'export PATH="/home/******/.modular/pkg/packages.modular.com_mojo/bin:$PATH"' >> ~/.zshrc
source ~/.zshrc

Then enter 'mojo' to start the Mojo REPL.

For tool help, enter 'mojo --help'.
For more docs, see https://docs.modular.com/mojo.

4. Add mojo to PATH

# You must replace two <USERNAME> with your own username
echo 'export MODULAR_HOME="/home/<USERNAME>/.modular"' >> ~/.bashrc

echo 'export PATH="/home/<USERNAME>/.modular/pkg/packages.modular.com_mojo/bin:$PATH"' >> ~/.bashrc

source ~/.bashrc

Now verify mojo command is accesible:

which mojo

/home/******/.modular/pkg/packages.modular.com_mojo/bin/mojo

5. Mojo REPL

mojo

Welcome to Mojo! 🔥 Expressions are delimited by a blank line. Type :mojo help for further assistance.

Bonus Round: directory structure

tree $MODULAR_HOME

/home/******/.modular
├── crashdb
│   ├── attachments
│   ├── completed
│   ├── new
│   ├── pending
│   └── settings.dat
├── modular.cfg
└── pkg
    └── packages.modular.com_mojo
        ├── bin
        │   ├── lldb
        │   ├── lldb-argdumper
        │   ├── lldb-server
        │   ├── lldb-vscode
        │   ├── modular-crashpad-handler
        │   ├── mojo
        │   └── mojo-lsp-server
        ├── installed.json
        ├── jupyter
        │   ├── kernel
        │   │   ├── logo-64x64.png
        │   │   ├── logo.svg
        │   │   └── mojokernel.py
        │   └── manage_kernel.py
        ├── lib
        │   ├── libKGENCompilerRTShared.so -> /home/******/.modular/pkg/packages.modular.com_mojo/lib/libKGENCompilerRTShared.so.18git
        │   ├── libKGENCompilerRTShared.so.18git
        │   ├── libKGENCompilerRT-static.a
        │   ├── libLLCLRuntimeGlobals.so -> /home/******/.modular/pkg/packages.modular.com_mojo/lib/libLLCLRuntimeGlobals.so.18git
        │   ├── libLLCLRuntimeGlobals.so.18git
        │   ├── liblldb.so -> /home/******/.modular/pkg/packages.modular.com_mojo/lib/liblldb.so.18.0.0git
        │   ├── liblldb.so.18.0.0git
        │   ├── liblldb.so.18git -> /home/******/.modular/pkg/packages.modular.com_mojo/lib/liblldb.so.18.0.0git
        │   ├── libMojoJupyter.so -> /home/******/.modular/pkg/packages.modular.com_mojo/lib/libMojoJupyter.so.18git
        │   ├── libMojoJupyter.so.18git
        │   ├── libMojoLLDB.so -> /home/******/.modular/pkg/packages.modular.com_mojo/lib/libMojoLLDB.so.18git
        │   ├── libMojoLLDB.so.18git
        │   ├── libMSupportGlobals.so -> /home/******/.modular/pkg/packages.modular.com_mojo/lib/libMSupportGlobals.so.18git
        │   ├── libMSupportGlobals.so.18git
        │   ├── liborc_rt.a
        │   ├── lldb-visualizers
        │   │   ├── lldbDataFormatters.py
        │   │   └── mlirDataFormatters.py
        │   ├── mblack
        │   │   ├── base_library.zip
        │   │   ├── importlib_metadata-6.8.0.dist-info
        │   │   │   ├── INSTALLER
        │   │   │   ├── LICENSE
        │   │   │   ├── METADATA
        │   │   │   ├── RECORD
        │   │   │   ├── top_level.txt
        │   │   │   └── WHEEL
        │   │   ├── libbz2.so.1.0
        │   │   ├── libcrypto.so.1.1
        │   │   ├── lib-dynload
        │   │   │   ├── _asyncio.cpython-38-x86_64-linux-gnu.so
        │   │   │   ├── _bz2.cpython-38-x86_64-linux-gnu.so
        │   │   │   ├── _codecs_cn.cpython-38-x86_64-linux-gnu.so
        │   │   │   ├── _codecs_hk.cpython-38-x86_64-linux-gnu.so
        │   │   │   ├── _codecs_iso2022.cpython-38-x86_64-linux-gnu.so
        │   │   │   ├── _codecs_jp.cpython-38-x86_64-linux-gnu.so
        │   │   │   ├── _codecs_kr.cpython-38-x86_64-linux-gnu.so
        │   │   │   ├── _codecs_tw.cpython-38-x86_64-linux-gnu.so
        │   │   │   ├── _contextvars.cpython-38-x86_64-linux-gnu.so
        │   │   │   ├── _ctypes.cpython-38-x86_64-linux-gnu.so
        │   │   │   ├── _decimal.cpython-38-x86_64-linux-gnu.so
        │   │   │   ├── _hashlib.cpython-38-x86_64-linux-gnu.so
        │   │   │   ├── _json.cpython-38-x86_64-linux-gnu.so
        │   │   │   ├── _lzma.cpython-38-x86_64-linux-gnu.so
        │   │   │   ├── mmap.cpython-38-x86_64-linux-gnu.so
        │   │   │   ├── _multibytecodec.cpython-38-x86_64-linux-gnu.so
        │   │   │   ├── _multiprocessing.cpython-38-x86_64-linux-gnu.so
        │   │   │   ├── _opcode.cpython-38-x86_64-linux-gnu.so
        │   │   │   ├── _posixshmem.cpython-38-x86_64-linux-gnu.so
        │   │   │   ├── _queue.cpython-38-x86_64-linux-gnu.so
        │   │   │   ├── resource.cpython-38-x86_64-linux-gnu.so
        │   │   │   ├── _ssl.cpython-38-x86_64-linux-gnu.so
        │   │   │   ├── termios.cpython-38-x86_64-linux-gnu.so
        │   │   │   └── _uuid.cpython-38-x86_64-linux-gnu.so
        │   │   ├── libexpat.so.1
        │   │   ├── libffi.so.7
        │   │   ├── liblzma.so.5
        │   │   ├── libmpdec.so.2
        │   │   ├── libpython3.8.so.1.0
        │   │   ├── libssl.so.1.1
        │   │   ├── libuuid.so.1
        │   │   ├── libz.so.1
        │   │   ├── mblack
        │   │   └── mblib2to3
        │   │       ├── Grammar.txt
        │   │       ├── __init__.py
        │   │       ├── LICENSE
        │   │       ├── PatternGrammar.txt
        │   │       ├── pgen2
        │   │       │   ├── conv.py
        │   │       │   ├── driver.py
        │   │       │   ├── grammar.py
        │   │       │   ├── __init__.py
        │   │       │   ├── literals.py
        │   │       │   ├── parse.py
        │   │       │   ├── pgen.py
        │   │       │   ├── tokenize.py
        │   │       │   └── token.py
        │   │       ├── pygram.py
        │   │       ├── pytree.py
        │   │       └── README
        │   ├── mojo
        │   │   ├── algorithm.mojopkg
        │   │   ├── autotune.mojopkg
        │   │   ├── base64.mojopkg
        │   │   ├── benchmark.mojopkg
        │   │   ├── builtin.mojopkg
        │   │   ├── complex.mojopkg
        │   │   ├── math.mojopkg
        │   │   ├── memory.mojopkg
        │   │   ├── os.mojopkg
        │   │   ├── python.mojopkg
        │   │   ├── random.mojopkg
        │   │   ├── runtime.mojopkg
        │   │   ├── sys.mojopkg
        │   │   ├── tensor.mojopkg
        │   │   ├── testing.mojopkg
        │   │   ├── time.mojopkg
        │   │   └── utils.mojopkg
        │   └── mojo-repl-entry-point
        ├── licenses
        │   ├── LICENSE
        │   └── Third-Party-Notices
        ├── modular.cfg
        ├── root.json
        ├── scripts
        │   └── post-install
        │       ├── install-dependencies.sh
        │       ├── pick_python.py
        │       ├── requirements.txt
        │       └── self-test.py
        ├── share
        │   └── man
        │       └── man1
        │           ├── mojo.1
        │           ├── mojo-build.1
        │           ├── mojo-demangle.1
        │           ├── mojo-doc.1
        │           ├── mojo-format.1
        │           ├── mojo-package.1
        │           ├── mojo-repl.1
        │           └── mojo-run.1
        ├── snapshot.json
        ├── targets.json
        ├── test
        │   ├── test_format.mojo
        │   ├── test_jupyter.ipynb
        │   ├── test_mandelbrot.mojo
        │   ├── test_package
        │   │   └── __init__.mojo
        │   ├── test_package_user.mojo
        │   └── test_python.mojo
        ├── timestamp.json
        └── VERSION

26 directories, 133 files

References

Modular Developer Console

MOJO 系列第一篇: 在 Ubuntu 环境下安装本地 SDK

Zeyang Lin — Fri, 08 Sep 2023 10:00:00 GMT

那个号称 比 Python 快 35000倍 的 Mojo 语言，今天终于开放了 SDK 的下载。就是说，你可以在自己的本地环境安装 Mojo 并运行 Mojo 程序了。

那么这篇文章是用来记录在 Ubuntu 环境下如何安装 SDK。

首先来看看前置条件－－官方的系统需求

System Requirements

Ubuntu 20.04 and later
x86-64 CPU and minimum 4 GB RAM
Python 3.8 - 3.10
g++ or clang++ compiler

并无苛刻之处，都2023年了这些应该都是基础配置了吧。（除非你不用 Ubuntu 系列的 Linux）

那我自己的环境如下

My environment

Kubuntu 22.04.3
AMD CPU with 16GB RAM
Python 3.10.12
g++ 11.4.0

然后你需要在 Modular 网站（https://developer.modular.com/download）上面用邮箱注册一个帐号，来获得你的 AUTHKEY 。这个 KEY 是后面步骤用来验证你的身份的。图中的 MODULAR_AUTH= 后面的部分就是你的 AUTHKEY。

满足了官方需求后，下面就是一步一步安装了。需要注意的是你似乎是需要魔法才能成功完成下面的步骤。

安装步骤

1. 安装 Modular CLI

Modular CLI 是安装 mojo 的前置条件

# 首先切换到 root 用户：
sudo -u root -i

# 然后执行以下命令：
apt-get install -y apt-transport-https &&
  keyring_location=/usr/share/keyrings/modular-installer-archive-keyring.gpg &&
  curl -1sLf 'https://dl.modular.com/bBNWiLZX5igwHXeu/installer/gpg.0E4925737A3895AD.key' |  gpg --dearmor >> ${keyring_location} &&
  curl -1sLf 'https://dl.modular.com/bBNWiLZX5igwHXeu/installer/config.deb.txt?distro=debian&codename=wheezy' > /etc/apt/sources.list.d/modular-installer.list &&
  apt-get update &&
  apt-get install -y modular

# 然后切换回你自己的普通用户：
exit

2.验证 `modular` 已经安装

在命令行执行：

which modular

如果有下面的输出则表明modular安装成功

/usr/bin/modular

如果没有任何输出，那你可能是需要魔法了。

3.安装 Mojo SDK

modular安装好后，就可以安装mojo了。

在命令行执行：

# 把下面的 <YOUR AUTH KEY> 替换成你自己的 key
modular auth <YOUR AUTH KEY> && modular install mojo

等待时间可能会比较久。。。下面就是输出，可以看到它还会安装很多 python 库到系统的 python 环境里。。。

# Found release for https://packages.modular.com/mojo @ 0.2.1, installing to /home/******/.modular/pkg/packages.modular.com_mojo
# Downloads complete, setting configs...
# Configs complete, running post-install hooks...

< 中间省略掉 >

Successfully installed ansiwrap-0.8.4 attrs-23.1.0 certifi-2023.7.22 charset-normalizer-3.2.0 entrypoints-0.4 fastjsonschema-2.18.0 find_libpython-0.3.0 idna-3.4 jsonschema-4.19.0 jsonschema-specifications-2023.7.1 jupyter-core-5.3.1 jupyter_client-8.3.1 nbclient-0.8.0 nbformat-5.9.2 papermill-2.4.0 platformdirs-3.10.0 python-dateutil-2.8.2 pyzmq-25.1.1 referencing-0.30.2 requests-2.31.0 rpds-py-0.10.2 tenacity-8.2.3 textwrap3-0.9.2 tornado-6.3.3 tqdm-4.66.1 traitlets-5.9.0 urllib3-2.0.4
。。。。。。。
Testing `MODULAR_HOME=/home/******/.modular`
* `/home/******/.modular/pkg/packages.modular.com_mojo/bin/mojo`...
TEST: `mojo --help`... OK
TEST: `mojo run --help`... OK
TEST: `mojo build test_mandelbrot.mojo`... OK
TEST: `mojo build test_python.mojo`... OK
TEST: `mojo demangle`... OK
TEST: `mojo format`... OK
TEST: `mojo package`... OK
TEST: `mojo test_mandelbrot.mojo`... OK
TEST: `mojo test_python.mojo`... OK
TEST: `mojo repl`... OK

🔥 Mojo installed! 🔥

Now run the following commands if you are using bash:

echo 'export MODULAR_HOME="/home/******/.modular"' >> ~/.bashrc
echo 'export PATH="/home/******/.modular/pkg/packages.modular.com_mojo/bin:$PATH"' >> ~/.bashrc
source ~/.bashrc

If you are using ZSH, run the following commands:

echo 'export MODULAR_HOME="/home/******/.modular"' >> ~/.zshrc
echo 'export PATH="/home/******/.modular/pkg/packages.modular.com_mojo/bin:$PATH"' >> ~/.zshrc
source ~/.zshrc

Then enter 'mojo' to start the Mojo REPL.

For tool help, enter 'mojo --help'.
For more docs, see https://docs.modular.com/mojo.

4.添加 `mojo` 到 `PATH`

# 把下面两个 <USERNAME> 替换成你自己的用户名
echo 'export MODULAR_HOME="/home/<USERNAME>/.modular"' >> ~/.bashrc

echo 'export PATH="/home/<USERNAME>/.modular/pkg/packages.modular.com_mojo/bin:$PATH"' >> ~/.bashrc

# 重新加载 .bachrc 令改动生效
source ~/.bashrc

现在验证 mojo 命令是否已经能用了:

which mojo

若输出为下面内容则表示安装成功：

/home/******/.modular/pkg/packages.modular.com_mojo/bin/mojo

5. 体验 Mojo REPL

在命令行执行：

mojo

就进到了 mojo 的互动编程环境。熟悉 Python 或其它类似语言的小伙伴对这个一定不陌生。

Welcome to Mojo! 🔥 Expressions are delimited by a blank line. Type :mojo help for further assistance.

那么至此 mojo 的基础开发环境就已经搭建好了，在下一篇文章中我会记录如何运行最基础的 “Hello world” 程序。

Bonus Round: 看看 mojo 目录的文件夹结构

tree $MODULAR_HOME

/home/******/.modular
├── crashdb
│   ├── attachments
│   ├── completed
│   ├── new
│   ├── pending
│   └── settings.dat
├── modular.cfg
└── pkg
    └── packages.modular.com_mojo
        ├── bin
        │   ├── lldb
        │   ├── lldb-argdumper
        │   ├── lldb-server
        │   ├── lldb-vscode
        │   ├── modular-crashpad-handler
        │   ├── mojo
        │   └── mojo-lsp-server
        ├── installed.json
        ├── jupyter
        │   ├── kernel
        │   │   ├── logo-64x64.png
        │   │   ├── logo.svg
        │   │   └── mojokernel.py
        │   └── manage_kernel.py
        ├── lib
        │   ├── libKGENCompilerRTShared.so -> /home/******/.modular/pkg/packages.modular.com_mojo/lib/libKGENCompilerRTShared.so.18git
        │   ├── libKGENCompilerRTShared.so.18git
        │   ├── libKGENCompilerRT-static.a
        │   ├── libLLCLRuntimeGlobals.so -> /home/******/.modular/pkg/packages.modular.com_mojo/lib/libLLCLRuntimeGlobals.so.18git
        │   ├── libLLCLRuntimeGlobals.so.18git
        │   ├── liblldb.so -> /home/******/.modular/pkg/packages.modular.com_mojo/lib/liblldb.so.18.0.0git
        │   ├── liblldb.so.18.0.0git
        │   ├── liblldb.so.18git -> /home/******/.modular/pkg/packages.modular.com_mojo/lib/liblldb.so.18.0.0git
        │   ├── libMojoJupyter.so -> /home/******/.modular/pkg/packages.modular.com_mojo/lib/libMojoJupyter.so.18git
        │   ├── libMojoJupyter.so.18git
        │   ├── libMojoLLDB.so -> /home/******/.modular/pkg/packages.modular.com_mojo/lib/libMojoLLDB.so.18git
        │   ├── libMojoLLDB.so.18git
        │   ├── libMSupportGlobals.so -> /home/******/.modular/pkg/packages.modular.com_mojo/lib/libMSupportGlobals.so.18git
        │   ├── libMSupportGlobals.so.18git
        │   ├── liborc_rt.a
        │   ├── lldb-visualizers
        │   │   ├── lldbDataFormatters.py
        │   │   └── mlirDataFormatters.py
        │   ├── mblack
        │   │   ├── base_library.zip
        │   │   ├── importlib_metadata-6.8.0.dist-info
        │   │   │   ├── INSTALLER
        │   │   │   ├── LICENSE
        │   │   │   ├── METADATA
        │   │   │   ├── RECORD
        │   │   │   ├── top_level.txt
        │   │   │   └── WHEEL
        │   │   ├── libbz2.so.1.0
        │   │   ├── libcrypto.so.1.1
        │   │   ├── lib-dynload
        │   │   │   ├── _asyncio.cpython-38-x86_64-linux-gnu.so
        │   │   │   ├── _bz2.cpython-38-x86_64-linux-gnu.so
        │   │   │   ├── _codecs_cn.cpython-38-x86_64-linux-gnu.so
        │   │   │   ├── _codecs_hk.cpython-38-x86_64-linux-gnu.so
        │   │   │   ├── _codecs_iso2022.cpython-38-x86_64-linux-gnu.so
        │   │   │   ├── _codecs_jp.cpython-38-x86_64-linux-gnu.so
        │   │   │   ├── _codecs_kr.cpython-38-x86_64-linux-gnu.so
        │   │   │   ├── _codecs_tw.cpython-38-x86_64-linux-gnu.so
        │   │   │   ├── _contextvars.cpython-38-x86_64-linux-gnu.so
        │   │   │   ├── _ctypes.cpython-38-x86_64-linux-gnu.so
        │   │   │   ├── _decimal.cpython-38-x86_64-linux-gnu.so
        │   │   │   ├── _hashlib.cpython-38-x86_64-linux-gnu.so
        │   │   │   ├── _json.cpython-38-x86_64-linux-gnu.so
        │   │   │   ├── _lzma.cpython-38-x86_64-linux-gnu.so
        │   │   │   ├── mmap.cpython-38-x86_64-linux-gnu.so
        │   │   │   ├── _multibytecodec.cpython-38-x86_64-linux-gnu.so
        │   │   │   ├── _multiprocessing.cpython-38-x86_64-linux-gnu.so
        │   │   │   ├── _opcode.cpython-38-x86_64-linux-gnu.so
        │   │   │   ├── _posixshmem.cpython-38-x86_64-linux-gnu.so
        │   │   │   ├── _queue.cpython-38-x86_64-linux-gnu.so
        │   │   │   ├── resource.cpython-38-x86_64-linux-gnu.so
        │   │   │   ├── _ssl.cpython-38-x86_64-linux-gnu.so
        │   │   │   ├── termios.cpython-38-x86_64-linux-gnu.so
        │   │   │   └── _uuid.cpython-38-x86_64-linux-gnu.so
        │   │   ├── libexpat.so.1
        │   │   ├── libffi.so.7
        │   │   ├── liblzma.so.5
        │   │   ├── libmpdec.so.2
        │   │   ├── libpython3.8.so.1.0
        │   │   ├── libssl.so.1.1
        │   │   ├── libuuid.so.1
        │   │   ├── libz.so.1
        │   │   ├── mblack
        │   │   └── mblib2to3
        │   │       ├── Grammar.txt
        │   │       ├── __init__.py
        │   │       ├── LICENSE
        │   │       ├── PatternGrammar.txt
        │   │       ├── pgen2
        │   │       │   ├── conv.py
        │   │       │   ├── driver.py
        │   │       │   ├── grammar.py
        │   │       │   ├── __init__.py
        │   │       │   ├── literals.py
        │   │       │   ├── parse.py
        │   │       │   ├── pgen.py
        │   │       │   ├── tokenize.py
        │   │       │   └── token.py
        │   │       ├── pygram.py
        │   │       ├── pytree.py
        │   │       └── README
        │   ├── mojo
        │   │   ├── algorithm.mojopkg
        │   │   ├── autotune.mojopkg
        │   │   ├── base64.mojopkg
        │   │   ├── benchmark.mojopkg
        │   │   ├── builtin.mojopkg
        │   │   ├── complex.mojopkg
        │   │   ├── math.mojopkg
        │   │   ├── memory.mojopkg
        │   │   ├── os.mojopkg
        │   │   ├── python.mojopkg
        │   │   ├── random.mojopkg
        │   │   ├── runtime.mojopkg
        │   │   ├── sys.mojopkg
        │   │   ├── tensor.mojopkg
        │   │   ├── testing.mojopkg
        │   │   ├── time.mojopkg
        │   │   └── utils.mojopkg
        │   └── mojo-repl-entry-point
        ├── licenses
        │   ├── LICENSE
        │   └── Third-Party-Notices
        ├── modular.cfg
        ├── root.json
        ├── scripts
        │   └── post-install
        │       ├── install-dependencies.sh
        │       ├── pick_python.py
        │       ├── requirements.txt
        │       └── self-test.py
        ├── share
        │   └── man
        │       └── man1
        │           ├── mojo.1
        │           ├── mojo-build.1
        │           ├── mojo-demangle.1
        │           ├── mojo-doc.1
        │           ├── mojo-format.1
        │           ├── mojo-package.1
        │           ├── mojo-repl.1
        │           └── mojo-run.1
        ├── snapshot.json
        ├── targets.json
        ├── test
        │   ├── test_format.mojo
        │   ├── test_jupyter.ipynb
        │   ├── test_mandelbrot.mojo
        │   ├── test_package
        │   │   └── __init__.mojo
        │   ├── test_package_user.mojo
        │   └── test_python.mojo
        ├── timestamp.json
        └── VERSION

26 directories, 133 files

本文参考了

Modular Developer Console

My Visual Studio Code extensions for python & other development

Zeyang Lin — Mon, 31 May 2021 01:47:01 GMT

Python

ms-python.python

Pylance

ms-python.vscode-pylance

Black Formatter

ms-python.black-formatter

Flake8

ms-python.flake8

isort

ms-python.isort

Jupyter

ms-toolsai.jupyter

Data Wrangler

ms-toolsai.datawrangler

Mypy Type Checker

ms-python.mypy-type-checker

Pylint

ms-python.pylint

Ruff

charliermarsh.ruff

ty

astral-sh.ty

autoDocstring: VSCode Python Docstring Generator

njpwerner.autodocstring

Python Indent

kevinrose.vsc-python-indent

Sublime Text Keymap and Settings Importer

ms-vscode.sublime-keybindings note that it automatically imports sublime key bindings after installation, although it also prompts you to explicitly import a sublime settings file (while could be ignored).

Docker

ms-azuretools.vscode-docker

Kubernetes

ms-kubernetes-tools.vscode-kubernetes-tools

Remote - SSH

ms-vscode-remote.remote-ssh

Remote - Containers

ms-vscode-remote.remote-containers

GitLens

eamodio.gitlens

vscode-json

andyyaldoo.vscode-json

YAML

redhat.vscode-yaml

Even Better TOML

tamasfe.even-better-toml

Rainbow CSV

mechatroner.rainbow-csv

Prettier - Code formatter

esbenp.prettier-vscode

Prettier SQL VSCode

inferrinizzard.prettier-sql-vscode

SQL Formatter

adpyke.vscode-sql-formatter

Mojo

modular-mojotools.vscode-mojo

Amazon Q

amazonwebservices.amazon-q-vscode

Baidu Comate

baiducomate.comate

Cline

saoudrizwan.claude-dev

CodeGeeX

aminer.codegeex

Windsurf Plugin (formerly Codeium)

codeium.codeium

Gemini Code Assist

google.geminicodeassist

Google Cloud Code

googlecloudtools.cloudcode

Github Copilot

github.copilot

Github Copilot Chat

github.copilot-chat

iFlyCode

anhuizhuojiantechnology.iflycode

TONGYI Lingma

alibaba-cloud.tongyi-lingma

Trae AI(formerly MarsCode): Coding Assistant

marscode.marscode-extension

GitHub Theme

github.github-vscode-theme

Ai on BlueberryPy

This Month for Pythonistas - September 2026

Events & Social

New Versions

Tutorials

deeplearning.ai’s Building Adaptive AI Agents by Oracle

deeplearning.ai’s Building AI Assistants with On-Device Memory by Qdrant

RealPython’s How to Write an AGENTS.md File for a Python Project

RealPython’s How to Review AI-Generated Python Code Efficiently

Articles

Podcasts

🐍 RealPython Podcast

🍕 Python Bytes Podcast

📣 Talk Python to me

Repositories

BruceEckel/ThinkingInPython (CC BY-NC-ND 4.0)

reflex-dev/xy (Apache 2.0)

gi0baro/tonio (BSD-3-Clause)

Have time for some fun?

This Month for Pythonistas - August 2026

Events & Social

New Versions

Tutorials

deeplearning.ai’s AI Coding Workflows: From Cloud to Local by Paul Everitt

RealPython’s How to Integrate OpenTelemetry With a FastAPI App

Articles

Podcasts

🐍 RealPython Podcast

🍕 Python Bytes Podcast

📣 Talk Python to me

Repositories

RyanCodrai/turbovec (MIT)

Have time for some fun?

Gamescom 2026

This Month for Pythonistas - July 2026

Events & Social

EuroPython 2026

New Versions

Tutorials

Deeplearning.ai’s AI Code Reviews

RealPython’s LangGraph Tutorial: Build Stateful AI Agents in Python

RealPython’s CrewAI in Python: Coordinating Teams of AI Agents

Articles

Podcasts

🥝 core.py

🐍 RealPython Podcast

🍕 Python Bytes Podcast

📣 Talk Python to me

🚀 VS Code Insiders Podcast

Repositories

This Month for Pythonistas - June 2026

Events & Social

EuroPython 2026 schedule is revealed 📣

New Versions

Tutorials

DeepLearning.ai’s Fast & Efficient LLM Inference with vLLM from Red Hat

DeepLearning.ai’s Voice for AI Agents and Applications from Vocal Bridge

Microsoft’s Rust for Python Programmers

Articles