Pycon 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! 👋

[PyCon China 2026] It's Time to Learn (Some) Rust — Starting from a Faster pip install

Zeyang Lin — Sat, 05 Sep 2026 07:10:00 GMT

It’s Time to Learn (Some) Rust — Starting from a Faster pip install

Hi everyone! This post is adapted from my lightning talk at PyCon China 2026, “It’s Time to Learn (Some) Rust — Starting from a Faster pip install”. What the subtitle means — I’ll get to that in a moment.

Whether you’ve noticed it or not, Rust is already part of your daily life as a Python developer. uv, ruff, and pyrefly — Meta’s open-source type checker — this new generation of Python tooling is all written in Rust. And plenty of Python libraries are bringing Rust in as well: pydantic v2 rewrote its validation core in Rust and got 17x faster; polars’ entire engine is Rust; cryptography uses it to harden its core. So Rust stopped being “the language next door” a long time ago — it’s hiding inside the dependencies of every pip install you run.

Even CPython’s own source code may soon include Rust. Look at the timeline: in November 2025, the pre-PEP discussion thread opened; in March 2026, the forked CPython project’s CI builds went green on all platforms; and at PyCon US 2026 in May, the working group unveiled zlib-py as the first planned pilot module — a drop-in alternative to the existing zlib module, with decompression running 3 to 6 times faster. If it lands, every pip install you run from then on will decompress faster. That’s where the subtitle comes from.

The bad news: the PEP originally planned for July has slipped. The good news: the reason is nothing external — the design details of the internal Rust API simply deserve to be worked through slowly and carefully. It’s a slip, not a stall. Their target is Python 3.16, in 2027.

So next, let’s see how simple getting started with Rust can be. It’s like the old joke about putting an elephant into a fridge — three steps in total.

Step one: install maturin with uv, then run maturin init — and a Rust project is initialized, ready to be packaged straight into a Python wheel.

Step two: in lib.rs, write a function that computes the n-th Fibonacci number. Only two macros in this code really matter: #[pyfunction] exposes the Rust function to Python, and #[pymodule] registers it as a Python module. The iterative logic in between is essentially the usual way you’d compute Fibonacci in Python — even with no Rust background, you can follow the gist.

Step three: maturin develop. That single command compiles the Rust package, builds a wheel, and installs it into your current Python virtual environment — building, packaging, and installation all in one go, an experience nearly identical to a pure-Python toolchain. Then it’s back to Python: import fibonacci_rs, call fibonacci(88), and the 88th Fibonacci number comes right out.

One sentence to sum it up: Python handles the orchestration; Rust does the computing.

Now, some of you may feel that computing Fibonacci numbers is a bit too simple — barely a step above Hello World.

So let’s look at a somewhat more involved example: the Julia set. In short: take every point in the complex plane, repeatedly apply z = z² + c (with c a fixed complex number), and see which points never fly off to infinity (modulus above a threshold).

In my concrete example, the canvas is 1000×1000 — one million points in total, each iterated at most 300 times. In the figure, the black areas are points that escaped quickly; the brighter the region, the more iterations it took to escape; and the white, snowflake-shaped region in the middle marks points that still hadn’t escaped after 300 iterations. This is a CPU-bound task — precisely the territory where Python is considered relatively weak.

We start with the pure-Python version: an honest, plain double loop. A run of line_profiler makes the picture stark: this one function devours 96.1% of the program’s total time, while the two list operations above it — each executed a million times — account for just 1.4% and 1.5% respectively.

Still using maturin, we write a Rust function, calculate_z_serial, that mirrors the pure-Python function roughly one-to-one in logic.

Once it’s written, the Python script needs exactly one added import line and one changed function name — that’s it. From the caller’s point of view, the function signature and behavior are completely unchanged.

Now we run line_profiler again: the function’s share of runtime drops from 96% straight down to 18% — the biggest time sinks are now Python’s for loops and list operations — and the script’s total runtime falls from 3.008 seconds to 0.144 seconds, a speedup of more than 20x. And that’s with a faithful serial port of the original; bring in Rayon for multithreaded parallelism, and the speedup tops 100x.

If, after these two examples, you’d like to try building something in Rust, it’s worth first understanding the four mindset hurdles that lie between writing Python and writing Rust.

First, from recommended explicitness to enforced explicitness: Python’s “explicit is better than implicit” is advice; Rust makes it law — mutating data requires declaring mut, match must be exhaustive, and if you don’t comply, it refuses to compile.

Second, from referencing data to owning it: in Python, assignment is sticking a name tag on an object — share it freely, and the GC cleans up. In Rust, every value has exactly one owner, and whether it’s moved or borrowed is checked with total clarity at compile time.

Third, from EAFP to LBYL — from “easier to ask forgiveness than permission” to “look before you leap”: Rust writes “can this fail?” into the types. With Option and Result, you can’t touch the value without checking it first.

Fourth, from the GIL to real concurrency: data races become compile errors — if your program compiles, it is guaranteed free of data races.

Here’s a reference roadmap for learning Rust, in four stages.

Stage one, syntax bridging — with a Python foundation, you’ll get up to speed quickly.

Stage two is the climb: ownership, borrowing, error handling, traits, closures — possibly the most painful stretch of the entire journey, but push through it and the change is qualitative.

Stage three, concurrency. std::thread has you writing real multithreaded code; shared mutable state gets the standard Arc-plus-Mutex combo; and whether data may cross thread boundaries is policed by the compiler through Send/Sync. Want to keep it easy? Rayon turns a loop into data-parallel execution with one line; for I/O-bound concurrency, there’s tokio, the async runtime.

Last and most important: hands-on practice. Use maturin to rewrite a hot function from your own project — profile to locate it, test for parity, benchmark to compare — closing the loop.

As we all know, writing code while you learn is one of the most effective ways to surface problems and consolidate knowledge. These are the three tools I found most helpful as a beginner: Rustlings — around ninety bite-sized exercises straight from the official project, a few minutes each, running locally; and Codewars and LeetCode, which both let you solve problems in Rust directly. Re-solving problems you previously did in Python — this time in Rust — makes the differences between the two languages far easier to internalize.

So does this mean all your Python code should become Rust? Before you start, remember: profiling first — confirm the bottleneck before talking about a rewrite. Don’t go on a hunch.

Good candidates for a rewrite: CPU-bound modules with clear boundaries that process untrusted input; I/O-bound code and glue code can often stay as they are.

Before you dive in, also look at the alternatives: a better algorithm, a free-threaded build, an existing third-party library — or Cython, Numba, or GPU acceleration. Any of these may be the better deal.

Of course, real-world decisions are more complicated — team skills and migration cost come into play, among other factors. And remember this line: Rust is not a “press for speed” button — speed has always been the reward for choosing the right problem.

If you still feel Rust is too hard to learn, consider it from another angle: even if you never write production-grade Rust, the time is not wasted. Explicit types, ownership, explicit error handling, exhaustive matching — these habits of mind transfer back and make your Python more rigorous.

OK, to wrap up. Rust is not Python’s rival — it’s Python’s partner: Python for orchestration, Rust for speed and safety. And learning Rust is more than an investment in personal skills: judging by the progress of Rust for CPython, it may be your ticket to contributing to CPython. The next Rust for CPython contributor might well be you, reading this article right now.

Of course, this talk would not exist without the valuable material left behind by pioneers in the community — Microsoft’s Rust for Python Programmers course, plus several excellent talks and articles, all listed below. My thanks to all of them.

Microsoft — Rust for Python Programmers (open course)
Daroc Alden — “Eventual Rust in CPython”
Bob Belderbos — “Learning Rust Made Me a Better Python Developer”
Daniel Szoke — “Why You, a Python Developer, Should Learn Rust”
Emma Smith — “Rust for CPython: Making Python Safer and More Robust for Everyone”
Micha Gorelick & Ian Ozsvald — High Performance Python, 2nd Edition

That’s the whole talk. The demo code is on GitHub, and if you’re interested, you’re welcome to find me on any of these platforms to keep the conversation going. Thanks for reading!

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! 👋

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! 👋

Pycon 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?

[PyCon China 2026] It's Time to Learn (Some) Rust — Starting from a Faster pip install

It’s Time to Learn (Some) Rust — Starting from a Faster pip install

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

Podcasts

🐍 RealPython Podcast

🍕 Python Bytes Podcast

📣 Talk Python to me

Repositories

LvcidPsyche/auto-browser (MIT)

NVIDIA/SkillSpector (Apache-2.0)

microsoft/coreutils (MIT)

Have time for some fun?

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

Summer Game Fest

This Month for Pythonistas - May 2026

Events & Social

PyCon US 2026

New Versions

Tutorials

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

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

Articles