Agentic on BlueberryPy

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.

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

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!

Agentic on BlueberryPy

This Month for Pythonistas - January 2026

Events & Social

EuroPython 2026 Location Revealed

New Versions

Python 3.15.0 alpha 5

Pandas 3.0.0

FastMCP 3.0.0 beta 1

Tutorials

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

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

RealPython’s How to Build a Personal Python Learning Roadmap

Articles

How to build self-improving coding agents

Podcasts

🥝 core.py

🐍 RealPython Podcast

🥧 Python Bytes Podcast

🦜 Talk Python to me

🍕 Pybites Podcast

🚀 VS Code Insiders Podcast

Repositories

adamchainz/tprof (MIT)

This Month for Pythonistas - November 2025

Events & Social

PyCon US 2026 CFP is Open

PyCon Ireland 2025

20th anniversary of first ever Django release

New Versions

Tutorials

Articles

Podcasts

🐍 RealPython Podcast

🥧 Python Bytes Podcast

🦜 Talk Python to me

🍕 Pybites Podcast

🚀 VS Code Insiders Podcast

Repositories

Have time for some fun?

Golden Joystick Awards 2025

This Month for Pythonistas - October 2025

Events & Social

OpenAI DevDay 2025

Github Universe 25

New Versions

Python 3.14.0 final

Python 3.15.0 alpha 1

LangChain 1.0 & LangGraph 1.0

CrewAI 1.0

PyTorch 2.9

isort 7.0

Ubuntu 25.10

Tutorials

Articles

Podcasts

🥝 core.py

🐍 RealPython Podcast

🥧 Python Bytes Podcast

🦜 Talk Python to me

🍕 Pybites Podcast

🚀 VS Code Insiders Podcast

Repositories