Linux on BlueberryPy

[one-liner] Install OpenCode

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

One-Liner series: OpenCode

Install on Linux, macOS

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

Install on Windows

Install with npm

npm install -g opencode-ai

Install with chocolatey

choco install opencode

Verify installation

opencode --version

Update

opencode upgrade

[one-liner] Install Bun

Zeyang Lin — Sat, 13 Jun 2026 08:20:00 GMT

One-Liner series: Bun

source: Bun docs

Install on Linux and macOS

curl -fsSL https://bun.com/install | bash

Install on Windows (PowerShell)

powershell -c "irm bun.sh/install.ps1|iex"

Update

bun upgrade

[one-liner] Install pnpm

Zeyang Lin — Thu, 11 Jun 2026 08:20:00 GMT

One-Liner series: pnpm

source: pnpm docs

Install on POSIX systems (except Intel Macs (darwin-x64))

curl -fsSL https://get.pnpm.io/install.sh | sh -

Install on Windows (PowerShell)

Invoke-WebRequest https://get.pnpm.io/install.ps1 -UseBasicParsing | Invoke-Expression

Update

pnpm self-update

This Month for Pythonistas - April 2026

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

from datetime import date

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

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

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

Ready? Let’s get started!

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

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

DjangoCon Europe 2026

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

Introducing GPT‑5.5

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

Introducing Claude Opus 4.7

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

Qwen3.6-Plus: Towards Real World Agents

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

GLM-5.1: Towards Long-Horizon Tasks

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

Kimi K2.6: Advancing Open-Source Coding

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

The next evolution of the Agents SDK

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

New Versions

Python 3.15.0a8, 3.14.4 and 3.13.13 are out!

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

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

Tutorials

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

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

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

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

DeepLearning.ai’s Building Multimodal Data Pipelines from Snowflake

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

RealPython’s Variables in Python: Usage and Best Practices

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

Articles

Cutting Python Web App Memory Over 31%

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

Python: introducing profiling-explorer

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

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

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

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

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

Building a Python Library in 2026

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

Why pylock.toml includes digital attestations

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

Continual learning for AI agents

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

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

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

Learning Rust Made Me a Better Python Developer

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

What every dev should know about AI sandboxes

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

Long-running Agents

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

Scaling Managed Agents: Decoupling the brain from the hands

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

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

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

Managing context in long-run agentic applications

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

Components of A Coding Agent

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

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

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

All your agents are going async

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

Why we’re rethinking cache for the AI era

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

Your harness, your memory

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

Oh Memories, Where’d You Go

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

The Spec Layer

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

I Still Prefer MCP Over Skills

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

The Beginning of Programming as We’ll Know It

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

The Cult Of Vibe Coding Is Insane

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

Claude Is Not Your Architect. Stop Letting It Pretend.

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

Podcasts

🥝 core.py

Episode 29: Is CPython developed with AI now?

🐍 RealPython Podcast

🥧 Python Bytes Podcast

🦜 Talk Python to me

🚀 VS Code Insiders Podcast

Episode 21: Inside The Agent Loop with Pierce Boggan

Repositories

NousResearch/hermes-agent (MIT)

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

dropseed/plain (BSD-3)

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

smelloscope/smello (MIT)

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

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 April Edition of “This Month for Pythonistas”. Thank you again for reading my post. I hope you enjoy it or find something useful. Happy coding and see you in May! 👋

This Month for Pythonistas - March 2026

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

from datetime import date

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

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

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

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

Ready? Let’s get started!

OpenAI acquires Astral

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

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

PyCon US 2026 Schedule Revealed

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

The Python Insider Blog Has Moved!

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

Guido van Rossum Interviews Thomas Wouters

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

Guido van Rossum Interviews Brett Cannon

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

Py AI Conference

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

Gemini 3.1 Flash-Lite: Built for intelligence at scale

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

Gemini Embedding 2: Our first natively multimodal embedding model

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

Introducing GPT‑5.4

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

MiniMax M2.7: Early Echoes of Self-Evolution

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

New Versions

Python 3.15.0 alpha 7

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

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

Tutorials

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

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

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

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

Articles

Thoughts on OpenAI acquiring Astral and uv/ruff/ty

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

Python 3.15’s JIT is now back on track

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

The Optimization Ladder

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

When to make a class in Python

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

Invent your own comprehensions in Python

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

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

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

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

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

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

Reinventing Python’s AsyncIO

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

What Python’s asyncio primitives get wrong about shared state

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

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

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

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

CLI subcommands with lazy imports

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

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

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

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

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

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

Python Type Checker Comparison: Typing Spec Conformance

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

Rewriting a 20-year-old Python library

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

Replacing tox with UV

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

Key features of UV for testing include:

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

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

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

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

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

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

Building shared coding guidelines for AI (and people too)

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

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

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

AI Coding is Gambling

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

Is AI Killing Software Engineering Jobs?

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

Reports of code’s death are greatly exaggerated

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

Read Less, Steer More

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

“Design Me a Highly Resilient Database”

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

Podcasts

🐍 RealPython Podcast

🥧 Python Bytes Podcast

🦜 Talk Python to me

🍕 Pybites Podcast

#218: Why Python developers are learning Rust

🚀 VS Code Insiders Podcast

Episode 20: Autopilot Mode with Justin Chen

Repositories

agentscope-ai/ReMe (Apache-2.0)

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

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

alibaba/OpenSandbox (Apache-2.0)

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

NVIDIA/OpenShell (Apache-2.0)

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

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

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

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 March Edition of “This Month for Pythonistas”. Thank you again for reading my post. I hope you enjoy it or find something useful. Happy coding and see you next month! 👋

This Month for Pythonistas - February 2026

Zeyang Lin — Sat, 28 Feb 2026 13:00:00 GMT

from datetime import date

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

Welcome back Pythonistas! This is the February 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!

Python Unplugged

Python Unplugged is a free online conference bringing together the leading voices of the Python community. It would be live on Youtube on 4th of March, 2026 from 11:00 am to 6:30 pm CET.

Introducing Claude Opus 4.6

Anthropic has released Claude Opus 4.6, its “most capable” AI model yet. The new flagship significantly improves coding, planning, and agentic task execution, with enhanced ability to work autonomously on complex, long-running projects. It features a 1M token context window (first for Opus-class) and achieves state-of-the-art results on key benchmarks including Terminal-Bench 2.0, Humanity’s Last Exam, and GDPval-AA, outperforming competitors by wide margins. Despite intelligence gains, Opus 4.6 maintains excellent safety with low misaligned behavior and minimal over-refusals. The model is available now on claude.ai, the API, and major cloud platforms with new developer features including adaptive thinking, effort controls, and context compaction.

Introducing GPT-5.3-Codex

OpenAI has launched GPT-5.3-Codex, a highly capable agentic coding model that is 25% faster and sets new industry records on coding benchmarks like SWE-Bench Pro (56.8%) and Terminal-Bench 2.0 (77.3%). It can build complex games and handle professional tasks beyond coding, including data analysis and presentations. Notably, this model helped accelerate its own development. GPT-5.3-Codex offers real-time interactive steering, strong cybersecurity capabilities classified as “High capability,” and is available through paid ChatGPT plans and API access.

GLM-5: From Vibe Coding to Agentic Engineering

GLM-5 is Z.ai’s latest model targeting complex systems engineering and long-horizon agentic tasks. It scales up to 744B parameters (40B active) with 28.5T tokens of training data, integrating DeepSeek Sparse Attention for efficiency. A novel asynchronous RL infrastructure called “slime” improves training. GLM-5 achieves best-in-class performance among open-source models on reasoning, coding, and agent benchmarks, ranking #1 on Vending Bench 2 with a $4,432 final balance. It’s open-sourced under MIT license, available via API, and supports local deployment with compatibility for Claude Code and OpenClaw.

MiniMax M2.5: Built for Real-World Productivity.

MiniMax introduces M2.5, a new AI model extensively trained with reinforcement learning in complex real-world environments. It achieves state-of-the-art performance in coding (80.2% SWE-Bench Verified), tool use, search (76.3% BrowseComp), and office work. M2.5 completes tasks 37% faster than its predecessor M2.1, matching Claude Opus 4.6’s speed while costing only 10% as much. At $1 per hour (100 tokens/sec) or $0.30 (50 tokens/sec), it offers extremely cost-effective AI for productivity applications.

Nano Banana 2: Combining Pro capabilities with lightning-fast speed

Google DeepMind has launched Nano Banana 2, a new AI image generation model that combines the advanced capabilities of Nano Banana Pro with the speed of Gemini Flash. The model offers enhanced features including advanced world knowledge with real-time information, subject consistency for up to five characters and 14 objects, precise instruction following, production-ready specs (512px to 4K), and improved visual fidelity.

Hello Entire World

Entire, a new company backed by a $60 million seed round, aiming to create the world’s next developer platform for AI‑driven coding agents. Their first product, the Entire CLI, introduces “Checkpoints” – a Git‑compatible primitive that automatically records an agent’s full context (prompts, transcripts, token usage, tool calls, etc.) with each commit, storing it on a dedicated branch. This makes AI‑generated code traceable, easier to review, and reusable across sessions, while reducing token waste and supporting multiple agents. The CLI is open‑source, supports Claude Code and Gemini now, and will expand to other models. The vision is an AI‑native, open, and scalable software‑development lifecycle.

New Versions

Python 3.15.0 alpha 6

This sixth alpha build of 3.15 arrives in the middle of February.

Additionally, Python 3.14.3 and 3.13.12 (both being bugfix releases) are also available.

transformers 5

Transformers v5 was released as a major upgrade, with support for over 400 model architectures (up from ~40 in v4) and 750,000+ model checkpoints. Key improvements include 20-30% faster inference, a new modular architecture that simplifies adding models, streamlined tokenizers and image processors, and native quantization support. It also introduces a built-in HTTP server (transformers serve) for easy deployment. The library now integrates tightly with popular inference engines like vLLM and SGLang, and supports GGUF files for local execution. Existing v4 checkpoints remain compatible, though PyTorch-only support means Flax/TensorFlow have been deprecated.

isort 8

isort 8 drops support of Python 3.9, and fixes a number of issues.

Tutorials

Deeplearning.ai’s Agent Skills with Anthropic by Anthropic

In this course, you’ll learn how skills work, explore best practices for creating them, and build skills for different use cases. You’ll see skills in action across Claude.ai, Claude Code, the Claude API, and the Claude Agent SDK, and learn how to combine them with MCP and subagents for complex workflows.

Deeplearning.ai’s A2A: The Agent2Agent Protocol by Google Cloud and IBM

In this course, you’ll build a healthcare multi-agent system with three specialized agents using different frameworks. You’ll wrap each agent in an A2A server, build A2A clients to communicate with them, and orchestrate them into sequential and hierarchical workflows. You’ll see how A2A complements MCP: while MCP connects agents to external data systems, A2A enables agents to collaborate with each other.

Articles

PEP 814 – Add frozendict built-in type

PEP 814 is accepted. This PEP proposes adding an immutable frozendict built-in type to Python 3.15. It implements the Mapping protocol, preserves insertion order, and is hashable when all keys/values are hashable. Unlike MappingProxyType, it’s truly immutable and hashable, making it safe for use with @functools.lru_cache() and as dictionary keys. It supports union operators (|, |=) and can replace mutable dicts in stdlib constants for safety. Unlike collections.frozenmap, frozendict maintains insertion order and provides O(1) lookups. The implementation shares code with dict but is not a subclass to prevent mutation via dict methods.

From Python 3.3 to today: ending 15 years of subprocess polling

For 15 years, Python’s subprocess module and psutil used busy-loop polling to wait for processes, causing unnecessary CPU usage and latency. The author replaced this with event-driven approaches: using pidfd_open() with poll() on Linux (kernel 5.3+), kqueue() on BSD/macOS, and existing mechanisms on Windows. This eliminates busy-looping - the process blocks until the kernel signals process termination or timeout. Measurements show dramatic reduction in CPU context switches (from 258+ to just 2). The improvement first landed in psutil and was contributed upstream to CPython.

Speeding up Pillow’s open and save

This blog post by Hugo van Kemenade details performance improvements to Pillow’s image open/save operations using Python 3.15’s Tachyon profiler. Previously, Pillow would import many image format plugins unnecessarily even when only one format was needed. A new file extension-to-plugin mapping enables lazy loading, only importing relevant plugins. Results: PNG opening 2.6x faster, WebP opening 14x faster, PNG saving 2.2x faster, and WebP saving 7.9x faster. These optimizations will be included in Pillow 12.2.0, making image processing more efficient especially for command-line tools.

Is it a class or a function?

The article explains that in Python both classes and functions are callables — they’re invoked with parentheses and may return a value. Examples: print and sum are built‑in functions; str, list, bool, enumerate, and type are classes that behave like functions, returning new objects when called. Because the user‑facing syntax is the same, Python programmers often call any callable a “function” even when it’s technically a class. This fuzzy terminology fits Python’s duck‑typing philosophy: what matters is the object’s behavior (being callable), not its exact implementation.

Anatomy of a Python Function

The article explains the terminology for a Python function’s parts. The function body is everything indented after the definition. The function definition runs from def to the end of the body, though many think it ends at the colon. The first line (from def to the colon) is called the function header by the author; others may call it a declaration, but not a signature. A signature consists only of the parameter list and return annotation, as defined by PEP 362. Clear naming matters for type‑checking and communication.

switch-case in Python? It’s not match-case!

Python lacks a traditional switch-case statement, though it has match-case from Python 3.10. However, match-case is designed for structural pattern-matching (matching iterables, dictionaries, objects, and nested patterns), not simple value-based switching. For basic switch-case needs, if-elif chains are more readable and require less indentation. When mapping input values to outputs, dictionaries are typically the best alternative. The article advises using match-case only for advanced pattern-matching scenarios, not as a direct replacement for switch statements found in other languages. Most Python programmers are unfamiliar with match-case, so simpler constructs are usually preferable.

Making Pyrefly Diagnostics 18x Faster

Pyrefly achieved an 18x performance improvement in diagnostic updates through two key optimizations. The first was implementing fine-grained dependency tracking, which reduces module invalidation from 2000+ to just 100+ by tracking exactly which types are used rather than all imports. The second was streaming diagnostics directly to the IDE as files are rechecked, rather than waiting for the entire recheck process to complete. These changes reduce diagnostic update time from ~3.6 seconds to under 200ms on an M4 Macbook Pro, making type errors refresh instantly after saving a file. The team continues prioritizing speed, memory efficiency, and functionality as they approach the v1 release.

Better Python tests with `inline-snapshot`

The article introduces inline-snapshot, a Python testing library that automatically manages test data. Instead of manually writing assertions for complex data structures, developers use snapshot() placeholders that get auto-populated when running pytest --inline-snapshot=fix. This eliminates tedious maintenance when data changes. The library pairs well with dirty-equals to handle dynamic fields like timestamps via IsInt() and IsNow(). Snapshots can even be nested within complex structures. The underlying executing library enables automatic source code updates by inspecting Python AST.

Django: profile memory usage with `Memray`

This blog post explains how to profile and reduce memory usage in Django projects using Memray, a memory profiler from Bloomberg. The author demonstrates profiling the Django “check” command, generating flame graphs to visualize allocations, and identifying that importing numpy.random consumed 5.7MB (23% of peak 25.2MB). By replacing numpy.random with Python’s built-in random.shuffle(), memory usage dropped 22% to 19.4MB. The post also offers solutions like deferred imports, lazy imports (upcoming in Python 3.15), and provides a Zsh one-liner for faster iteration. The key takeaway: Memray helps pinpoint and eliminate unnecessary memory bloat in Django applications.

Implementing local-first agentic AI: A practical guide

This article provides a practical guide for implementing local-first agentic AI using Small Language Models (SLMs) in privacy-sensitive environments. It presents an enterprise use case: an HR triage system that processes sensitive employee reports. The system uses a three-stage pipeline: intent detection (classifying issues like harassment or burnout), planning (creating remediation steps), and tool execution (performing actions like opening HR cases). Key models include sentence-transformers/all-MiniLM-L6-v2 (~90M), Phi-3-mini (~3.8B), and Function Gemma (~2B). The “Local First, Cloud Last” architecture runs on modest hardware without GPUs, offering privacy, cost efficiency, and auditability while avoiding cloud latency and compliance risks. SLMs require precise prompt engineering but enable easy local testing without paid tokens, making them ideal for enterprise workloads with strict data locality constraints.

Agent Trace: Capturing the Context Graph of Code

Agent Trace is an open, vendor-neutral specification for recording AI contributions alongside human authorship in version-controlled codebases. It solves the modern problem of context loss by linking each code change to its originating conversation and context, rather than just storing line differences like traditional git. This enables powerful engineering management tools (blaming AI vs humans, PR breakdowns, dashboards) and significantly improves AI agent performance by making context retrievable, reducing wasted inference time. The spec represents a shift where context—not lines of code—becomes the precious resource in the AI era.

Podcasts

🐍 RealPython Podcast

🥧 Python Bytes Podcast

🦜 Talk Python to me

🍕 Pybites Podcast

VS Code Insiders Podcast

Episode 19: Subagents: Parallel Execution and Context Isolation

Repositories

volcengine/OpenViking (Apache 2.0)

OpenViking is a context database designed specifically for AI Agents which unifies the management of context (memory, resources, and skills) that Agents need through a file system paradigm, enabling hierarchical context delivery and self-evolving.

NevaMind-AI/memU (Apache 2.0)

memU is a memory framework built for 24/7 proactive agents. It is designed for long-running use and greatly reduces the LLM token cost of keeping agents always online, making always-on, evolving agents practical in production systems. memU continuously captures and understands user intent. Even without a command, the agent can tell what you are about to do and act on it by itself.

Have time for some fun?

Kena: Scars of Kosmora is announced during State of Play

Kena: Scars of Kosmora, the second chapter of Kena’s adventure, brings our Spirit Guide to the mysterious realm of Kosmora, an island “full of buried secrets from a tragic past”. You can watch the announcement trailer here.

It is expected to launch on PlayStation 5 and PC later this year.

Alright, that concludes the February 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 March! 👋

This Month for Pythonistas - January 2026

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

from datetime import date

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

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

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

Ready? Let’s get started!

EuroPython 2026 Location Revealed

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

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

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

2026 Python Developers Survey

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

PEP 686 - Make UTF-8 mode default

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

New Versions

Python 3.15.0 alpha 5

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

Pandas 3.0.0

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

FastMCP 3.0.0 beta 1

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

Tutorials

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

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

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

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

RealPython’s How to Build a Personal Python Learning Roadmap

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

Articles

Python Numbers Every Programmer Should Know

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

Recent optimizations in Python’s Reference Counting

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

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

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

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

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

Implicit string concatenation

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

What async really means for your python web app?

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

Asyncio is neither fast nor slow

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

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

How to Type Hint a Decorator in Python

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

Static Protocols in Python: Behaviour Over Inheritance

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

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

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

How we made Python’s packaging library 3x faster

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

WebAssembly as a Python extension platform

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

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

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

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

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

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

The Future of Software Development is Software Developers

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

Agent-native Architectures

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

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

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

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

Demystifying evals for AI agents

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

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

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

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

How to build self-improving coding agents

Part 1

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

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

Part 2

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

Part 3

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

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

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

AI Makes Exploration Cheap, Not Decisions Easy

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

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

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

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

Top Python libraries of 2025

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

PyPI in 2025: A Year in Review

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

2025: The year in LLMs

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

Five Takes to End 2025

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

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

Software Engineering in 2026

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

17 predictions for AI in 2026

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

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

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

Podcasts

🥝 core.py

Episode 28: 2025 In Review

🐍 RealPython Podcast

🥧 Python Bytes Podcast

🦜 Talk Python to me

🍕 Pybites Podcast

🚀 VS Code Insiders Podcast

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

Repositories

adamchainz/tprof (MIT)

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

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

This Month for Pythonistas - November 2025

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

from datetime import date

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

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

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

Ready? Let’s get started!

PyCon US 2026 CFP is Open

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

PyCon Ireland 2025

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

20th anniversary of first ever Django release

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

New Versions

Python 3.15.0 alpha 2

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

Django 6.0 RC 1

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

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

pytest 9.0

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

Tutorials

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

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

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

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

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

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

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

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

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

Build a coding agent with GPT 5.1

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

Articles

Why Performance Matters in Python Development

Disclaimer: This article contains promotional content regarding JetBrains products.

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

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

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

__slots__ for optimizing classes

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

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

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

How to use UUIDv7 in Python, Django and PostgreSQL

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

Python package managers: uv vs pixi?

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

Introducing GPT-5.1 for developers

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

Key updates include:

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

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

Key features include:

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

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

The Learning Loop and LLMs

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

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

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

Becoming a Core Developer

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

What caused the large AWS outage?

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

Cloudflare outage on November 18, 2025

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

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

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

Podcasts

🐍 RealPython Podcast

🥧 Python Bytes Podcast

🦜 Talk Python to me

🍕 Pybites Podcast

🚀 VS Code Insiders Podcast

Repositories

hyperflask (MIT)

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

langchain-ai/deepagents (MIT)

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

MoonshotAI/kimi-cli (Apache 2.0)

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

MemMachine (Apache 2.0)

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

OpenRouterTeam/python-sdk (Apache 2.0)

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

Have time for some fun?

Golden Joystick Awards 2025

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

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

[one-liner] Install Kiro Cli

Zeyang Lin — Tue, 18 Nov 2025 08:20:00 GMT

One-Liner series: Kiro Cli

source: kiro.dev docs

Install on Linux/macOS

curl -fsSL https://cli.kiro.dev/install | bash

Important note on Amazon Q CLI

If Amazon Q CLI was already installed, running the script above would result in:

Kiro CLI installer:

Detected existing Amazon Q CLI installation
Kiro CLI is the new version of Amazon Q CLI. Updating to latest version.


⚠️ Q CLI at /usr/bin/q does not support auto-update. Please uninstall it and rerun this script to install Kiro CLI.

To uninstall Q CLI, run:

sudo apt remove amazon-q

If succeeded, run the kiro-cli script again:

curl -fsSL https://cli.kiro.dev/install | bash

It should install Kiro CLI:

Kiro CLI installer:

Downloading package...
✓ Downloaded and extracted
✓ Package installed successfully

🎉 Installation complete! Happy coding!

Next steps:
Use the command "kiro-cli" to get started!

This script would install Kiro Cli into current user’s .local/ directory:

which kiro-cli

/home/******/.local/bin/kiro-cli

Update

kiro-cli update

[one-liner] Install Claude Code (Native Build)

Zeyang Lin — Sun, 02 Nov 2025 08:09:00 GMT

One-Liner series: Claude Code (Native Build)

source: Claude Docs

Install on Linux/macOS/WSL

curl -fsSL https://claude.ai/install.sh | bash

Install on Windows (PowerShell)

irm https://claude.ai/install.ps1 | iex

Update

claude update

This Month for Pythonistas - October 2025

Zeyang Lin — Fri, 31 Oct 2025 13:00:00 GMT

from datetime import date

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

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

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

Ready? Let’s get started!

OpenAI DevDay 2025

OpenAI DevDay 2025 was held on October 6, 2025 at Fort Mason in San Francisco. The keynote was delivered by CEO Sam Altman and featured special guest Jony Ive, the renowned Apple designer. The event focused on empowering developers to build groundbreaking applications faster than ever.

Highlights include:

Apps in ChatGPT and Apps SDK
AgentKit
Sora 2 and Sora 2 Pro
GPT-5 Pro API
Codex General-Available
GPT-Realtime-mini

Github Universe 25

At Github Universe 25, which was held on October 28 - 29, 2025, GitHub announces Agent HQ - a unified platform bringing coding agents from Anthropic, OpenAI, Google, Cognition, and xAI directly into GitHub workflows as part of Copilot subscriptions. Features include mission control for managing agents across devices, VS Code integration with plan mode and custom agents, enterprise governance tools, code quality checks, and metrics dashboards. It would be available starting with OpenAI Codex for Copilot Pro+ users in VS Code Insiders.

A comprehensive recap can be found here.

New Versions

Python 3.14.0 final

Python 3.14 (Pi, 𝜋, or Pie) is finally here! This release brings officially supported free-threaded build and lots of new features. Besides, Python 3.13.9 is also released.

Python 3.12.12, 3.11.14, 3.10.19 and 3.9.24 are the latest security-only releases.

Python 3.9 is reaching End-Of-Life this October, so don’t forget to upgrade!

Python 3.15.0 alpha 1

Python 3.15.0 alpha 1 is the first of seven planned alpha releases for the Python 3.15 series. Key highlights include:

Statistical Sampling Profiler (PEP 799): A new high-performance profiling tool with virtually zero overhead that can sample at up to 1,000,000 Hz
UTF-8 as Default Encoding (PEP 686): Python now uses UTF-8 as the default encoding for I/O operations, improving cross-platform compatibility
New C API (PEP 782): Introduction of PyBytesWriter for creating Python bytes objects
Improved Error Messages: Enhanced developer experience with better error reporting

LangChain 1.0 & LangGraph 1.0

This version marks LangChain’s commitment to stability with no breaking changes until 2.0, while reducing complexity and focusing on core agent functionality.

CrewAI 1.0

CrewAI 1.0 represents the transition from beta/experimental to production-grade enterprise solution, with better stability, enterprise features, and a more mature ecosystem while maintaining the core multi-agent orchestration capabilities.

PyTorch 2.9

The 2.9 release focuses on enhancing multi-GPU programming, expanding hardware compatibility, and improving the developer experience for C++ extensions while maintaining performance optimizations.

Major New Features include:

Symmetric Memory: New feature enabling easier multi-GPU kernel programming
Enhanced torch.compile: Ability to arbitrarily toggle error or resume on graph breaks
Expanded Hardware Support: Added ROCm, XPU, and CUDA 13 wheel variants
FlexAttention: Now enabled on Intel GPUs with flash decoding optimization on x86 CPUs
Arm Platform: Improvements and optimizations for Arm architecture
Linux aarch64: Binary wheel builds across all CUDA versions

isort 7.0

isort 7 is a conservative major release focused on updating Python version support and maintaining compatibility with newer Python versions. The changes are relatively minor compared to the major architectural changes seen between versions 4.x → 5.x. The main impact for users will be the requirement for Python 3.10+ and improved debugging information for file processing.

Ubuntu 25.10

Ubuntu 25.10 “Questing Quokka” is released! It “introduces GNOME 49 with media and power controls on the lock screen, HDR brightness settings, and enhanced accessibility features in line with the European Accessibility Act.”

It “also debuts Rust-based implementations of sudo and coreutils for improved memory safety, and adopts the new RVA23 profile as the baseline for RISC-V, paving the way to Ubuntu 26.04 LTS.”

Other spins like Xubuntu, Lubuntu, Kubuntu, edubuntu, and Ubuntu Studio are also released. Pick your favorite and start coding!

Tutorials

DeepLearning.ai’s Agentic AI by Andrew Ng

In this course taught by Andrew Ng, you’ll gain a fundamental understanding and practical knowledge to develop production-ready agentic applications, from design patterns to deployment and evaluation.

DeepLearning.ai’s Building Live Voice Agents with Google’s ADK from Google

You’ll learn how to build and deploy AI agents with Google’s open source Agent Development Kit (ADK). ADK provides modular components such as models, tools, memory, and orchestration, that make it easier to create both simple and complex systems.

DeepLearning.ai’s Governing AI Agents from databricks

Explore what it means to govern an agent, how to apply governance policies to a real dataset in Databricks, and how to add observability to track and debug performance. Through this course, you’ll know how to build agents that handle data responsibly while maintaining visibility, and safety.

Articles

Python 3.14: Cool New Features for You to Try

As usual, RealPython has a great article on the very latest Python version. This time it compiles a list of the new features in Python 3.14 (eg. t-strings, colorful REPL, deferred annotation evaluation) and demonstrates how to play with them.

Python 3.14 Is Here. How Fast Is It?

Python 3.14 is the fastest CPython release yet, showing significant improvements over previous versions. Benchmarks tested Fibonacci calculations and bubble sort algorithms across single-threaded and multi-threaded scenarios. Key findings show 3.14 running 27% faster than 3.13 for recursive functions. While the new JIT interpreter showed minimal gains, the free-threading variant delivered impressive 3x speed improvements for CPU-heavy multi-threaded workloads due to GIL removal. PyPy remained exceptionally fast, outperforming even Node.js in some tests, while Rust demonstrated the highest performance overall.

The future of Python web services looks GIL-free

Python 3.14’s free-threaded implementation (no GIL) shows promising results for web services. Benchmarks reveal ASGI apps maintain similar performance with 20% lower memory usage, while WSGI apps see 3-4x throughput improvements for CPU-bound tasks. Despite 5-10% performance penalty in pure Python Python code, the elimination of GIL contention enables true multi-core utilization, potentially revolutionizing Python web deployment by simplifying concurrency and reducing memory requirements.

T-strings: Python’s Fifth String Formatting Technique?

Python 3.14 introduces t-strings, a fifth string formatting technique that returns Template objects instead of strings. Unlike f-strings which immediately interpolate values, t-strings enable lazy string interpolation - useful for library authors who need to pre-process inputs (like escaping SQL/HTML) before final string creation. T-strings use t"..." syntax and are primarily designed for tool/library maintainers, not typical Python developers.

Build Production-Ready LLM Agents with LangChain 1.0 Middleware

This tutorial demonstrates how to build production-ready LLM agents using LangChain 1.0’s new middleware architecture. It covers five essential middleware components:

Message Summarization: Manages context windows by condensing conversations
PII Filtering: Protects sensitive data through automatic redaction
Human-in-the-Loop: Adds approval workflows for sensitive actions
Task Planning: Structures complex requests into manageable subtasks
Intelligent Tool Selection: Pre-filters tools to reduce costs and improve accuracy

The middleware follows web server patterns, providing reusable, testable components that can be composed together. Each focuses on a single responsibility (monitor, modify, control, or enforce) and integrates seamlessly to build robust production agents with minimal infrastructure code.

Django: one ORM to rule all databases 💍

This article provides a comprehensive comparison of Django ORM features across PostgreSQL, SQLite, MariaDB, MySQL, and Oracle. It includes detailed feature matrices showing support levels (✅/⚠️/🚫) for various functionality including field types, constraints, query features, transactions, and GIS capabilities, using fictional data to illustrate what an automated feature comparison matrix could look like in Django’s official documentation.

Why Reactive Programming Hasn’t Taken Off in Python (And How Signals Can Change That)

Reactive programming hasn’t gained traction in Python because existing tools like RxPY are designed for event streams and require complex subscription management. However, signal-based reactive programming offers Python developers automatic state synchronization like spreadsheet formulas, reducing bugs and improving maintainability. The reaktiv library provides transparent, synchronous updates where derived values automatically stay in sync with base data without manual coordination.

From Claude Code to Agentic RAG

The article advocates moving from traditional vector-based RAG systems to “agentic retrieval” - letting LLMs reason through documents directly. It introduces PageIndex, a vectorless hierarchical indexing system that creates human-like table-of-contents trees. Instead of complex vector databases, it gives LLMs navigational tools to find and retrieve relevant content, mirroring how Claude Code uses simple tools like grep. PageIndex achieved 98.7% accuracy on FinanceBench while requiring minimal infrastructure.

Vibe engineering

Simon Willison proposes “vibe engineering” as the opposite of “vibe coding” - a sophisticated, accountable approach where experienced engineers use AI tools like coding agents responsibly. This method rewards advanced software practices: comprehensive testing, planning, documentation, version control, and good management skills.

State of LLMs in Late 2025

The 2025 LLM landscape is hyper-specialized, moving from single generalist models to a diverse ecosystem where each model has distinct strengths. The article analyzes GPT-5’s unified intelligence system with automatic model switching, Claude Sonnet 4.5’s coding dominance (77% SWE-bench), open-source Llama 4 variants with 10M token contexts, Grok 4’s mathematical supremacy, and efficient alternatives like Mistral. It provides practical guidance on choosing the right model based on specific use cases rather than “which is smartest,” reflecting the era of tailored AI tools for specific tasks.

Two things LLM coding agents are still bad at

LLM coding agents struggle with two key areas. First, they don’t use copy-paste operations—instead of moving code directly, they delete from the source and write from memory into the destination, which feels unnatural compared to human programming habits. Second, they’re terrible at asking clarifying questions when uncertain; instead they make assumptions and brute-force solutions until hitting walls.

AI can code, but it can’t build software

The article argues that while AI can generate code, it cannot truly “build software” - the complex engineering required to create production-ready applications. Coding is solving isolated problems, but software engineering involves managing complexity, integration, and long-term maintainability. AI can demo features, but transforming prototypes into robust systems requires human expertise, explaining why non-technical founders still seek technical co-founders despite AI tools.

Podcasts

🥝 core.py

🐍 RealPython Podcast

🥧 Python Bytes Podcast

🦜 Talk Python to me

🍕 Pybites Podcast

#203: Automating API Documentation with Zylosystems

🚀 VS Code Insiders Podcast

Repositories

claude-agent-sdk-python (MIT)

Claude Code SDK is renamed to Claude Agent SDK. It helps developers build powerful autonomous agents using Claude.

microsoft/agent-framework (MIT)

MAF is Microsoft’s comprehensive multi-language framework for building, orchestrating, and deploying AI agents with support for both .NET and Python implementations. It’s developed by the core AutoGen and Semantic Kernel teams at Microsoft, and is designed to be a new foundation for building AI applications going forward.

microsoft/agent-lightning (MIT)

“The absolute trainer to light up AI agents.”

PageIndex (MIT)

PageIndex is a Vector-less, reasoning-based RAG system that simulates how human experts navigate and extract knowledge from long documents through tree search, enabling LLMs to think and reason their way to the most relevant document sections.

/dev/push (MIT)

/dev/push is a open-source Platform as a Service (PaaS) written in Python and HTML for developers to build and deploy their applications. It is self-hostable and can be considered as an alternative to Vercel, Netlify, etc.

mitmproxy/pdoc (MIT-0)

pdoc is a Python library for generating API documentation from code and comments.

ludo-technologies/pyscn (MIT)

pyscn is a Python code quality analyzer written in Go. It detects dead code, tracks module dependencies, and analyzes complexity, etc. to make your code base more maintainable.

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

This Month for Pythonistas - September 2025

Zeyang Lin — Tue, 30 Sep 2025 13:00:00 GMT

from datetime import date

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

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

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

Ready? Let’s get started!

DjangoCon US 2025 was held in Chicago, United States.
PyCon UK 2025 was held in Manchester, England.
PyCon China 2025 was held in Shanghai, China.

New Versions

Python 3.14 RC3

This is the final release preview before 3.14 final, which is scheduled for Tuesday, 2025-10-07.

Source tarball and binary releases are available here.

Tutorials

Deeplearning.ai’s Knowledge Graphs for AI Agent API Discovery from SAP

You’ll implement API discovery that starts with semantic retrieval to reduce the API selection space, then adds APIs connected by business-process edges. The result is a small, relevant subset of APIs that includes the information about the process sequence the agent should follow.

Deeplearning.ai’s Build AI Apps with MCP Servers: Working with Box Files from Box

Build an LLM-powered invoice app that processes local PDF invoices to extract fields such as client name, total amount, and purchased product, and generates per-client reports.

DeepLearning.ai’s Building and Evaluating Data Agents from snowflake

You’ll know how to build, trace, and evaluate a multi-agent workflow that plans tasks, pulls context from structured and unstructured data, performs web search, and summarizes or visualizes the final results.

Guide to Agentic AI – Build a Python Coding Agent with Gemini

This project-based tutorial provides a deep understanding of how powerful AI tools work by guiding you through the creation of an agentic loop powered by tool calling. You will implement the core abilities for your agent to interact with and modify a codebase, including reading files, writing to files, and executing code to get feedback.

Articles

Python has had async for 10 years – why isn’t it more popular?

Python’s async / await (introduced 2015) remains niche due to limited I/O use cases (excludes disk ops, reliant on GIL), fragmented ecosystem (Flask/Django’s patchy async adoption, duplicated sync/async APIs), and testing complexity. FastAPI’s rise indicates async success in web contexts, but 3.14’s free-threading/sub-interpreter features may reduce async reliance.

Python: fix SyntaxWarning: 'return' in a 'finally' block

Python 3.14+ warns about return/break/continue in finally blocks (PEP 765) as they override preceding flow control. Always returns the finally block’s value, causing silent bugs. Fix it by restructuring code to avoid these keywords in finally blocks—move returns to except blocks or remove unnecessary exception handling.

Building your own CLI Coding Agent with Pydantic-AI

This article details building a custom CLI coding agent using Pydantic-AI and Model Context Protocol. Unlike commercial tools, a custom agent can be tailored to specific project needs, understanding project context and conventions. The agent combines Claude with specialized MCP servers for testing, code execution, documentation access, internet search, and file operations. Through incremental capabilities—from simple test running to full codebase management—the agent evolves into an intelligent development partner that maintains context, provides structured reasoning, and can autonomously debug and implement solutions.

Static Sites with Python, uv, Caddy, and Docker

This blog post explains the author’s deployment stack for Python-built static sites using uv, Caddy, and Docker. The author details a multi-stage Docker build approach: first stage uses uv with Python 3.13 to build the site, second stage uses Caddy’s Alpine image to serve static files. The setup includes custom Caddy configurations for reverse proxying analytics and handling custom error pages, domains, and content types.

Where to Host a Python Web App

The article compares hosting options for Python web apps, recommending Heroku for non-Docker apps due to its excellent developer experience. Render offers a cheaper Heroku alternative, while Fly.io is usually the cheapest but requires more configuration. AWS ECS suits AWS-experienced users, and self-hosting is only viable with dedicated ops teams. Docker usage significantly impacts hosting choice. The author strongly recommends autoscaling regardless of platform choice, with Heroku being their top pick when prioritizing developer experience and reliability.

AI-Assisted Development: A Three-Act Play

The article presents three distinct approaches to AI-assisted software development: “Vibe Coding” (AI builds apps through chat iterations), “Copilot” (AI assists with planned code sections requiring human review), and “HUD” (AI serves as an intelligent code-completion tool). Author explains these methods aren’t mutually exclusive but suited for different tasks—designers prefer vibe-coding for rapid prototypes while developers use HUD (Cursor’s Tab) for production code.

Parallel AI Agents Are a Game Changer

Parallel AI agents represent a major shift in software development, allowing multiple AI agents (like GitHub Copilot) to work simultaneously on different tasks. Instead of coding one feature at a time, developers can assign 10-20 issues to agents working in parallel, then focus on reviewing and refining their output.Success requires good system documentation, fast CI/CD, monorepo architecture, and skills in problem decomposition and code review rather than line-by-line coding.

Writing effective tools for agents — with agents

The post explains how to create effective tools for AI agents using an evaluation-driven approach. Key insights include: building targeted tools for specific workflows rather than generic APIs, using clear namespacing to avoid confusion, returning meaningful context efficiently, and optimizing for token usage. The authors recommend prototyping quickly, creating comprehensive evaluations with real-world tasks, and collaborating with Claude itself to iteratively improve tool performance. Best practices involve designing tools that mirror human problem-solving while providing rich functionality under the hood.

Building Agents with the Claude Agent SDK

The Claude Code SDK is now Claude Agent SDK. It helps developers build powerful autonomous agents using Claude. The framework operates on a feedback loop: gather context → take action → verify work → repeat. Key features include agentic search, tools/actions, subagents, MCP integrations, code generation, and verification methods.

Podcasts

🐍 RealPython Podcast

🥧 Python Bytes Podcast

🦜 Talk Python to me

🍕 Pybites Podcast

#202: Behind the scenes at Pybites with Bob and Julian

VS Code Insiders Podcast

Repositories

langchain-ai/open-swe (MIT)

OpenSWE is an open-source, cloud-based asynchronous coding agent built with LangGraph. It autonomously understand codebases, plans solutions, and executes code changes across repositories - creating issues and pull requests automatically. Features include human-in-the-loop feedback, parallel execution, and can be launched via web UI or GitHub issues with the “open-swe” label.

google-agentic-commerce/AP2 (Apache 2.0)

Agent Payments Protocol (AP2) is Google’s initiative for secure, interoperable AI-driven payments. This repository provides code samples and demos using ADK and Gemini, with Python/Android scenarios for shopping agents. Features setup instructions, quickstart guides, and authentication via Google API Key or Vertex AI.

deepseek-ai/DeepSeek-V3.2-Exp

As an intermediate step toward DeepSeek’s next-generation architecture, V3.2-Exp builds upon V3.1-Terminus by introducing DeepSeek Sparse Attention—a sparse attention mechanism designed to explore and validate optimizations for training and inference efficiency in long-context scenarios.

Have time for some fun?

Tokyo Game Show 2025 took place from September 25-28, 2025, featuring numerous major game announcements and reveals across various platforms.

Major Xbox Announcements:

Forza Horizon 6: The highly anticipated racing game was officially revealed
Gungrave G.O.R.E Blood Heat: A new entry in the action series
007: First Light: A James Bond title
Aniimo: A rhythm-based game
Double Dragon: Revive: The classic franchise returns
Hotel Barcelona: An adventure game
Rhythm Doctor: A music/rhythm game
Hitman: New content or entry in the franchise

Capcom Presentations:

Pragmata: Updates revealed for this highly anticipated title
Street Fighter 6: Continued support and new content
Other Capcom franchises received updates or reveals

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

This Month for Pythonistas - August 2025

Zeyang Lin — Sun, 31 Aug 2025 13:00:00 GMT

from datetime import date

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

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

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

Ready? Let’s get started!

Python: The Documentary | An origin story is available on Youtube now.

New Versions

Python 3.13.7

Python 3.13.7 is an expedited release which aims to fix a significant issue with the 3.13.6 release:

gh-137583: Regression in ssl module between 3.13.5 and 3.13.6: reading from a TLS-encrypted connection blocks

The official downloads are available here.

Python 3.14 RC2

This is the penultimate release candidate of Python 3.14.

RC2 was originally planned as the final Release Candidate, but a bug was discovered and a third RC is scheduled in September, before October’s 3.14 final release.

The official downloads are available here.

Tutorials

DeepLearning.ai’s Claude Code: A Highly Agentic Coding Assistant from Anthropic

In this course, you’ll learn best practices for using Claude Code to improve your coding workflow. You’ll learn key tips on how to provide Claude Code with clear context, such as specifying the relevant files, clearly defining the features and functionality, and connecting Claude Code to MCP servers.

DeepLearning.ai’s Agentic Knowledge Graph Construction from neo4j

You’ll implement an agentic system using Google’s Agent Development Kit (ADK), to build a knowledge graph that helps you find the root cause of product issues. You’ll work with structured data consisting of product and supplier information, and unstructured data consisting of product reviews.

Coursera’s Fast Prototyping of GenAI Apps with Streamlit

Build and iterate GenAI apps in hours instead of days! Start with a simple chatbot, then add prompt engineering and RAG powered by Snowflake’s secure data and LLM services, then push your prototype to Snowflake or Streamlit Community Cloud for instant feedback and quick improvement.

RealPython’s AsyncIO Python

In this tutorial, you’ll learn how Python asyncio works, how to define and run coroutines, and when to use asynchronous programming for better performance in applications that perform I/O-bound tasks.

RealPython’s What Are Mixin Classes in Python?

Mixins offer a powerful way to reuse code across multiple Python classes without forcing them into a rigid inheritance hierarchy. Instead of building deep and brittle class trees, you can use mixins to share common behaviors in a modular and flexible way.

Articles

How Python Grew From a Language to a Community

Python’s growth from a programming language to a thriving community represents an inspiring story of collaboration and dedication. Starting in 1991, Python began as a pet project by Guido van Rossum, distributed through Usenet newsgroups. The pivotal moment came in 1994 with an in-person meeting of 20 developers in Maryland, where the Python community was born as something separate from the language itself.

The journey from these humble beginnings to becoming the world’s #1 programming language involved several key phases. Early attempts to commercialize Python through a consortium model failed, but the passion and commitment of its community led to the creation of the nonprofit Python Software Foundation in 2001. This foundation, guided by open-source principles, employed Python’s core team to work full-time on the language.

PyCon conferences became the “real engine for change”, generating revenue through sponsorships from tech giants like Google. This funding enabled the foundation to hire professional staff and support ongoing development and infrastructure projects. The foundation’s commitment to diversity and heterogeneous cultures positioned Python to capitalize on emerging trends like AI, ensuring its continued relevance and growth in the tech landscape.

The State of Python 2025

The article summarizes key findings from the 2025 Python Developers Survey, highlighting major trends in the Python ecosystem. It notes that 86% of respondents use Python as their main language, emphasizing its central role. Importantly, 50% of developers have less than two years of professional coding experience, and 39% have less than two years with Python. This underscores Python’s popularity among beginners and the importance of supporting newcomers with detailed tutorials and resources. The insights are based on over 30,000 responses and aim to guide both individual developers and tool vendors.

pyx: a Python-native package registry, now in Beta

Astral.sh’s ambition to build Python’s next-gen infrastructure (the Astral Platform) begins with pyx, a “Python-native package registry” which could be seen as an optimized backend for tools like uv. Some of its early partners are already using it while other have to submit their information to be on the waitlist.

Inside HRT’s Python Fork: Leveraging PEP 690 for Faster Import

HRT implemented “lazy imports” by forking CPython, using Meta’s Cinder patches. This defers module loading until first use, solving import overhead in their Python monorepo. After migration challenges (2023-2024), all HRT Python now uses lazy imports by default, cutting CLI startup times and distributed compute overhead dramatically.

How Your Code Runs in a JIT Build

This post explains how JIT compilation works in Python, focusing on CPython’s Tier 2 and Tier 3 optimizations. It covers bytecode evolution, how code transforms from Tier 1 basic bytecode through Tier 2 micro-ops to Tier 3 machine code, the role of specializations for common patterns, and how JIT bridges Python’s flexibility with C-like performance through runtime optimization based on actual execution patterns.

asyncio: a library with too many sharp corners

The article criticizes Python’s asyncio library and suggests that it is “too many sharp corners”. It details four major problems: cancellation is broken (edge-triggered vs level-triggered), tasks can be garbage collected while pending due to weak references, I/O APIs are convoluted callback-based systems inherited from Twisted, and asyncio.Queue has poor backpressure handling. Additional issues include thread integration problems, signal handling limitations, and broken eager tasks. The author recommends using Trio or AnyIO libraries instead, which implement cancellation properly with level-triggered semantics and saner I/O abstractions.

From Async/Await to Virtual Threads

In this post Armin Ronacher explores the concept of virtual threads and structured concurrency as a way to simplify concurrent programming, especially in Python. It contrasts traditional async/await models with the idea of virtual threads managed in thread groups, where parallel tasks are spawned and automatically managed with cancellation and error propagation.

Agentic Coding Things That Didn’t Work

This is another post from Armin Ronacher in which Armin discusses various approaches and tools to improve workflow automation with LLMs but found ineffective. It is highlighted that clear, manual instruction often outperforms elaborate automations. They caution that over-reliance on automation leads to mental disengagement and reduced code quality, emphasizing the importance of active review and critical thinking.

AI Agent Design Patterns: How to Build Reliable AI Agent Architecture for Production

The article emphasizes that building reliable AI agents requires more than prompt engineering—it needs modular, role-based design, observability, and feedback loops. Modular design assigns specialized roles to agents, making systems scalable and easier to maintain. Observability involves monitoring and logging every step for improvement. Feedback loops enable agents to learn and self-optimize.

Best Practices for Building Agentic AI Systems: What Actually Works in Production

The article outlines proven best practices for building productive agentic AI systems based on real-world implementation at UserJot. Key insights include using a simple two-tier architecture (primary agent + specialized subagents), keeping subagents stateless for predictability, and employing task decomposition (vertical for sequential tasks, horizontal for parallel processing). The system emphasizes structured communication protocols, parallel execution for performance, and robust error handling with graceful degradation.

Building MCP PyExec: Secure Python Execution Server with Docker & Authentication

The blog details building MCP PyExec, a secure Python execution server using the Model Context Protocol (MCP). It covers three components: the PyExec server implementing MCP for streaming Python code execution; an OAuth 2.0 Identity Provider (IDP) for secure authentication supporting authorization code flow, JWT, and token validation; and a PyExec client for testing and interaction that manages OAuth tokens and streaming results.

Introducing gpt-oss

OpenAI has released their first open-weight models since GPT-2 - gpt-oss-120b and gpt-oss-20b - under Apache 2.0 license.

Why Observability Isn’t Just for SREs (and How Devs Can Get Started)

This blog post serves as a guide for developers to understand the importance of observability and provides a playbook for integrating it into their workflow. Observability helps developers maintain cleaner code, manage systems better, and reduce technical debt by considering more edge cases and improving debugging processes.

Vibe code is legacy code

This blog highlights that vibe coding quickly generates tech debt as the produced code often becomes legacy code—difficult to understand or maintain. Vibe coding works well for prototypes and throwaway projects but is risky for large, maintainable systems, especially if done by non-programmers. Serious coding with AI requires caution, thorough understanding, and careful maintenance. The author emphasizes that while AI changes programming, deep technical knowledge and theory-building remain essential.

Podcasts

🥝 core.py

Episode 25: A Python That Never Was

🐍 RealPython Podcast

🥧 Python Bytes Podcast

🦜 Talk Python to me

🍕 Pybites Podcast

VS Code Insiders Podcast

Repositories

jd-opensource/oxygent (Apache 2.0)

OxyGent is an open-source Python framework from JD retail department for building production-ready multi-agent AI systems. It provides modular components that snap together like LEGO bricks, enabling efficient development of collaborative AI agents. Features include intelligent real-time task decomposition, elastic distributed architecture, continuous learning capabilities, and standardized tools/LLM integration.

You can find more at their project website.

google/langextract (Apache 2.0)

LangExtract is a Python library by Google that uses LLMs to extract structured data from unstructured text. Key features include precise source grounding (mapping extractions to exact source locations), optimized handling of long documents via chunking and parallel processing, interactive HTML visualization, and support for cloud models like Gemini and local LLMs via Ollama.

nottelabs/notte (Server Side Public License 1.0)

Notte is an open-source web automation framework for building reliable AI agents. It provides essential tools for creating and deploying agents that interact with the web, combining AI reasoning with traditional scripting for cost-efficiency. Key features include structured data extraction, vaults for credential management, stealth browser sessions with CAPTCHA solving, and hybrid workflows.

langdiff (Apache 2.0)

…

mcp-use (MIT)

This is a Python library that provides a simple way to connect any LLM to any MCP server and build custom MCP agents that have tool access, without using closed source or application clients.

openai/gpt-oss (Apache 2.0)

This is the repository as part of OpenAI’s GPT-OSS, which provides a set of code implementations including a gpt-oss Python library, harmony, and more.

KittenTTS (Apache 2.0)

This is the accompanying Python library for KittenTTS, an open-source realistic text-to-speech model with just 15 million parameters which can run without a GPU.

Have time for some fun?

GamesCom 2025

Hollow Knight Silk Song finally has revealed its launch date: Sept. 4, 2025.
Resident Evil Requiem debuts a cinematic trailer featuring Grace Ashcroft for the sequel to the critically acclaimed survival horror game franchise.
Black Myth: Zhong Kui introduces Zhong Kui, a legendary demon-slayer from Chinese folklore, as the central figure of the sequel to hit Black Myth: Wukong.
Warhammer 40K Dawn of War IV is officially announced.
Lords of the Fallen II takes place a century after its predecessor, featuring faster and more punishing combat.
LEGO Batman: Legacy of the Dark Knight covers the story of Batman, starting from a young Bruce Wayne.

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

This Month for Pythonistas - July 2025

Zeyang Lin — Thu, 31 Jul 2025 13:00:00 GMT

from datetime import date

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

Welcome back Pythonistas! I hope you enjoy your summer vacation if you actually have one. But in any case I’m glad to see you back reading the fifth issue of my “This month for Pythonistas” series which curates the news, articles, tutorials, podcasts, and more Python stuff worth noting in this month.

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

Ready? Let’s get started!

EuroPython 2025 took place in Prague again this year. For those of you who did not attend, there’s no official recordings of the talks yet.

New Versions

Python 3.14.0 release candidate 1

The first release candidate of Python 3.14 is ready! Source code as well as binary distributions can be found here.

The second candidate (and the last planned release preview) is scheduled for Tuesday, 2025-08-26, while the official release of 3.14.0 is scheduled for Tuesday, 2025-10-07.

Tutorials

Deeplearning.ai’s Post-training of LLMs from NexusFlow

In this course, you’ll learn three common post-training methods—Supervised Fine-Tuning (SFT), Direct Preference Optimization (DPO), and Online Reinforcement Learning (RL)—and how to use each one effectively.

Deeplearning.ai’s Pydantic for LLM Workflows

Use Pydantic to generate structured outputs from LLMs, ensuring the responses follow a specific format that your application can reliably process.

Articles

How global variables work in Python bytecode

The blog post explains how global variables work in Python bytecode using the Memphis interpreter built in Rust as an example. It highlights that while the VM doesn’t store the names of local variables, it performs dynamic name resolution for global variables, a key aspect of Python’s flexibility.

Python Backstage • Disassembling Python Code Using the dis Module

This article explains how to use Python’s dis module to view the bytecode generated from a simple script. The bytecode is a low-level representation of the Python code, showing the sequence of operations the Python interpreter performs. For example, the LOAD_CONST and STORE_NAME instructions represent assigning a constant value to a variable, while the CALL instruction indicates a function call.

330× faster: Four different ways to speed up your code

The article discusses four ways to accelerate Python code: efficiency improvements by reducing unnecessary calculations, using compilation to optimize performance, leveraging parallelism with multiple CPU cores, and adopting development processes like benchmarking and testing. An example analyzing letter frequency in Jane Austen’s Northanger Abbey demonstrates how combining these methods yields significant speedups, ultimately achieving a 330× faster performance.

The Missing Manual for Signals: State Management for Python Developers

The article discusses state management using Signals in Python, highlighting their benefits in handling complex state dependencies and cascading updates. It contrasts Signals with traditional manual approaches, which can lead to bugs and maintenance challenges due to implicit dependencies.

Reflections on 2 years of CPython’s JIT Compiler: The good, the bad, the ugly

This blog post discusses the current state of CPython’s JIT (Just-In-Time) compiler. The author highlights that while the JIT is still experimental and not always faster than the interpreter, a growing community of contributors is working on improving it. Key areas for improvement include performance and coverage.

Getting extensions to work with free-threaded Python

The addition of free-threaded Python allows for better thread scalability, particularly in Python extensions like NumPy. Nathan Goldbaum and Lysandros Nikolaou presented at PyCon US 2025 about the challenges and solutions for migrating the Python ecosystem to support the new free-threaded model, emphasizing the importance of maintaining compatibility with existing C/C++/Rust-based extensions.

Tools: Code Is All You Need

The author details a method for converting a blog from reStructuredText to Markdown, using an LLM to generate and validate scripts, emphasizing the importance of trust in the automated process. It concludes that while MCP may be useful for certain tasks, it currently faces limitations in composability and context management compared to direct code generation.

Wasm-agents: AI agents running in your browser

The article introduces Wasm-agents, a blueprint for creating AI agents that can run directly in your browser. These agents are packaged as standalone HTML files, utilizing WebAssembly and Pyodide to execute Python scripts and libraries.

Learnings from building AI agents

The article discusses lessons learned from developing an AI code review agent at Cubic. Initially, the tool was too noisy, generating many false positives and irrelevant comments. Improvements included requiring the AI to explicitly justify its findings, simplifying the toolset to essential components, and employing specialized micro-agents for different tasks. These changes reduced false positives by 51%, improved developer trust, and streamlined the code review process.

A Guide For LLM-Assisted Web Research

The article reviews various LLMs and web research tools for internet-based research tasks. Overall, standard ChatGPT with web search is recommended for its speed, manageability, and iterative capabilities, while more complex, slower tools are less practical for routine research tasks.

Context Engineering

This article discusses “context engineering”, which involves providing the right information to agents (like LLMs) within their context window to help them perform tasks effectively. It covers four strategies: write, select, compress, and isolate.

Programming as Theory Building: Why Senior Developers Are More Valuable Than Ever

The article discusses Peter Naur’s 1985 idea that programming is about building a shared theory of how a system works. Source code is just a representation, and critical knowledge is in developers’ minds. Today’s AI tools and novice developers risk losing this underlying theory, leading to incoherent code and technical debt. Senior developers are now more vital than ever because they preserve and evaluate the theoretical framework, ensuring system coherence and understanding the “why” behind code decisions.

Writing Code Was Never The Bottleneck

The article argues that while the creation of code may be sped up by tools like LLMs, the true bottlenecks in software engineering lie in code reviews, testing, debugging, coordination, and communication. These processes, which require deep understanding and collaboration, remain critical and cannot be bypassed.

Podcasts

🥝 core.py

The Megahertz

🐍 RealPython Podcast

🥧 Python Bytes Podcast

🦜 Talk Python to me

🍕 Pybites Podcast

Repositories

huggingface/screenenv

blog -> ScreenEnv: Deploy your full stack Desktop Agent

google-gemini/genai-processors

blog -> Announcing GenAI Processors: Build powerful and flexible Gemini applications

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

This Month for Pythonistas - June 2025

Zeyang Lin — Mon, 30 Jun 2025 13:00:00 GMT

from datetime import date

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

Welcome back! Summer is really here and I hope you all enjoy the heat or rain. I’m glad to see you back reading the fourth issue of my “This month for Pythonistas” series which curates the news, articles, tutorials and more Python stuff worth noting in this month.

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

Ready? Let’s get started!

DjangoCon US 2025 is coming this September in Chicago, United States. The in-person tickets are officially on sale now. You can also choose to attend online with even Sprints options available.

New versions

Python 3.14.0 beta 3

The third beta release of 3.14 is here! Source code as well as binary distributions can be found here.

Python 3.13.5

Python 3.13.4 was an expected release early this month but was found to be having bugs. So another bugfix release 3.13.5 is out soon after.

Python 3.12.11, 3.11.13, 3.10.18 and 3.9.23

These are regular security releases with only offical tarball distributions. And remember that Python 3.9 is going to reach its end of life this October.

Tutorials

Deeplearning.ai’s DSPy: Build and Optimize Agentic Apps from DataBricks

This course teaches you how to use DSPy to build and optimize LLM-powered applications. You’ll write programs using DSPy’s signature-based programming model, debug them with MLflow tracing, and automatically improve their accuracy with DSPy Optimizer. Along the way, you’ll see how DSPy helps you easily switch models, manage complexity, and build agents that are both powerful and easy to maintain.

Deeplearning.ai’s Orchestrating Workflows for GenAI Applications from Astronomer

In this course, you’ll learn how to turn a Retrieval Augmented Generation (RAG) prototype into a robust, automated pipeline using Airflow 3.0, a leading open-source orchestration tool. You’ll build two workflows for a typical RAG application: one that ingests and embeds book description texts into a vector database, and another that queries that database to recommend books.

Deeplearning.ai’s Building with Llama 4 from Meta

In hands-on lessons, you’ll build apps using Llama 4’s long-context and its new multi-modal capabilities including reasoning across multiple images and “image grounding” in which you can identify elements and reason within specific image regions.

Deeplearning.ai’s ACP: Agent Communication Protocol from BeeAI and Linux Foundation

You’ll learn how to wrap an agent inside an ACP server and set up an ACP client to connect to the server. You’ll build sequential and hierarchical workflows of agents hosted inside ACP servers, and learn how to manage this workflow on the client side through a process or another agent.

RealPython’s How Can You Structure Your Python Script?

This is a comprehensive guide on structuring a standalone, shareable Python script, including specifying its dependencies in the script itself following PEP 723, handling CLI inputs, proprerly logging, and more.

Articles

PEP 734 – Multiple Interpreters in the Stdlib

PEP 734 is accepted. It proposes to add a new module, interpreters, to support inspecting, creating, and running code in multiple interpreters in the current process.

PEP 779 – Criteria for supported status for free-threaded Python

PEP 779 is accepted, which means that staring from Python 3.14 a “No-GIL” build is officially supported instead of being in “experimental” status like in Python 3.13.

How local variables work in Python bytecode

Local variables are stored on the stack, specifically within the evaluation stack of a Frame in the CallStack. Despite this, most Python variables are actually references to objects stored on the heap. The post illustrates this concept through a simple function, demonstrating how the stack changes as the function executes.

Google decided to donate Agent2Agent protocol/project to Linux Foundation

The Linux Foundation has announced the creation of the Agent2Agent (A2A) project, which aims to develop an open standard protocol that enables AI agents from different vendors to communicate, collaborate, and share information securely. Google Cloud contributed the A2A protocol specifications, SDKs, and developer tools.

How we built our multi-agent research system

This post by Anthropic gives a behind-the-scenes look at how they set up a system where multiple AI agents can work together on different tasks. Think of it like a digital teamwork lab, where AI agents can play different roles—like writers, editors, or problem-solvers—and collaborate to get things done.

The team designed the system to be super flexible, so they could easily run different types of experiments. Some agents work together on writing tasks, while others negotiate or help delegate work among themselves. It’s all about seeing how AIs interact, cooperate, and sometimes even challenge each other.

Building this wasn’t all smooth sailing—they had to deal with tricky prompts, keep experiments reproducible, and figure out how to measure how well the agents were doing. Along the way, they learned a lot: use clear building blocks, design thoughtful communication between agents, and always keep good logs.

Agentic Search for Dummies

This blog post discusses building a search agent that uses full-text search with offline document augmentation to let AI models dynamically gather context from a large document corpus. The system uses a search index (Tantivy) and a set of tools to enable a language model to issue multiple queries, fuse results, and read selected documents iteratively until it produces a final answer. The post argues against relying on dense embeddings due to complexity and overhead, advocating for full-text search as a more predictable and effective method for agentic search.

O(no) You Didn’t 😱

This article discusses the difference between theoretical Big-O performance and real-world performance, emphasizing that actual speed depends on context and profiling. Using a “Two Sum” problem as an example, it compares the brute-force O(n^2) approach with an optimized O(n) hashmap method. The article explains how memory access times and hardware factors influence performance, illustrating that understanding practical bottlenecks is crucial beyond just Big-O notation.

How to Vibe Code as a Senior Engineer

Despite concerns about AI-generated code quality, recent advancements in AI models have made vibe coding a valuable tool for experienced engineers. However, human oversight remains crucial for guiding architecture and ensuring code quality. The author emphasizes the importance of using a robust scaffold, establishing clear rules, and providing perfect context for optimal AI performance.

Will AI Replace Junior Developers? I Asked Experts at Pycon US

The blog discusses whether AI will replace junior developers, based on conversations at PyCon US. Most experts believe AI won’t fully replace programmers but will change how they work, especially in tasks like boilerplate coding. Key figures like Guido van Rossum and Trey Hunner see AI as a tool for improving productivity rather than a threat. Some, like Samuel Colvin, think AI could replace certain roles to increase efficiency.

Don’t Build Multi-Agents

The article argues against building multi-agent systems due to their fragility and context sharing challenges. It advocates for principles like sharing full context and implicit decision-making to build reliable AI agents. The author suggests simpler, single-threaded, linear agents or long-context compressed systems for better reliability.

Podcasts

🥝 core.py

PyCon US 2025 Recap

🐍 RealPython Podcast

🥧 Python Bytes Podcast

🦜 Talk Python to me

🍕 Pybites Podcast

Repositories

strands-agents/sdk-python (Apache-2.0)

Strands Agents is an open source SDK introduced by AWS that simplifies the development of AI agents using a model-driven approach. It enables developers to build and run AI agents in a few lines of code, scaling from simple to complex use cases. Unlike other frameworks requiring complex workflows, Strands leverages the capabilities of advanced models to plan, chain thoughts, call tools, and reflect. You can start exploring the SDK on their documentation.

bytedance/deer-flow (MIT)

deer-flow is a Deep Research framework by byte-dance team. It aims to combine language models with specialized tools for tasks like web search, crawling, and Python code execution. You can either host your own or try their online demo.

gemini-cli (Apache-2.0)

Gemini CLI is Google’s answer to Anthropic’s Claude Code and OpenAI’s Codex, but with generous free-tier usage on Gemini-2.5-pro/flash at the moment.

mongodb/kingfisher (Apache-2.0)

Originally an internal tool from Mondodb, Kingfisher is an open-source command-line secrets scanner/validator written in Rust which has various built-in rules and runs “blazingly fast”. It provides pre-built binaries for Windows, MacOS and Linux, and you can also build it yourself from the source.

microsoft/edit (MIT)

Written in Rust, Edit is the promised open-source command line editor from Microsoft. It brings classic MS-DOS style UI to both Windows and Linux but also accommodates modern features.

Have time for some fun?

Call of Ducy: Black Ops 7 continues the stories of BO 2 and BO 6

Two Black Ops games in a row! During Xbox Games Showcase 2025, Activision reveals the seventh game in the COD sub-franchise where players will fight as David Mason in futuristic world of year 2035. It is going to launch on PC (Steam, Battle.net, XBOX PC), Xbox Series/One and PlayStation 5/4.

007 First Light is gonna tell the origin story of James Bond in 2026

IO Interactive, the developer behind Hitman 47 series, announces during State of Play that their 007 title “007 First Light”, “a thrilling narrative action-adventure game” in third person, is going to be published in 2026. It is expected to be available on all major platforms: PC (Steam / Epic), Xbox Series, PlayStation 5, as well as Nintendo Switch 2.

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

This Month for Pythonistas - May 2025

Zeyang Lin — Fri, 30 May 2025 12:00:00 GMT

from datetime import date

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

Welcome back! I’m glad to see you back reading the third issue of my “This month for Pythonistas” series which curates the news, articles, tutorials and more Python stuff worth noting in this May. This May witnesses several conferences, Python 3.14 Beta 1 & 2, more tooling, and more Agentic stuff.

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

Ready? Let’s get started!

PyCon US 2025

(Many of) the video recordings are available on PyCon US YouTube channel.

Microsoft Build 2025

Github Copilot Chat Extension for VS Code is going open-source.
Github Copilot coding agent is in public preview for Copilot Enterprise and Copilot Pro+ users.
Github Models is integrated at repository level.
Native MCP support is going to land in Windows 11.
xAI’s Grok 3 and Grok 3 mini are available via Azure AI Foundry.
Windows Subsystem for Linux (WSL) is fully open-sourse.
A command line text editor called “Edit” is coming to Windows 11, and its source code would be available too.

Google I/O 2025

New models - Veo 3, Imagen 4, and Flow - are announced.
Gemma-3n is dedicated to mobile and edge device use cases.
Project Mariner, Project Astra
Jules, an asynchronous coding agent, is now in public preview.
Gemini 2.5 Flash, the fastest version of Gemini, is coming this June.
Gemini 2.5 is brought to Google Search, the “AI mode” is currently open to users in United States.

Announcing the PyTorch Docathon 2025

This docathon is a hackathon-style event aimed at enhancing PyTorch documentation with the support of the community.

Python Documentary

A documentary about Python is coming. It will debut in July at EuroPython 2025 and will be available on YouTube as well.

New versions

Python 3.14.0 beta 1 and beta 2

The first and second of four planned beta releases of 3.14 are here! Source code as well as binary distributions can be found here and here.

wagtail 7.0 LTS

This is a major update and the first ever LTS release of Wagtail, which aligns with Django 5.2 LTS.

For more check their blog post Flying into a new era with Wagtail 7.0.

redis-py 6.2

This major release happened while Redis 8 is GA and the source code goes back to true open-source. Support for HGETDEL, HGETEX, and HSETEX commands are added. VectorSet commands are added as experimental features.

Tutorials

DeepLearning.ai’s LLMs as Operating Systems: Agent Memory from Letta

Learn how to build agentic memory into your applications in this short course, LLMs as Operating Systems: Agent Memory, created in partnership with Letta, and taught by its founders Charles Packer and Sarah Wooders.

DeepLearning.ai’s Building AI Voice Agents for Production

In this course, you’ll learn how to build voice agents that listen, reason, and respond naturally. You’ll follow the architecture used to create Andrew Avatar, a collaborative project between DeepLearning.AI and RealAvatar that responds to users in Andrew Ng’s voice.

DeepLearning.ai’s MCP: Build Rich-Context AI Apps with Anthropic

Explore how MCP standardizes access to tools and data for AI applications, its underlying architecture, and how it simplifies the integration of new tools and connections to external systems.

Deeplearning.ai’s Reinforcement Fine-Tuning LLMs with GRPO from Predibase

In this course, you’ll take a technical deep dive into RFT with GRPO. You’ll learn how to build reward functions that you can use in the GRPO training process to guide an LLM toward better performance on multi-step reasoning tasks.

HuggingFace’s MCP Course

In this course, you will:

📖 Study Model Context Protocol in theory, design, and practice.

🧑‍💻 Learn to use established MCP SDKs and frameworks.

💾 Share your projects and explore applications created by the community.

🏆 Participate in challenges where you will evaluate your MCP implementations against other students’.

🎓 Earn a certificate of completion by completing assignments.

RealPython’s Modern Web Automation With Python and Selenium

This tutorial introduces modern web automation using Python and Selenium, focusing on practical techniques for navigating and interacting with web pages. It explains how to navigate web pages, locate elements within the DOM, and interact with them through clicks, keystrokes, and form submissions.

RealPython’s Managing Python Projects With uv: An All-in-One Solution

uv is designed to streamline workflows by providing an all-in-one solution that integrates installation, package management, and environment setup. The guide covers how to install uv using a standalone installer or through other package managers, and demonstrates its use cases in managing complex projects.

Articles

PEP 773 – A Python Installation Manager for Windows

PEP 773 is accepted. It proposes a new Python installation manager for Windows, called PyManager. The current installation methods for Python on Windows have several limitations and challenges, including mismatched user expectations and unreliability. PyManager aims to address these issues by providing a single, unified installation management tool that can handle multiple Python versions and provide a more streamlined user experience. It will be distributed through both the Windows Store and python.org as an MSIX package.

PEP 784 – Adding Zstandard to the standard library

PEP 784 is accepted. It proposes adding a new module to the Python standard library for Zstandard compression, a widely adopted and highly efficient compression standard. It aims to provide a unified interface for compression modules, reduce user confusion, and enable future additions of new compression formats. The reference implementation is based on the pyzstd project and includes integration with tarfile, shutil, and zipfile modules.

Unravelling t-strings

T-strings expose the parser used for f-strings, allowing introspection of the parts inside the curly braces. Brett demonstrates how to replicate f-string behavior using Python code to parse and format the components (value, conversion, and format spec) of t-strings. This parsing helps understand how expressions inside f-strings are evaluated and formatted internally.

Python Tooling at Scale: LlamaIndex’s Monorepo Overhaul

Llama-index managed to contain 650+ community packages in their monorepo. They migrated away from Poetry and Pants to uv and LlamaDev for faster, simpler development.

Pyrefly vs. ty: Comparing Python’s Two New Rust-Based Type Checkers

Both pyrefly and ty are promising new type checkers that aim to improve the Python type checking experience. While they share some similarities, they have different design goals and philosophies. ty takes a gradual approach to typing, while pyrefly is more aggressive in type inference. As both tools are still in early alpha, it will be interesting to see how they evolve in the future.

Takeaways from DjangoCon EU 2025

The article summarizes key takeaways from DjangoCon EU 2025 in Dublin, highlighting the community’s enthusiasm and valuable technical insights. Topics include database management techniques such as row locking with select_for_update, moving to BigInt primary keys, and partitioning large tables for performance. It also covers optimization strategies like reducing PostgreSQL index sizes significantly by using partial indexes.

PyTorch: The Open Language of AI

PyTorch has evolved from a framework focused on AI research to supporting production, deep AI compilation and has become foundational to thousands of projects and companies in the AI ecosystem. The PyTorch Foundation is expanding to be an umbrella organization and will now house some of the most popular and highly complementary projects making it easier for users to build AI at scale.

The first year of free-threaded Python

The first year of free-threaded Python has seen significant progress in enabling Python to fully utilize multicore CPUs and GPUs by removing the Global Interpreter Lock (GIL). Major packages and tools like NumPy, SciPy, Cython, and setuptools have been updated to support the free-threaded build. While many packages still require auditing and fixes for thread safety, the ecosystem has improved considerably.

Asyncio Demystified: Rebuilding it From Scratch One Yield at a Time

The article demystifies asyncio by rebuilding it from scratch. It starts with a primer on generators and coroutines, explaining how they can pause and resume execution. The article builds a custom event loop, showcasing an echo server example. The goal is to understand how asyncio works under the hood, removing the “magic” behind asynchronous programming in Python.

MCP explained without hype or fluff

The author shares a concrete example of an MCP server built for accessing CKAN open data, enabling AI applications to explore and analyze government datasets. Despite MCP’s evolving nature and some overhead, its adoption is strong, providing a standardized way to decouple AI clients from platform-specific tools and workflows, valuable for integrations requiring flexibility and breadth.

MCP is a powerful new AI coding technology: Understand the risks

While MCP offers powerful capabilities, it poses significant security risks because it is not secure by default. Experts warn that deploying MCP in production environments without robust safeguards is risky. However, ongoing efforts from industry and security researchers aim to enhance MCP’s security, making it a promising but still maturing technology.

A Critical Look at MCP

The author argues that the protocol’s documentation is poorly written, confusing, and glosses over important aspects. The author also criticizes the use of Python and JavaScript for examples, and the complexity of the protocol’s multiple transport modes, including HTTP+SSE and “Streamable HTTP”. It is suggested that WebSockets would be a better choice for transport, and that the protocol’s flexibility introduces security concerns and complexity. The author also mentions alternative protocols, such as ACP and A2A.

Claude Opus 4 and Claude Sonnet 4

Claude 4 Opus leads in complex, sustained coding tasks, excelling in memory usage and long-term focus, while Claude 4 Sonnet offers balanced performance and efficiency for everyday use, particularly powering GitHub Copilot. Both models support extended thinking with tool use, improved memory for handling local files, and parallel tool execution.

Podcasts

🥝 core.py

Episode 22: Beta Frenzy

DjangoChat

DjangoCon Europe 2025 Recap

🐍 RealPython Podcast

🥧 Python Bytes Podcast

🦜 Talk Python to me

🍕 Pybites Podcast

Repositories

facebook/pyrefly (MIT)

One of the tools I mentioned earlier. pyrefly is Meta’s brand new type checker for Python at very ealy stage. Read more about it on Facebook Engineering.

astral-sh/ty (MIT)

The other tool I mentioned earlier. Powered by Rust, ty is Astral’s standalone static type checker for Python but developed as part of ruff, previously known as “Red-Knot”. It comes with a command-line utility as well as a VS Code extension.

microsoft/magentic-ui (MIT)

Magentic-UI is a research prototype of a human-centered interface powered by a multi-agent system that can browse and perform actions on the web, generate and execute code, and generate and analyze files. Magentic-UI is built using AutoGen and provides a platform to study human-agent interaction and experiment with web agents.

Have time for some fun?

Gears of War: Reloaded Comes to Xbox Series, PlayStation 5 and Steam this August

This is a Remastered version of the first ever game in its franchise, featuring 4K/60FPS in the Campaign with HDR, Dolby Atmos, cross-platform play, etc. Those who own the digital version of Gears of War: Ultimate Edition would receive a free upgrade to Gears of War: Reloaded.

This Month for Pythonistas - April 2025

Zeyang Lin — Wed, 30 Apr 2025 07:00:00 GMT

from datetime import date

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

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

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

Ready? Let’s get started!

DjangoCon Europe 2025

Dublin, Ireland is the host city of this year’s DjangoCon Europe, which is held from April 23rd to 27th, 2025.

djangocon europe website

EuroPython 2025

EuroPython has announced three more Keynote Speakers: Sebastián Ramírez (Creator os FastAPI, Typer, SQLModel, etc.), Brett Cannon (Python Core Developer), and Petr Baudiš (co-founder and CTO of Rossum).

Besides, EuroPython will have a booth at PyCon US this year.

Microsoft turns 50

Like it or not, Microsoft had remarkable influence over the past decades and is still making a big impact right at the moment. In this page it celebrates its 50th anniversary by looking back at some iconic moments from the history, sharing some stories, and giving out digital goodies.

Discord server for free-threaded Python

There is a dedicated place to discuss free-threaded python on Discord now.

GvR BDFL (🤡 April Fools 🤡)

BREAKING! Guido van Rossum, the legendary creator of Python, has officially reinstated himself as Benevolent Dictator for Life (BDFL).

New versions

Python 3.13.3 & 3.12.10

It’s another month for Python version updates.

Python 3.14 Alpha 7 is out, and the first beta release is expected soon.

Python 3.13 and 3.12 receive bugfix updates:

The following versions receive only security-related fixes and no binary distributions are provided: 3.11.12, 3.10.17 and 3.9.22.

Visual Studio Code 1.99.0

VS Code joins Claude Desktop and other “AI IDEs”, having Agent Mode and MCP servers support (Preview).

A new open-source and local MCP server is introduced, allowing integration with any LLM tool supporting MCP. Read the details in Vibe coding with GitHub Copilot: Agent mode and MCP support rolling out to all VS Code users.

Update: Agent Mode is now officially turned on for everyone.

Django 5.2 LTS

This LTS version introduces new features (Automatic model imports in the shell, Composite primary keys, etc.) and deprecates some functionalities, and it will receive security updates for the next three years at least. Check its release notes.

PyTorch 2.7

This release introduces support for NVIDIA’s new Blackwell GPU architecture and ships pre-built wheels for CUDA 12.8. TorchAudio is updated to 2.7.0 and TorchVision is 0.22.0.

Ubuntu 25.04, Fedora 42, MX 23.6 and Manjaro 25.0

It seems like a big month for Linux distros since several popular distro have major/minor updates:

Ubuntu 25.04 “Plucky Puffin” introduces Linux 6.14 kernel, GNOME 48, and offers 9 months of support.
Fedora 42 promotes KDE Plasma variation to “Full Edition”.
MX Linux is a regular refresh containing bugfixes, kernel updates, and application updates.
Manjaro 25.0 “Zetar” brings various updates to different desktop environment editions.

Tutorials

Deeplearning.ai’s Vibe Coding 101 with Replit from replit

Take your own discretion on “Vibe Coding” (there’s an article about it below), but here’s a hands-on tutorial on deeplearning.ai.

You’ll use Replit’s cloud environment— with an integrated code editor, package manager, and deployment tools—to build and deploy two web applications with the help of an AI coding agent. Along the way, you’ll learn strategies for working effectively with agents and improve your development skills in the process.

Deeplearning.ai’s Getting Structured LLM Output from DotTxt

You’ll gain a fundamental understanding of structured outputs and learn efficient ways to generate outputs in your defined schema or format.

Deeplearning.ai’s Building AI Browser Agents from AGI Inc.

Learn the fundamentals of autonomous web agents, what they are, how they work, their limitations, and the decision-making strategies taken to optimize their performance.

Deeplearning.ai’s Building Code Agents with Hugging Face smolagents from HuggingFace

Understand the architecture and benefits of code agents that write code to perform tasks, compare them to traditional tool-calling agents, and learn when to use each approach.

RealPython’s Introducing DuckDB

The tutorial will equip you with the practical knowledge necessary to get started with DuckDB, including its Online Analytical Processing (OLAP) features, which enable fast access to data through query optimization and buffering.

freeCodeCamp.org’s Code DeepSeek V3 From Scratch in Python

This is a nearly-4-hours Youtube video tutorial brought by freeCodeCamp.

HuggingFace’s Agents Course

A series of tutorials introducing various aspects of AI Agents.

Articles

Python’s new t-strings

PEP 750 – Template Strings is accepted. This PEP introduces template strings which are a generalization of f-strings. Putting a t before a string template would keep it from being evaluated as a normal string but make it an instance of a new type Template.

In his blog, Dave introduces the motivation behind this PEP and shows how to play with it.

PEP 751 – A file format to record Python dependencies for installation reproducibility

PEP 751 is accepted. This PEP proposes a standard for the format of a file recording the requirements/dependencies of a Python project (ie. a lock file but standardized, agreed across the whole community).

Update:

pip 25.1+ adds experimental pip lock command:

pip lock -r .\requirements.txt --output pylock.toml

uv 0.6.15+ adds support through uv export command:

uv export --format pylock.toml --output-file pylock.toml

pdm 2.24+ also supports exporting to pylock.toml:

pdm export --format pylock --output pylock.toml

Share Python Scripts Like a Pro: uv and PEP 723 for Easy Deployment

Sharing single-file Python scripts with external dependencies is now easy thanks to uv and PEP 723, which enable embedding dependency metadata directly within scripts.

Case Study: Developing and Testing Python Packages with uv

This article highlights the simplicity of initializing a project with uv, which sets up essential files like pyproject.toml, README.md, and folder structures. This allows developers to manage dependencies effortlessly and set up virtual environments. It emphasizes the convenience of editable installations, enabling instant updates to package code without needing reinstallation.

The Llama 4 herd: The beginning of a new era of natively multimodal AI innovation

Meta has introduced Llama 4, its latest suite of multimodal AI models including “Llama 4 Scout” and “Llama 4 Maverick”, offering significant advancements in personalized AI experiences. Both models utilize a mixture-of-experts (MoE) architecture, allowing efficient use of parameters: Maverick has 17 billion active parameters with 128 experts, while Scout offers a remarkable context length of 10 million tokens. “Llama 4 Behemoth”, a larger model with 288 billion parameters, serves as a teacher for the others, enhancing their capabilities.

Agent Development Kit: Making it easy to build multi-agent applications

Google brings its own agent-building solution by announcing open-source framework Agent Development Kit (ADK) at Google Cloud NEXT 2025, additionally it introduces Agent2Agent (A2A) protocol, Agent Engine as well as Agent Garden.

Introducing GPT-4.1 in the API

GPT‑4.1, GPT‑4.1 mini, and GPT‑4.1 nano are available through OpenAI’s API service. These new models appear to focus mainly on coding and instruction following.

Update: They are also available through Github Models.

Introducing OpenAI o3 and o4-mini

OpenAI then release o3 and o4-mini of the o-series models, claiming they are their “smartest” models to date.

The role of developer skills in agentic coding

This article discusses the role of developer skills in agentic coding with AI assistants. The author categorizes AI missteps into three impact radius: time to commit, team flow, and long-term maintainability. The article emphasizes the need for developer oversight, caution against “good enough” solutions, and the importance of code quality practices and team communication.

MCP (Model Context Protocol): Simply explained in 5 minutes

Model Context Protocol is a way for LLMs to integrate with external tools. It is useful as it makes LLMs act more like developers. Behind the scenes, providers create MCP-compliant wrappers. Resources for MCP are also provided.

MCP - It’s Hot, But Will It Win?

In the author’s point of view, while MCP is popular, its success is uncertain. Middleware like MCP often fails to live up to expectations. It may face issues such as monetization problems if widely adopted or exclusion by a key platform. Vendors may lose interest due to market realities.

The “S” in MCP stands for Security

Despite its benefits, such as standardized APIs and persistent sessions, MCP has significant security risks. These risks include potential side-channels into shells, secrets, or infrastructure when agents are connected to arbitrary servers without proper security measures. The author emphasizes the need for better security in MCP to prevent these vulnerabilities.

MCP vs. A2A: Friends or Foes?

MCP standardizes how applications integrate with large language models (LLMs), while A2A facilitates communication between agents across different systems. Although MCP currently excels in establishing context for LLMs, it lacks essential features like security and task management, which A2A addresses. As both protocols evolve, their roles may intertwine, but A2A appears poised for dominance in inter-agent communication, potentially overshadowing MCP’s relevance in the future.

Git turns 20: A Q&A with Linus Torvalds

To celebrate two decades of Git, the author sat down with Linus himself to revisit those early days, explore the key design decisions behind Git’s lasting success, and discuss how it forever changed software development. The full video interview is also included in the blog.

Karpathy’s ‘Vibe Coding’ Movement Considered Harmful

The author argues that Karpathy’s “vibe coding” is harmful. It leads to hidden costs, exponential technical debt, and security risks. A better approach is to use AI with a clear vision, break down AI-generated code, provide context, test thoroughly, and review code to maintain understanding.

Training and Finetuning Reranker Models with Sentence Transformers v4

In this blogpost, the author shows how to use sentence-transformers to finetune a reranker model that beats all existing options on exactly your data. This method can also train extremely strong new reranker models from scratch.

Podcasts

🥝 core.py

Episode 21: A Garbage Episode

🐍 RealPython Podcast

🥧 Python Bytes Podcast

🦜 Talk Python to me

🍕 Pybites Podcast

Repositories

Have time for some fun?

Nintendo Switch 2 has a launch date

Nintendo reveals in their “Direct” livestream event that Switch 2 is available on June 5th, 2025 worldwide with starting price ~$449.99 outside Japan (multi-language version) and a much lower price inside Japan (Japanese-only version). Read more about it on their official website.

Clair Obscur: Expedition 33 sets sail on April 24th

In this dark fantasy RPG inspired by JRPG and Soul-like games and made by a small French team “Sandfall Interactive”, players will explore the mysterious city of Lumière and engage in immersive turn-based battles with unique mechanics. After playing it for around 30 hours I must say I really enjoyed the visual style and the rewarding action part in the battles. Check their official website for more info.

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

This Month for Pythonistas - March 2025

Zeyang Lin — Mon, 31 Mar 2025 07:00:00 GMT

from datetime import date

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

Welcome and thank you for reading This Month for Pythonistas, a monthly update dedicated to Python developers, professionals, and hobbyists.

In this inaugural issue, I would like to compile a list of news, articles, repositories, and tools worth noting in March 2025, as well as other fun stuff that may not necessarily be bound to Python community.

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

Ready? Let’s get started!

EuroPython 2025 Updates

EuroPython 2025 stays in Prague, Czech Republic (which makes Prague the host city three years in a row!), and the ticket sales start this month.

Python Core Developer Savannah Ostrowski is going to be one of the keynote speakers this year.

Get to know more in their blog.

New versions

`ipython` 9.0.2

The first major version update in three years! Check it out on pypi.

`dify` v1.1.3

This major update (v1) brings a plugin system, a new Agent node in workflow, “Extenstion”, “Dify Marketplace”, and more!

Check this particular release on github.

Tutorials

Deeplearning.ai’s Event-Driven Agentic Document Workflows from LlamaIndex

Build an event-driven agentic workflow that parses forms, retrieves relevant information from a source document using RAG, and returns answers to the form’s fields as structured outputs.

Deeplearning.ai’s Long-Term Agentic Memory with LangGraph from LangChain

Build a personal email agent with routing, writing, scheduling tools to automatically ignore, respond to, or notify about incoming emails.

RealPython’s LangGraph: Build Stateful AI Agents in Python

Here is another tutorial regarding LangGraph.

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 Python’s Instance, Class, and Static Methods Demystified

Instance, class, and static methods each serve a distinct role in Python, and knowing when to use one over another is key to writing clean, maintainable code. Instance methods operate on individual objects using self, while class methods use cls to access class-level data. Static methods, on the other hand, provide organizational structure without relying on class or instance state.

RealPython’s Python Code Quality: Best Practices and Tools

In this tutorial, you’ll learn about code quality and the key factors that make Python code high-quality. You’ll explore effective strategies, powerful tools, and best practices to elevate your code to the next level.

Articles

Performance of the Python 3.14 tail-call interpreter

The CPython project’s new tail-call interpreter initially showed a 10 - 15% performance boost. However, the author found this was mainly due to an LLVM 19 regression. When benchmarked against better baselines, the gain dropped to 1 - 5%. The LLVM 19 regression affected the bytecode interpreter’s optimization. Also, the “computed goto” approach might be unnecessary for modern Clang.

New tools for building agents

OpenAI introduces their new approach on building agents systems: the new Responses API which would replace Assistants API, a new Python SDK as a agents framework, and more.

Google’s Gemma 3

Latest iteration of Google’s open-weight LLM includes four sizes from small to medium: 1B, 4B, 12B, and 27B. Here’s the technical report.

Mistral Small 3.1

Mistral releases its newest “small” (24B) multi-modal, multilingual LLM, claiming it “outperforms comparable models like Gemma 3 and GPT-4o Mini, while delivering inference speeds of 150 tokens per second”.

Its “instruct” variation’s weight is obtainable from HuggingFace.

A Deep Dive Into MCP and the Future of AI Tooling

This article delves into the Model Context Protocol (MCP), an open protocol aiming to standardize AI model interactions with tools. Inspired by LSP, MCP supports autonomous AI workflows and human-in-the-loop operations. It has various use cases in dev-centric workflows and net-new experiences. However, the MCP ecosystem is in its early stage, facing challenges like authentication, authorization, and server discoverability. If these issues are resolved, MCP could reshape AI-tool interactions, leading to new pricing models, hosting modes, and a shift in tool development and consumption.

Introducing KBLaM: Bringing plug-and-play external knowledge to LLMs

KBLaM is a new approach to integrate structured knowledge bases into pre-trained LLMs. Traditional methods like fine-tuning and RAG have drawbacks, and in-context learning has computational issues. KBLaM converts knowledge bases into continuous key-value vector pairs and uses rectangular attention for efficient integration. It’s scalable, with linear cost and dynamic updates. KBLaM also enhances interpretability and reliability, reducing hallucinations. It paves the way for more reliable AI systems in critical fields.

Podcasts

🥝 core.py

🐍 RealPython Podcast

🥧 Python Bytes Podcast

🦜 Talk Python to me

🍕 Pybites Podcast

Tools

Warp on Windows

Warp is one of my favorite new toys in year 2024, and now it comes to Windows platform. Check their blog!

Cherry Studio 1.1.10

Cherry Studio catches quite a lot of eyes recently, and it just reaches 1.0 not too long ago. official download

Repositories

`lmstudio-python` (MIT)

I personally have been using LM Studio for roughly one year, and this lmstudio-python (alongside lmstudio-js for JavaScript) is their official SDK with which you can easily manage the models, conversations and more using pure Python code. They have documentations too: docs.

The source code is hosted on github.

`openai-agents-python` (MIT)

OpenAI’s latest contribution to open-source includes this framework for creating multi-agent workflows. This is also among the new toys from OpenAI which I mentioned earlier in this issue.

The source code is on github, and the documentation too.

Update: The Agents SDK has support for MCP, which means you can now connect MCP servers to Agents.

`smolagents` (Apache-2.0)

Another light-weight (“smol”) framework which helps you build AI agents, brought by the HuggingFace team.

Here’s the repostitory

`DeepSeek-V3-0324`

The is an updated version of V3, released just this March. The weights can be found on HuggingFace

`Qwen2.5-Omni-7B`

Qwen team has released their version of “omni” model on HuggingFace.

Have time for some fun?

Command & Conquer games go open-source

Despite their infamous and disastrous management on this beloved franchise, EA chose to open-source some of the classic C&C games on github, potentially enriching the Modding community support.

Here are the repositories (Mostly C++, plus some C, Assembly and others; under GNU GPL v3):

Death Stranding 2: On the Beach (finally) has a launch date

It would be on the shelves on June 26th (or 24th for Deluxe Edition owners), 2025 for Playstation only (… for a while at least), and the pre-order starts March 17th.

The price starts from 69.99 USD, 79.99 EUR, 568 HKD or 8,980 JPY.

More details can be found in this playstation blog.

StarCraft goes to tabletop

In their blog, Archon Studio announced an official partnership with Blizzard Entertainment, launching a StarCraft tabletop miniatures game in 2026, followed by board games set in the StarCraft universe in 2027.

More details, like miniature previews and gameplay mechanics, will be revealed later in 2025.

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

[one-liner] Install Ollama

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

One-Liner series: Ollama

source: ollama.com

Install on Ubuntu

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

Install a specific version

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

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

pip install modelscope

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

cd ollama-linux

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

./ollama-modelscope-install.sh`

Update on Ubuntu

Run the same command as above

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

Uninstall on Ubuntu

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

sudo rm $(which ollama)

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

UV is the latest attempt to rule All Python tools

Zeyang Lin — Wed, 21 Feb 2024 07:23:13 GMT

In short, uv is a command line tool written in Rust for Python developers, which aims to be “a comprehensive project and package manager that is extremely fast, reliable, and easy to use”.

If you are still interested, I hope you can spend a couple of minutes so that I can give you a quick tour of it.

Quick fact sheet

language: Rust

version: 0.1.13 (at the time of updating this post)

repo: github (6k stars)

pypi: pypi

docs: N/A

supported python versions: 3.8 through 3.12 (inclusive)

supported os: Windows, Linux, MacOS

Drop-in replacement for pip and more

uv is from the creator of ruff, Charlie Marsh and astralsh.

ruff, the linting and formating tool written is Rust as well, has already gain fame and popularity during the past year or so, and I believe many of Python developers have been using it for quite a while.

And uv is no doubt their next step in improving the Python toolchain eco.

Although you can easily install uv using pip or pipx just like any other Python tool, essentially it does not rely on your Python interpreter to be installed.

It provides just the binary executable and you can get it easily by running the quick script following the insructions in its git repo. And that’s it, no Python or Rust runtime required till this point.

Creating a virtual environment is now as easy as uv venv, though you now need at least one Python interpreter ready to make it work.

The virtual env it creates is just a standard Python venv, except it does not include pip by default (however if you need pip, you can let it be included by using an extra flag, or you could install it manually anytime after).

Some of your daily commands can then be like (but faster):

uv pip install -r requirements.txt
uv pip install black==24.2.0
uv pip compile pyprojects.toml -o requirements.txt

Fast in deed

Just like ruff is known as being an extremely fast linter, uv’s speed is also impressive.

Here is a short requirements.txt from one of my repos:

fastapi==0.109.2
pydantic[email]==2.6.1
python-multipart==0.0.9
uvicorn[standard]==0.27.1

coverage>=7.4.0
httpx>=0.26.0
memray>=1.11.0
pytest>=8.0.0

And I gave uv a try using github actions. The result on ubuntu-latest with Python 3.12 looks like this

> Run uv pip install -r requirements.dev.txt
Resolved 40 packages in 185ms
Downloaded 40 packages in 268ms
Installed 40 packages in 24ms
 + annotated-types==0.6.0
 + anyio==4.3.0
 + certifi==2024.2.2
 + click==8.1.7
 + coverage==7.4.2
 + dnspython==2.6.1
 + email-validator==2.1.0.post1
 + fastapi==0.109.2
 + h11==0.14.0
 + httpcore==1.0.3
 + httptools==0.6.1
 + httpx==0.26.0
 + idna==3.6
 + iniconfig==2.0.0
 + jinja2==3.1.3
 + linkify-it-py==2.0.3
 + markdown-it-py==3.0.0
 + markupsafe==2.1.5
 + mdit-py-plugins==0.4.0
 + mdurl==0.1.2
 + memray==1.11.0
 + packaging==23.2
 + pluggy==1.4.0
 + pydantic==2.6.1
 + pydantic-core==2.16.2
 + pygments==2.17.2
 + pytest==8.0.1
 + python-dotenv==1.0.1
 + python-multipart==0.0.9
 + pyyaml==6.0.1
 + rich==13.7.0
 + sniffio==1.3.0
 + starlette==0.36.3
 + textual==0.52.1
 + typing-extensions==4.9.0
 + uc-micro-py==1.0.3
 + uvicorn==0.27.1
 + uvloop==0.19.0
 + watchfiles==0.21.0
 + websockets==12.0

As you can see, this process, including solving the dependencies, downloading them and installing them, took just less than half a second!

Features in need

uv’s vision, according to the blog, is

a single binary that bootstraps your Python installation and gives you everything you need to be productive with Python, bundling not only pip, pip-tools, and virtualenv, but also pipx, tox, poetry, pyenv, ruff, and more.

And appearantly at the current point, it is still quite far away from that.

The only two major top-level sub-commands the cli currently supports are

venv
pip
cache

It thus can only create a virtual environment, install dependencies into it and outputs a “lock” file, etc.

I want it to list installed packages, or run commands using the interpreter inside the virtual env, just like what poetry is capable of right now.

Not to mention that it cannot run tests, switch virtual environments or lint source files.

But it’s still in its early age, and the pace is like one patch version every couple of days, isn’t it?

What about Rye

The ambitions of uv share a lot with those from Rye, a tool (which happens to be written in Rust as well) created by Armin Ronacher, the creator of Flask.

What’s more, the team behind uv, astralsh, is actually taking over the dev work of Rye according to their blog, and ultimately going to migrate Rye to uv in the future.

We saw this as a rare opportunity to team up, and to avoid fragmenting the Python ecosystem. As such, in collaboration with Armin, we’re excited to be taking over Rye. Our goal is to evolve uv into a production-ready “Cargo for Python”, and to provide a smooth migration path from Rye to uv when the time is right.

Some thoughts

The name uv seems not relevant to libuv, uvloop or uvicorn.

Maybe it’s short for “universal/ultimate/unified virtualenv manager”?

The dedicated docs pages of uv are not present at the time of writing, which is a pitty.

References

MOJO Series #1: Install SDK on UBUNTU

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

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

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

System Requirements

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

My environment

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

Install steps

1. Install Modular CLI

# switch to root first
sudo -u root -i

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

# switch back to normal user
exit

2. Verify `modular` is installed

which modular

/usr/bin/modular

3. Install Mojo SDK

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

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

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

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

🔥 Mojo installed! 🔥

Now run the following commands if you are using bash:

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

If you are using ZSH, run the following commands:

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

Then enter 'mojo' to start the Mojo REPL.

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

4. Add mojo to PATH

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

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

source ~/.bashrc

Now verify mojo command is accesible:

which mojo

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

5. Mojo REPL

mojo

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

Bonus Round: directory structure

tree $MODULAR_HOME

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

26 directories, 133 files

References

Modular Developer Console

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

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

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

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

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

System Requirements

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

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

那我自己的环境如下

My environment

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

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

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

安装步骤

1. 安装 Modular CLI

Modular CLI 是安装 mojo 的前置条件

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

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

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

2.验证 `modular` 已经安装

在命令行执行：

which modular

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

/usr/bin/modular

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

3.安装 Mojo SDK

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

在命令行执行：

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

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

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

< 中间省略掉 >

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

🔥 Mojo installed! 🔥

Now run the following commands if you are using bash:

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

If you are using ZSH, run the following commands:

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

Then enter 'mojo' to start the Mojo REPL.

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

4.添加 `mojo` 到 `PATH`

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

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

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

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

which mojo

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

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

5. 体验 Mojo REPL

在命令行执行：

mojo

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

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

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

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

tree $MODULAR_HOME

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

26 directories, 133 files

本文参考了

Modular Developer Console

[one-liner] Install Julia (juliaup)

Zeyang Lin — Tue, 16 May 2023 14:36:16 GMT

One-Liner series: juliaup

source: julialang.org

Install on Ubuntu

curl -fsSL https://install.julialang.org | sh

Update on Ubuntu (via ‘release’ channel)

juliaup update release

[one-liner] Install Rust (Rustup)

Zeyang Lin — Tue, 16 May 2023 14:24:06 GMT

One-Liner series: Rustup

source: rust-lang.org

Install on Ubuntu

curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

Update on Ubuntu

rustup update

[one-liner] Install Node.js and NPM

Zeyang Lin — Sat, 07 May 2022 14:06:58 GMT

One-Liner series: Node.js and NPM

Option 1: DEB package through apt

source: nodesource github

Install on Ubuntu

curl -fsSL https://deb.nodesource.com/setup_24.x | sudo -E bash -
sudo apt install -y nodejs

Install on Debian, as root

curl -fsSL https://deb.nodesource.com/setup_24.x | bash -
apt install -y nodejs

Option 2: Through NVM (Node Version Manager)

source: nodejs.org

# Install NVM
curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.40.3/install.sh | bash

# Download and install Node.js
nvm install 24

[one-liner] Install minikube, kubectl and kustomize

Zeyang Lin — Wed, 23 Jun 2021 09:33:22 GMT

One-liner series: minikube, kubectl and kustomize

OS	Shell
Ubuntu 20.04 amd64	Bash

Install minikube

source

As Binary

curl -LO https://storage.googleapis.com/minikube/releases/latest/minikube-linux-amd64

sudo install minikube-linux-amd64 /usr/local/bin/minikube && rm minikube-linux-amd64

As DEB

curl -LO https://storage.googleapis.com/minikube/releases/latest/minikube_latest_amd64.deb

sudo dpkg -i minikube_latest_amd64.deb

Install kubectl

source

curl -LO "https://dl.k8s.io/release/$(curl -L -s https://dl.k8s.io/release/stable.txt)/bin/linux/amd64/kubectl"

sudo install -o root -g root -m 0755 kubectl /usr/local/bin/kubectl

To download a specific version, replace the $(curl -L -s https://dl.k8s.io/release/stable.txt) portion of the command with the specific version. eg. v1.30.0: curl -LO https://dl.k8s.io/release/v1.30.0/bin/linux/amd64/kubectl

Install kustomize

source

curl -s "https://raw.githubusercontent.com/kubernetes-sigs/kustomize/master/hack/install_kustomize.sh"  | bash

sudo install -o root -g root -m 0755 kustomize /usr/local/bin/kustomize

Setup command-line completion for minikube

source

sudo su root && minikube completion bash > /etc/bash_completion.d/minikube

Setup command-line completion for kubectl

source

sudo kubectl completion bash > /etc/bash_completion.d/kubectl

Setup command-line completion for kustomize

sudo kustomize completion bash > /etc/bash_completion.d/kustomize

[one-liner] Install Docker Engine community and docker-compose

Zeyang Lin — Wed, 23 Jun 2021 08:11:39 GMT

One-Liner series: Docker and docker-compose

OS	Shell
Ubuntu Server 22.04 Jammy	Bash

Install Docker Engine community

source

curl -fsSL https://get.docker.com -o get-docker.sh && sudo sh ./get-docker.sh

docker-compose is now installed along with docker engine, and becomes docker compose. However docker-compose can still be installed as a stand-alone binary:

sudo curl -SL https://github.com/docker/compose/releases/download/v2.27.0/docker-compose-linux-x86_64 -o /usr/local/bin/docker-compose

Linux on BlueberryPy

[one-liner] Install OpenCode

One-Liner series: OpenCode

Install on Linux, macOS

Install on Windows

Install with npm

Install with chocolatey

Verify installation

Update

[one-liner] Install Bun

One-Liner series: Bun

Install on Linux and macOS

Install on Windows (PowerShell)

Update

[one-liner] Install pnpm

One-Liner series: pnpm

Install on POSIX systems (except Intel Macs (darwin-x64))

Install on Windows (PowerShell)

Update

This Month for Pythonistas - April 2026

Events & Social

DjangoCon Europe 2026

New Versions

Tutorials

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

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

DeepLearning.ai’s Building Multimodal Data Pipelines from Snowflake

RealPython’s Variables in Python: Usage and Best Practices

Articles

Podcasts

🥝 core.py

🐍 RealPython Podcast

🥧 Python Bytes Podcast

🦜 Talk Python to me

🚀 VS Code Insiders Podcast

Repositories

NousResearch/hermes-agent (MIT)

dropseed/plain (BSD-3)

smelloscope/smello (MIT)

This Month for Pythonistas - March 2026

Events & Social

New Versions

Python 3.15.0 alpha 7

Tutorials

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

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

Articles

Podcasts

🐍 RealPython Podcast

🥧 Python Bytes Podcast

🦜 Talk Python to me

🍕 Pybites Podcast

🚀 VS Code Insiders Podcast

Repositories

This Month for Pythonistas - February 2026

Events & Social

New Versions

Python 3.15.0 alpha 6

transformers 5

isort 8

Tutorials

Deeplearning.ai’s Agent Skills with Anthropic by Anthropic

Deeplearning.ai’s A2A: The Agent2Agent Protocol by Google Cloud and IBM

Articles

Podcasts

🐍 RealPython Podcast

🥧 Python Bytes Podcast

🦜 Talk Python to me