📅 Today’s Picks

Claude Code: Run Tasks to Completion with /goal

Problem

Starting a task in Claude Code often means spending multiple turns going back and forth before it finally reaches the result you wanted.

Solution

Claude Code’s /goal command lets you define a completion condition once, then continues working until that condition is met.

After each turn, a lightweight model evaluates the conversation against your condition. If the goal is not satisfied, Claude gets sent back for another turn with a short explanation of what still needs to be done.

To get the most out of /goal, write a condition the evaluator can actually verify.

• Name a measurable end state instead of a vague target (e.g. “all tests in test/auth pass” instead of “auth is working”)

• List constraints that must hold along the way (e.g. “no other test file is modified” or “no tests are skipped or deleted”)

• Add a safety limit like “stop after 20 turns” to avoid endless iterations.

📖 View The Docs

smolagents: Build an AI Agent in 4 Lines of Code

Problem

LangChain and LangGraph are powerful, but they also come with concepts like chains, runnables, and state graphs.

That is useful for complex workflows, but overkill when you just want to give a model a tool and let it solve a task.

Solution

smolagents from Hugging Face is a barebones agent library designed for simplicity.

In roughly 1,000 lines of code, it gives you the core pieces needed to build a working agent with a single import and three lines of setup.

Key features:

• Agents act by writing Python in a sandbox, the same way you’d script a task in a notebook

• Model-agnostic design, swap between OpenAI, Anthropic, local Ollama, or Hugging Face Inference

• Push agents to the Hugging Face Hub to share with the community

💬 Rate Your Experience

How would you rate your newsletter experience? Share your feedback →

🔍 Explore More on CodeCut

• Tool Selector - Discover 70+ Python tools for AI and data science

• Production Ready Data Science - A practical book for taking projects from prototype to production

Introduction

Most Docker images contain far more than a Python application actually needs at runtime. They include full OS layers with shells, compilers, and utilities that often go completely unused, leading to unnecessarily large images that consume storage and slow deployment pipelines.

SlimToolkit analyzes your container at runtime, identifies which files are actually used, and builds a minimal image with only those dependencies.

This article walks through slimming a Chainlit LLM chatbot, but the same approach works on any Python container.

What Is SlimToolkit?

SlimToolkit is a command-line tool that strips unused files from a container image without touching your Dockerfile. It works in two steps:

1. Static analysis. Looks at the image’s contents without running it.

2. Dynamic analysis. Runs the image to see which files the app actually uses.

The first step lists everything in the image. The second narrows that list to what the app actually needs. Everything outside the second list gets stripped.

Install it via the official install script (works on Linux and macOS):

curl -sL https://raw.githubusercontent.com/slimtoolkit/slim/master/scripts/install-slim.sh | sudo -E bash -

Or with Homebrew on macOS:

brew install docker-slim

Verify the install:

slim --version

Output

mint version darwin/arm64|Aurora|1.41.8|latest|latest

💻 Get the Code: The complete source code and Jupyter notebook for this tutorial are available on GitHub. Clone it to follow along!

Build the Chatbot Image

To test SlimToolkit, build a small Chainlit chatbot image first. We’ll write a small Chainlit chatbot, package it with a Dockerfile, and build it.

The Chainlit App

The chatbot app uses two libraries:

• Chainlit: an open-source Python framework for building LLM chat UIs; provides the web interface and message handling

• OpenAI SDK: calls gpt-4o-mini for responses

# app.py
import os
import chainlit as cl
from openai import AsyncOpenAI

client = AsyncOpenAI(api_key=os.environ.get("OPENAI_API_KEY"))


@cl.on_chat_start
async def start():
    cl.user_session.set("messages", [])


@cl.on_message
async def main(message: cl.Message):
    messages = cl.user_session.get("messages")
    messages.append({"role": "user", "content": message.content})

    response = await client.chat.completions.create(
        model="gpt-4o-mini",
        messages=messages,
    )
    reply = response.choices[0].message.content

    messages.append({"role": "assistant", "content": reply})
    cl.user_session.set("messages", messages)

    await cl.Message(content=reply).send()

Here’s what happens when someone uses the chatbot:

• At import time, AsyncOpenAI reads the OPENAI_API_KEY environment variable and constructs the client

• When a new chat session opens, @cl.on_chat_start initializes an empty message list for that session

• When the user types something, @cl.on_message appends it to the history, sends the whole conversation to gpt-4o-mini, stores the reply, and displays it

Before containerizing, let’s test it locally first. Export your OpenAI key:

export OPENAI_API_KEY=sk-...

Then run the app:

chainlit run app.py

Open http://localhost:8000, you should see the Chainlit welcome screen.

The Dockerfile

Pin every dependency in a requirements.txt so the build is reproducible:

# requirements.txt
chainlit==2.11.1
openai==2.16.0

Create a Dockerfile to build the image:

# Dockerfile
FROM python:3.11-slim

WORKDIR /app

COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

COPY app.py .

EXPOSE 8000
CMD ["chainlit", "run", "app.py", "--host", "0.0.0.0", "--port", "8000", "-h"]

Here’s what each step does:

• Pulls python:3.11-slim as the base image

• Installs the pinned dependencies from requirements.txt

• Copies in app.py

• Starts Chainlit on port 8000 when the container runs

Build the image:

docker build -t llm-chatbot:fat .

Verify the image size:

docker images llm-chatbot:fat

Output

IMAGE             ID             DISK USAGE   CONTENT SIZE   EXTRA
llm-chatbot:fat   e8de32dd85d4        308MB             0B

Around 300 MB. Let’s see if we can shrink it with SlimToolkit.

Slim the Image

To slim the image, start with the basic command:

slim build \
    --target llm-chatbot:fat \
    --tag llm-chatbot:slim \
    --env OPENAI_API_KEY=$OPENAI_API_KEY

Each flag plays a role in the slim build:

• --target llm-chatbot:fat: tells slim which image to minify

• --tag llm-chatbot:slim: names the output image

• --env OPENAI_API_KEY=$OPENAI_API_KEY: sets the env var inside slim’s probe container so the module-level AsyncOpenAI() can construct at import time

Here’s what happens when you run the command:

1. Slim inspects the fat image

2. Starts it in a sandbox

3. Sends a GET / probe and records every file the container touches

4. Builds a slim image containing only those files

But the default GET / only loads the chat UI shell. It doesn’t actually send a chat message, so files needed for the chat path (OpenAI’s lazy submodules, httpcore, etc.) get stripped. To trace the chat path too, add --continue-after enter:

slim build \
    --target llm-chatbot:fat \
    --tag llm-chatbot:slim \
    --env OPENAI_API_KEY=$OPENAI_API_KEY \
    --continue-after enter

--continue-after enter pauses slim after the default probe so you can open the chatbot in a browser and send a message; this tells slim what files the chat actually needs.

Now that the chat path runs during the probe, slim keeps openai.resources and httpcore in the final image:

Let’s compare both images:

docker images llm-chatbot

Output

IMAGE              ID             DISK USAGE   CONTENT SIZE   EXTRA
llm-chatbot:fat    e8de32dd85d4        308MB             0B    U
llm-chatbot:slim   e1f5e9b31e53        123MB             0B

Nice! We reduced the image size from 308 MB to 123 MB, about a 2.5x reduction.

Let’s run the slim image with the environment variable and see what happens.

docker run -p 8000:8000 -e OPENAI_API_KEY=$OPENAI_API_KEY llm-chatbot:slim

Output

File "/usr/local/lib/python3.11/site-packages/chainlit/server.py", line 181, in get_build_dir
    raise FileNotFoundError(f"{local_target} built UI dir not found")
FileNotFoundError: libs/copilot built UI dir not found

The error comes from a mismatch between Chainlit and slim:

• Chainlit expects chainlit/copilot/ to exist when the server starts

• Even with --continue-after enter, slim removed chainlit/copilot/ because the chat you exercised in the browser only loaded the main chat UI. The Copilot widget is a separate Chainlit feature; no file inside chainlit/copilot/ was opened during the probe

• Now Chainlit’s startup check finds the directory missing and the container crashes

This is not unique to Chainlit or chat-UI frameworks. Any framework that loads features lazily but checks for them at startup is vulnerable. Django’s admin, FastAPI apps with multiple routers, ML serving frameworks with embedded UIs, and plugin systems all hit the same problem.

Add --include-path for the Chainlit Package

The fix is --include-path, which tells SlimToolkit to preserve a path regardless of whether probing touched it. The path that matters is the whole Chainlit package directory, which contains every feature bundle Chainlit ships:

slim build \
    --target llm-chatbot:fat \
    --tag llm-chatbot:slim \
    --include-path /usr/local/lib/python3.11/site-packages/chainlit \
    --continue-after enter \
    --env OPENAI_API_KEY=$OPENAI_API_KEY

Compare the images again:

docker images llm-chatbot

Output

IMAGE              ID             DISK USAGE   CONTENT SIZE   EXTRA
llm-chatbot:fat    e8de32dd85d4        308MB             0B    U
llm-chatbot:slim   952b6b44df9f        163MB             0B    U

Re-run the image to confirm it works:

docker run -p 8000:8000 -e OPENAI_API_KEY=$OPENAI_API_KEY llm-chatbot:slim

With the chainlit directory preserved, the slim container starts and runs as expected.

Inspecting the Result with slim xray

To see exactly which files slim stripped, run slim xray against both images. It reverse-engineers a built image into a JSON report listing every file, its size, and the layer it came from. Slim always writes its output to slim.report.json, so rename the first report before the second run overwrites it:

slim xray --target llm-chatbot:fat
mv slim.report.json fat.report.json

slim xray --target llm-chatbot:slim

Each report is several megabytes of JSON, which makes manual comparison painful. To handle that, I packaged the diff and summary steps into compare.sh:

bash compare.sh

Here are the biggest deletions, grouped by bucket:

Removed                          Size    Bucket
/usr/bin/perl                    3.8 MB  OS cruft
libapt-pkg.so                    2.4 MB  OS cruft (apt)
ensurepip/pip-24.0.whl           2.1 MB  Python build leftover
libdb-5.3.so                     1.8 MB  OS cruft (apt)
/usr/bin/sqv                     1.6 MB  OS cruft (apt’s PGP verifier)
/usr/bin/bash                    1.4 MB  OS cruft
ensurepip/setuptools-79.0.1.whl  1.3 MB  Python build leftover
multidict/_multidict.so          923 kB  Unused part of aiohttp
jiter/jiter.so                   880 kB  Unused part of openai
pydoc_data/topics.py             775 kB  Python build leftover
aiohttp/_http_writer.so          600 kB  Unused part of aiohttp

The biggest savings come from the Debian base image, not from the Python packages. Of the top 11 deletions:

• Five are base-image binaries: perl, bash, libapt-pkg, libdb-5.3, sqv

• Three are install-time leftovers: bundled pip and setuptools wheels, plus the pydoc help-text database

• Three are write-side or helper modules of runtime libraries the probe didn’t exercise: aiohttp/_http_writer, multidict, jiter

Final Thoughts

A single slim build command took this chatbot from 308 MB to 163 MB. That is one data point on one image. Your numbers will likely look different. The wider the gap between what your image installs and what it actually runs at runtime, the bigger the reduction tends to be. Give it a try on your own images and see what kind of improvement you get.

Related Tutorials

• How to Test GitHub Actions Locally with act: Iterate on a slim-build CI workflow locally before pushing.

• Unregistry: Skip the Registry, Deploy Docker Images Directly: Deploy the slimmed image straight to a server, no registry required.

📚 Want to go deeper? Learning new techniques is the easy part. Knowing how to structure, test, and deploy them is what separates side projects from real work. My book shows you how to build data science projects that actually make it to production. Get the book →

Originally published on CodeCut.

📅 Today’s Picks

Never Use yaml.load() in Python. Here’s Why.

Problem

Has your AI assistant ever suggested yaml.load() to parse a config file?

It’s an easy mistake: yaml.load() looks like a clean way to turn YAML into a Python dict, and AI tools generate it freely because it appears in plenty of legacy code.

But yaml.load() can do more than parse text. It can execute Python objects embedded in the YAML, meaning anyone who controls that file could run shell commands on your machine.

Solution

Use yaml.safe_load() instead. It only supports standard YAML types like mappings, lists, strings, numbers, booleans, and null, and rejects anything that tries to execute code.

To catch unsafe yaml.load() calls automatically, scan your codebase with Bandit.

📖 View Full Article

Context7: Stop AI Agents from Generating Deprecated Syntax

Problem

AI coding assistants often generate code using training data that may already be outdated.

That means if you ask for Polars 1.x code, the model may still generate deprecated 0.x APIs from older training data.

Solution

Context7 solves this by pulling the latest, version-specific library docs directly into the prompt before the assistant writes any code. That way, it generates code against the API that actually exists today.

Other capabilities:

• One command sets it up across Cursor, Claude Code, Copilot, and 30+ clients

• Trigger with use context7 in any prompt

• Runs as either an MCP server or a CLI + skill, so it works with or without MCP support

• Automatically loads version-matched docs like “Polars 1.0

☕️ Weekly Finds

beartype [Code Quality] - Near-real-time pure-Python runtime type-checker. Decorate a function and catch type violations the moment they happen, not after a stack trace.

vulture [Code Quality] - Find dead Python code. Scans your project for unused functions, classes, imports, and variables so you can safely delete them.

pyupgrade [Code Quality] - A tool (and pre-commit hook) that automatically upgrades Python syntax to newer language versions. Drop f-strings, dict literals, and modern type hints in one sweep.

💬 Rate Your Experience

How would you rate your newsletter experience? Share your feedback →

🔍 Explore More on CodeCut

• Tool Selector - Discover 70+ Python tools for AI and data science

• Production Ready Data Science - A practical book for taking projects from prototype to production

📅 Today’s Picks

Bandit: Catch Insecure Patterns in AI-Generated Python Code

Problem

LLMs have become extremely good at generating syntactically valid Python, but security quality has barely improved.

Veracode’s Spring 2026 GenAI Code Security Report found that security pass rates have remained stuck near 55% since 2024.

That gap exists because models learn from public code full of insecure patterns and reproduce them when prompted.

At the same time, reviewers usually verify whether code works, not whether it introduces vulnerabilities.

Solution

Bandit is a static analyzer for Python that identifies insecure patterns by matching code against 60+ Common Weakness Enumeration (CWE) rules.

Key capabilities:

• Flags hardcoded secrets, weak hashes (MD5, SHA1), and unsafe deserialization

• Detects SQL string concatenation, eval, and exec injection risks

• Catches empty except blocks and unpinned Hugging Face downloads

• Integrates with pre-commit hooks and GitHub Actions out of the box

• Maps every finding to a CWE ID so issues stay auditable

📖 View Full Article

llama.cpp: Run LLMs 70% Faster Than Ollama on the Same GPU

Problem

An r/LocalLLaMA benchmark on Qwen-3 Coder 32B (FP16) measured Ollama at 30 tokens/sec and llama.cpp at 52 tokens/sec on the same model and hardware.

Ollama is built on top of llama.cpp, so the core inference engine is identical. The performance gap comes from configuration.

Solution

Ollama ships with conservative defaults designed to work reliably across many systems. llama.cpp exposes the low-level tuning flags so you can optimize specifically for your hardware.

Key flags to tune:

• GPU offload (-ngl 99): put the entire model on your GPU instead of partial offload

• Throughput (--batch-size): bigger means faster prompts but more GPU memory

• Context length (--cache-type-k q4): use less GPU memory per token so longer prompts fit

• Generation speed (-md): run a small helper model alongside your main model for 2-3x faster generation

📖 View Source

☕️ Weekly Finds

scalene [Code Quality] - A high-performance CPU, GPU, and memory profiler for Python with AI-powered optimization proposals.

pymc-marketing [Data Analysis] - Bayesian marketing toolbox in PyMC. Includes Media Mix Modeling (MMM), customer lifetime value (CLV), and buy-till-you-die (BTYD) models.

cronboard [Workflow Automation] - A terminal-based dashboard for managing cron jobs locally and on remote servers. Add, edit, pause, resume, and search jobs from the terminal.

💬 Rate Your Experience

How would you rate your newsletter experience? Share your feedback →

🔍 Explore More on CodeCut

• Tool Selector - Discover 70+ Python tools for AI and data science

• Production Ready Data Science - A practical book for taking projects from prototype to production

📅 Today’s Picks

Slim: Shrink Docker Images by 30x with One Command

Problem

Docker images include the entire OS layer. For a simple Python app, this is unnecessary because it never touches the shells, compilers, and system utilities bundled inside.

This inflates images to hundreds of megabytes, wasting storage and adding time to every deploy.

Solution

Slim automatically analyzes your container at runtime to identify which files are actually used, then builds a minimal image with only essential components.

Slim works alongside Docker, not instead of it:

• Step 1: Build your image with docker build

• Step 2: Minify with slim build your-image

• Step 3: Push the .slim image to your registry

• Your Dockerfile and workflow stay the same

Polars: Vectorize List Column Transformations with list.eval

Problem

When working with list columns, most people reach for apply with a Python lambda that loops over every list row by row.

That approach breaks vectorization, so performance quickly degrades as the dataset grows.

Solution

Polars solves this with list.eval, which runs a full expression against each list using pl.element() and stays fully vectorized.

Key benefits:

• Vectorized per-element transformations without Python loops

• Support for a wide range of expressions, including aggregations like max, mean, and sum

• Composable with other Polars expressions for clean, readable pipelines

📖 View Full Article

☕️ Weekly Finds

pyupgrade [Code Quality] - A tool (and pre-commit hook) to automatically upgrade syntax for newer versions of Python.

doxx [Python Utils] - Expose the contents of .docx files without leaving your terminal. Fast, safe, and smart, with no Office required.

ingestr [Data Processing] - ingestr is a CLI tool to copy data between any databases with a single command seamlessly.

💬 Rate Your Experience

How would you rate your newsletter experience? Share your feedback →

🔍 Explore More on CodeCut

• Tool Selector - Discover 70+ Python tools for AI and data science

• Production Ready Data Science - A practical book for taking projects from prototype to production

📅 Today’s Picks

Mem0: Turn AI Conversations into a Knowledge Graph

Problem

Vector databases store each memory as an independent embedding. You can search for similar text, but they cannot link entities across facts or follow relationships between them.

Store “Alice and Bob are collaborating” and “Alice leads payments” separately, and a vector store cannot recognize that both facts refer to the same Alice.

Solution

Mem0 fixes this by extracting entities and relationships from each conversation.

When you store “Alice and Bob are collaborating” and “Alice leads payments,” Mem0 recognizes that both facts refer to the same Alice and links them in a knowledge graph.

Key capabilities:

• Reads raw conversations and identifies the entities for you

• Relationship tracking between people, projects, and concepts

• A memory layer that grows smarter with every interaction

🧪 Run code

lakeFS: Bring Git-Style Branches and Commits to Cloud Storage

Problem

Cloud storage like S3, Google Cloud Storage, and Azure Blob has no concept of versions, branches, or commits like Git does.

As a result, testing changes can mean copying terabytes of data, and fixing mistakes requires tedious file-by-file restores.

Solution

lakeFS turns your cloud storage into a Git-like repository. You get branches, commits, merges, and instant rollback, all without copying data.

☕️ Weekly Finds

unsloth [LLM] - Fine-tune LLMs 5x faster with 60% less memory using QLoRA, no accuracy loss.

context7 [RAG] - Pulls up-to-date, version-specific docs and code examples straight into your LLM prompts and AI code editors.

Repomix [LLM] - Packs your entire repository into a single AI-friendly file you can paste into Claude, ChatGPT, or Gemini.

💬 Rate Your Experience

How would you rate your newsletter experience? Share your feedback →

🔍 Explore More on CodeCut

• Tool Selector - Discover 70+ Python tools for AI and data science

• Production Ready Data Science - A practical book for taking projects from prototype to production

📅 Today’s Picks

Generate Time-Sortable IDs with Python 3.14’s UUID v7

Problem

UUID4 generates purely random identifiers that lack chronological ordering.

Without embedded timestamps, you need separate timestamp fields and custom sorting logic to organize records by creation time.

Solution

Python 3.14 introduces UUID version 7 with built-in timestamp ordering.

Key features:

• Determine creation order by comparing two UUIDs directly

• Retrieve exact creation time by extracting the embedded timestamp

Pyrefly: Automatic Type Inference for Python

Problem

By default, MyPy ignores untyped function bodies, forcing you to manually annotate variables and return types to get meaningful type checking.

This adds overhead and clutters your code with types that don’t add much value.

Solution

Pyrefly automatically infers return types and local variable types from usage, so you only annotate function parameters and public APIs where it matters.

Other features:

• Lightning-fast type checking built in Rust

• Works with VSCode, Neovim, Helix, Emacs, and Zed

• Recognizes dataclass transforms from attrs, Pydantic, and similar libraries

☕️ Weekly Finds

pyrsistent [Python Utils] - Persistent/Immutable/Functional data structures for Python

wrapt [Python Utils] - A Python module for decorators, wrappers and monkey patching

Shiny for Python [Dashboard] - Build fast, beautiful reactive web applications in Python

💬 Rate Your Experience

How would you rate your newsletter experience? Share your feedback →

🔍 Explore More on CodeCut

• Tool Selector - Discover 70+ Python tools for AI and data science

• Production Ready Data Science - A practical book for taking projects from prototype to production

📅 Today’s Picks

kotaemon: Self-Hosted Document QA with Citations in One Command

Problem

Building a RAG app for document Q&A usually means assembling a parser, vector database, retrieval pipeline, and UI from scratch.

Each piece has its own setup, and getting everything to work together can take hours of debugging.

Solution

kotaemon packages the entire RAG stack into a single Docker image, letting you skip the setup and go straight to asking questions.

Key features:

• Citations linked to exact PDF pages for verifiable answers

• Question answering across multiple documents with figures and tables

• Works with local models or cloud APIs like OpenAI, Azure, and Groq

• Extensible Gradio-based UI with multi-user document management

gws: Replace Bulky MCP Tools with 100+ Modular Skill Files

Problem

Connecting AI agents to Google Workspace through MCP often means injecting every tool definition into each request, even if only a couple are needed.

That overhead quickly eats into the token budget, leaving less room for reasoning and task execution.

Solution

gws solves this by replacing bulky tool definitions with 100+ modular SKILL.md files.

Agents load only the skills they need, keeping the context lean and efficient.

Key features:

• Works with Claude Code, Cursor, Gemini CLI, and other AI agents out of the box

• 100+ skill files covering Google Docs, Sheets, Drive, Calendar, and more

• Agents load only relevant skills instead of full tool definitions

☕️ Weekly Finds

unstructured [RAG] - Turn any document into clean, structured data ready for RAG pipelines and LLM applications.

json_repair [LLM] - Repair malformed JSON from LLMs, APIs, and logs. A drop-in replacement for json.loads() that auto-fixes broken output.

MindsDB [AI Agents] - Query AI models directly from your database using SQL. Connect 200+ data sources to LLMs, ML, and vector operations.

💬 Rate Your Experience

How would you rate your newsletter experience? Share your feedback →

🔍 Explore More on CodeCut

• Tool Selector - Discover 70+ Python tools for AI and data science

• Production Ready Data Science - A practical book for taking projects from prototype to production

📅 Today’s Picks

TimescaleDB: Turn PostgreSQL into a Time-Series Engine with One Extension (Sponsored)

Problem

In standard PostgreSQL, all rows live in one table. As time-series data grows into the millions, queries cannot skip irrelevant data, so even recent lookups scan far more than needed.

Solution

TimescaleDB solves this with hypertables, which automatically partition data into time-based chunks.

Queries only touch the relevant chunks, leaving the rest untouched.

Other capabilities:

• Shrink storage by up to 95% with columnar compression that stays fully queryable

• Faster queries with continuous aggregates that refresh only new data

• Built-in retention policies to automatically remove old data

Guidance: One Function for Clean LLM Labels

Problem

Classification tasks with LLMs can get messy. Instead of a clean label, you might get “Option A”, “The answer is A”, or a full explanation.

Cleaning this up requires extra parsing, retries, and validation that can make your system fragile.

Solution

With Guidance, the select() function constrains the model to return exactly one option from your list.

Key benefits:

• Guarantees output matches one of your predefined options

• Eliminate parsing code and regex patterns

• Works with any list of valid choices

📖 View Full Article

☕️ Weekly Finds

TimesFM [ML] - Pretrained time-series foundation model by Google Research for zero-shot forecasting

timesketch [Data Processing] - Collaborative forensic timeline analysis tool

Orbit [ML] - Bayesian time series forecasting with an intuitive initialize-fit-predict interface

💬 Rate Your Experience

How would you rate your newsletter experience? Share your feedback →

🔍 Explore More on CodeCut

• Tool Selector - Discover 70+ Python tools for AI and data science

• Production Ready Data Science - A practical book for taking projects from prototype to production

📅 Today’s Picks

dotenvx: Commit .env Files to Git Without Leaking Secrets

Problem

A .env file stores configuration like API keys and database URLs in plain text.

Because of that, committing it to git would leak every secret. Teams usually gitignore the file and distribute credentials manually through Slack or password managers instead.

Over time, this leads to secrets being scattered across different places without a clear source of truth.

Solution

dotenvx changes this by encrypting .env files with public-key cryptography.

You can commit the encrypted file to git, and your team only needs a private key (kept in a gitignored .env.keys file) to decrypt it when running the application.

Key capabilities:

• Works with Python, Node, Go, Ruby, Rust, and more via a single CLI

• Encrypts .env files using the same cryptography as Bitcoin (secp256k1)

• Separates environments with .env.production, .env.staging, and .env.ci

• Requires zero infrastructure (no Vault, no KMS, no cloud setup)

Bandit: Find Python Security Flaws with One Pre-Commit Hook

Problem

AI code generators can produce working code in seconds, but they often introduce risky patterns like hardcoding passwords or API keys directly in the source.

These issues can easily slip through a quick review.

Solution

Bandit is a Python security linter that automatically detects vulnerability patterns in your code, from hardcoded secrets to unsafe function calls.

Key capabilities:

• Detects hardcoded passwords, tokens, and API keys

• Flags risky calls like eval, exec, and pickle

• Seamlessly integrates into pre-commit hooks, CI workflows, and editors

• Generates severity-ranked reports so you can prioritize fixes

☕️ Weekly Finds

vulture [Code Quality] - Find dead Python code with confidence-scored static analysis

responses [Testing] - A utility library for mocking out the Python Requests library

beartype [Code Quality] - Unbearably fast near-real-time pure-Python runtime type-checker

💬 Rate Your Experience

How would you rate your newsletter experience? Share your feedback →

🔍 Explore More on CodeCut

• Tool Selector - Discover 70+ Python tools for AI and data science

• Production Ready Data Science - A practical book for taking projects from prototype to production

📅 Today’s Picks

mem0: Auto-Update LLM Memory When Facts Change

Problem

Developers commonly store conversation embeddings in ChromaDB or Pinecone, then retrieve similar chunks before each LLM response.

But these systems do not handle changing information. When facts evolve, they simply accumulate, leaving your AI with conflicting context and no way to resolve it.

Solution

mem0 introduces a smarter memory layer. It identifies contradictions, updates existing knowledge, and ensures only the latest facts are retained.

Key capabilities:

• Extracts structured facts directly from raw conversations

• Conflict resolution that replaces outdated facts instead of duplicating them

• Memory isolation across users, sessions, and agents

• Retrieves context semantically, not just by similarity

Ibis: Write Once, Query 22+ SQL Databases

Problem

Running queries across multiple databases often means rewriting the same logic for each backend’s SQL dialect. A query that works in DuckDB may require syntax changes for PostgreSQL, and another rewrite for BigQuery.

Solution

Ibis removes that friction by compiling Python expressions into each backend’s native SQL. Swap the connection, and the same code runs across 22+ databases.

Key features:

• Write once, run on DuckDB, PostgreSQL, BigQuery, Snowflake, and 18+ more

• Lazy execution that builds and optimizes the query plan before sending it to the database

• Intuitive chaining syntax similar to Polars

📖 View Full Article

☕️ Weekly Finds

doccano [Data Processing] - Open source annotation tool for text classification, sequence labeling, and sequence-to-sequence tasks

Data Formulator [Data Visualization] - AI-powered data visualization tool that transforms and explores data with drag-and-drop charts and AI agents

qsv [Data Processing] - Blazing-fast CLI toolkit for querying, transforming, and analyzing CSV data at scale

💬 Rate Your Experience

How would you rate your newsletter experience? Share your feedback →

🔍 Explore More on CodeCut

• Tool Selector - Discover 70+ Python tools for AI and data science

• Production Ready Data Science - A practical book for taking projects from prototype to production

📅 Today’s Picks

gws: One CLI for Drive, Gmail, Calendar, and Sheets

Problem

Managing Workspace through the browser means clicking through multiple apps just to pull a spreadsheet, check your calendar, and send a follow-up email.

That manual loop adds up fast when you repeat it daily or weekly.

Solution

gws is a CLI that unifies every Workspace service behind simple terminal commands with structured JSON output ready for scripting.

Key capabilities:

• Single interface for Drive, Gmail, Calendar, Sheets, Docs, and more

• JSON output that pipes directly into your existing scripts and workflows

• 100+ AI agent skills that let LLMs orchestrate Workspace tasks programmatically

Autoresearch: Run ML Experiments on Autopilot with Git-Backed Rollback

Problem

Running experiments manually means adjusting one hyperparameter, waiting for training to finish, checking results, and repeating for hours.

Progress stops the moment you step away, and you only explore the narrow set of ideas you thought of.

Solution

Autoresearch is an open-source framework that solves this with an autonomous loop. An AI agent commits each change to git, trains for 5 minutes, and checks whether the model actually improved.

If the metric improves, the change stays. If not, the agent reverts to the last good state automatically.

Key benefits:

• Git-backed snapshots before every experiment for instant rollback

• Structured results log that survives crashes and tracks every attempt

• Continuous looping with no human confirmation needed

☕️ Weekly Finds

PyMC [ML] - Bayesian statistical modeling with advanced MCMC and variational inference algorithms

lifelines [ML] - Survival analysis in Python, including Kaplan-Meier, Nelson-Aalen, and regression

causal-learn [ML] - Causal discovery with constraint-based, score-based, and functional causal model methods

💬 Rate Your Experience

How would you rate your newsletter experience? Share your feedback →

🔍 Explore More on CodeCut

• Tool Selector - Discover 70+ Python tools for AI and data science

• Production Ready Data Science - A practical book for taking projects from prototype to production

📅 Today’s Picks

Codon: One Decorator to Turn Python into C Speed

Problem

Slow Python functions in large codebases are painful to optimize. You might try Numba or Cython, but Numba only works for numerical code with NumPy arrays.

You might try Cython, but it needs .pyx files, variable type annotations, and build setup. That’s hours of refactoring before you see any speedup.

Solution

Codon solves this with a single @codon.jit decorator that compiles your Python to machine code.

Key benefits:

• Works on any Python code, not just NumPy arrays

• No type annotations required since types are inferred automatically

• Compiled functions are cached for instant repeated calls

• Zero code changes beyond adding the decorator

The example below shows the real performance:

• Pure Python: 0.240s

• Codon first call: 0.324s (one-time compilation)

• Codon cached calls: 0.006s (37x faster)

🧪 Run code

Datadog: Trace Bad Data from Dashboard to Root Cause in One View (Sponsored)

Problem

If your pipeline isn’t connected end to end, debugging means jumping between tools and manually tracing the issue. It’s slow and error-prone.

Solution

Instead of jumping between tools, Datadog Data Observability gives you one connected view from ingestion to dashboards.

It does this through:

• Quality Monitoring: catches anomalies like missing rows or stale data automatically

• Jobs Monitoring: gives visibility into Spark and Airflow runs, including failures and cost

• Data and code lineage: traces problems upstream to the source and downstream to every affected dashboard, model, and report

📖 Try Datadog Data Observability

Type Check Your Python Codebase 15x Faster with Pyrefly

Problem

Tools like MyPy and Pyright process files sequentially, so larger codebases lead to longer wait times.

Solution

Pyrefly, Meta’s Rust-based type checker, runs checks in parallel, keeping performance nearly constant as your codebase grows.

Key features:

• Re-checks only changed modules for faster incremental runs

• Automatically infers types for variables and return values

On the PyTorch codebase, Pyrefly completes a full check in 2.4 seconds, about 15x faster than Pyright and 20x faster than MyPy.

📚 Latest Deep Dives

browser-use: Turn Plain English Prompts into Working Browser Automation

Traditional tools like Playwright rely on CSS selectors, tightly coupling your scraper to a site’s HTML. When the site changes, everything breaks and needs to be rewritten.

browser-use takes a different approach. You describe the goal in plain English, and an LLM decides what to click, type, and extract.

In this article, I tested browser-use on two real tasks:

• Finding AI stories on Hacker News and synthesizing themes

• Scraping Newegg for gaming laptops with specific constraints

I share the actual outputs, cost per run, and an honest breakdown of what worked and what didn’t, so you can decide if it fits your use case.

📖 View Full Article

☕️ Weekly Finds

bandit [Code Quality] - A security linter that scans Python code for common vulnerabilities by building and analyzing abstract syntax trees.

scalene [Code Quality] - High-performance CPU, GPU, and memory profiler for Python with AI-powered optimization proposals.

vulture [Code Quality] - Finds unused code in Python programs, including dead functions, classes, variables, and unreachable code blocks.

💬 Rate Your Experience

How would you rate your newsletter experience? Share your feedback →

🔍 Explore More on CodeCut

• Tool Selector - Discover 70+ Python tools for AI and data science

• Production Ready Data Science - A practical book for taking projects from prototype to production

🤝 Collaboration

Give Your AI Agent Live Web Access with Bright Data MCP

With basic search APIs, agents often miss critical context from sources like social platforms, forums, news, and answer engines. That leads to incomplete or outdated responses.

Bright Data’s MCP server unifies all web data access into one interface your AI agent can use directly.

With Bright Data MCP, your AI agent can access:

• Search engines (Google, Bing, more)

• Social media (Twitter/X, Reddit, Instagram, TikTok)

• Web archives (historical web data, years deep)

• Answer engines (ChatGPT, Perplexity, Gemini)

All through one connection.

🔗 Try Bright Data MCP

📅 Today’s Picks

Chandra OCR: From Handwritten Notes to Structured Text in Seconds

Problem

Most OCR tools are designed for printed text and struggle with handwritten notes, especially when they include diagrams, equations, and free-form writing.

Solution

Chandra OCR is built for this exact use case. It extracts text, images, and diagrams from handwritten notes and reconstructs them into clean Markdown or HTML.

How it compares to other OCR tools:

• 85.9% overall on the olmOCR benchmark, outperforming olmOCR 2 (82.4%), GPT-4o (69.9%), Gemini Flash 2 (63.8%), and Mistral OCR (72.0%)

• Scores 89.3% on handwritten math, where most OCR tools struggle

• Supports 90+ languages out of the box

Worktrunk: Give Every AI Agent Its Own Branch in Seconds

Problem

Git worktrees give each agent its own isolated copy of the repo, so multiple agents can edit files simultaneously without conflicts.

But the native commands are verbose and stop at creating the directory. Launching agents, installing dependencies, and cleaning up after merge are all separate manual steps.

Solution

Worktrunk is a CLI that makes git worktrees as easy as branches with just three core commands: switch, list, and remove.

Three commands cover the full lifecycle:

• switch: Create a worktree, run hooks for dependency setup, and launch an agent

• list: See diff status, commit counts, CI state, and AI-generated summaries per branch

• merge: Squash, rebase, or fast-forward to main with automatic worktree and branch cleanup

☕️ Weekly Finds

niquests [Python Utils] - Drop-in replacement for Requests with automatic HTTP/1.1, HTTP/2, and HTTP/3 support, plus WebSocket and SSE built in.

codon [Python Utils] - A high-performance Python compiler that produces native machine code with 10-100x speedups and built-in multithreading support.

whenever [Python Utils] - Modern, type-safe datetime library for Python with a Rust extension for performance, inspired by Temporal.

💬 Rate Your Experience

How would you rate your newsletter experience? Share your feedback →

🔍 Explore More on CodeCut

• Tool Selector - Discover 70+ Python tools for AI and data science

• Production Ready Data Science - A practical book for taking projects from prototype to production

📅 Today’s Picks

mem0: Give Your AI Memory Without Building a Vector DB

Problem

When you build an AI app using the OpenAI or Anthropic API, every conversation starts from scratch with no built-in memory between sessions.

Adding memory yourself with a vector database like ChromaDB requires writing custom extraction, deduplication, and scoping logic on top of the storage layer.

Solution

mem0 handles all of that in a single function call. Just pass in conversations and retrieve relevant memories when needed.

Key features:

• Automatic fact extraction from raw conversations via memory.add()

• Cross-session retrieval with memory.search() in any future conversation

• Automatic conflict resolution when user preferences change over time

🧪 Run code

Browser-Use: Automate Any Browser Task with Plain English

Problem

Most data collection tasks go beyond simple extraction. You need to log in, apply filters, navigate pagination, and then gather results.

Selenium can handle navigation, but it requires maintaining CSS selectors that can easily break when a site changes.

Solution

Browser Use simplifies the entire process. Describe what you want, and it navigates, clicks, types, and extracts automatically.

Key features:

• Natural language task descriptions

• Works with GPT-4, Claude, Gemini, and local models via Ollama

• Structured output with Pydantic models

📚 Latest Deep Dives

How to Test GitHub Actions Locally with act

Debugging GitHub Actions is painfully slow. Every YAML change requires a commit, a push, and a 2-5 minute wait just to find out you missed a colon.

This article introduces act, a CLI tool that runs GitHub Actions workflows locally in Docker containers.

You’ll set up an ML testing pipeline and learn to pass secrets, run specific jobs, and validate workflows in seconds.

📖 View Full Article

☕️ Weekly Finds

open-webui [LLM] - A self-hosted AI platform with built-in RAG, model builder, and support for Ollama and OpenAI-compatible APIs

ragflow [RAG] - An open-source RAG engine with deep document understanding for unstructured data in any format

vllm [MLOps] - A high-throughput, memory-efficient inference and serving engine for LLMs with multi-GPU support

💬 Rate Your Experience

How would you rate your newsletter experience? Share your feedback →

🔍 Explore More on CodeCut

• Tool Selector - Discover 70+ Python tools for AI and data science

• Production Ready Data Science - A practical book for taking projects from prototype to production

🤝 COLLABORATION

Give Your AI Agent Live Web Access with Bright Data MCP

With basic search APIs, agents often miss critical context from sources like social platforms, forums, news, and answer engines. That leads to incomplete or outdated responses.

Bright Data’s MCP server unifies all web data access into one interface your AI agent can use directly.

With Bright Data MCP, your AI agent can access:

• Search engines (Google, Bing, more)

• Social media (Twitter/X, Reddit, Instagram, TikTok)

• Web archives (historical web data, years deep)

• Answer engines (ChatGPT, Perplexity, Gemini)

All through one connection.

🔗 Try Bright Data MCP

📅 Today’s Picks

latexify_py: Turn Python Functions into LaTeX with One Decorator

Problem

Non-programmers cannot easily read Python logic. However, manually converting it to LaTeX is slow and quickly becomes outdated as the code changes.

Solution

latexify_py solves this with a single decorator, generating LaTeX directly from your function so the math stays readable and always in sync with the code.

Key capabilities:

• Three decorators for different outputs: expressions, full equations, or pseudocode

• Displays rendered LaTeX directly in Jupyter cells

• Functions still work normally when called

📖 View Full Article | 🧪 Run code

act: Run GitHub Actions Locally with Docker

Problem

GitHub Actions has no local execution mode. You can’t test a step, inspect an environment variable, or reproduce a runner-specific failure on your own machine.

Each change requires a commit and a wait for the cloud runner. A small mistake like a missing secret means starting the loop again.

Solution

With act, you can execute workflows locally using Docker. Failures surface immediately, making it easier to iterate and commit only when the workflow passes.

📖 View Full Article

☕️ Weekly Finds

json_repair [LLM] - A Python module to repair invalid JSON, especially from LLM outputs, with schema validation support

pyrsistent [Python Utilities] - Persistent, immutable, and functional data structures for Python

prek [Code Quality] - A faster, Rust-based reimagining of pre-commit with monorepo support and parallel hook execution

💬 Rate Your Experience

How would you rate your newsletter experience? Share your feedback →

🔍 Explore More on CodeCut

• Tool Selector - Discover 70+ Python tools for AI and data science

• Production Ready Data Science - A practical book for taking projects from prototype to production

🤝 COLLABORATION

Give Your AI Agent Live Web Access with Bright Data MCP

With basic search APIs, agents often miss critical context from sources like social platforms, forums, news, and answer engines. That leads to incomplete or outdated responses.

Bright Data’s MCP server unifies all web data access into one interface your AI agent can use directly.

With Bright Data MCP, your AI agent can access:

• Search engines (Google, Bing, more)

• Social media (Twitter/X, Reddit, Instagram, TikTok)

• Web archives (historical web data, years deep)

• Answer engines (ChatGPT, Perplexity, Gemini)

All through one connection.

🔗 Try Bright Data MCP

📅 Today’s Picks

Chronos: Forecast Any Time Series Without Training a Model

Problem

Traditional forecasting requires domain-specific data, feature engineering, and multiple rounds of model tuning.

Solution

Chronos is a family of pretrained time series forecasting models from Amazon Science that deliver zero-shot predictions out of the box.

Simply load a pretrained model and generate forecasts on any time series data, with no fine-tuning required.

If zero-shot accuracy isn’t enough, you can fine-tune on your data with AutoGluon in a few lines.

🧪 Run code

altimate-code: The Missing AI Layer for Data Engineering Teams

Problem

General AI tools can write SQL and catch obvious mistakes. But they cannot systematically detect anti-patterns, trace lineage, or keep warehouse costs under control.

That gap can lead to inefficient queries, broken dependencies, and hidden compliance risks building up over time.

Solution

I recently tried altimate-code, an open-source agent with 100+ tools purpose-built for data engineers, and built a demo repo to test it.

From a single prompt, it generated a full dbt project with staging, intermediate, and mart layers, added automated tests, and built an interactive dashboard.

What makes it different:

• 100+ tools that analyze SQL through structural parsing, not text guessing

• Works across your stack including Snowflake, BigQuery, Databricks, DuckDB, and more

• Model-agnostic. Compatible with OpenAI, Anthropic, Gemini, Ollama, and others

🧪 Demo repo

☕️ Weekly Finds

timesfm [Machine Learning] - Pretrained time series foundation model by Google Research for zero-shot forecasting

darts [Machine Learning] - A Python library for user-friendly forecasting and anomaly detection on time series

orbit [Machine Learning] - A Python package for Bayesian time series forecasting with probabilistic models under the hood

💬 Rate Your Experience

How would you rate your newsletter experience? Share your feedback →

🔍 Explore More on CodeCut

• Tool Selector - Discover 70+ Python tools for AI and data science

• Production Ready Data Science - A practical book for taking projects from prototype to production

📅 Today’s Picks

Polars scan_csv: Merge CSVs with Different Schemas in One Call

Problem

Polars’ scan_csv lets you load multiple CSV files lazily, reading data only when needed.

But before v1.39.0, every file had to share the same columns, or you’d get a SchemaError.

Solution

Polars v1.39.0 introduces missing_columns="insert" in scan_csv, allowing you to combine multiple files in one call while null-filling any missing columns.

📖 View Full Article | 🧪 Run code

Build Professional Python Packages with UV --package

Problem

Python packages turn your code into reusable modules you can share across projects.

But building them requires complex setup with setuptools, managing build systems, and understanding distribution mechanics.

Solution

UV, a fast Python package installer and resolver, reduces the entire process to 2 simple commands:

• uv init --package sets up your package structure instantly

• uv build and uv publish to create and distribute to PyPI

📖 Dive deeper in Production Ready Data Science

📚 Latest Deep Dives

uv vs pixi: Which Python Environment Manager Should You Use for Data Science?

uv installs Python packages from PyPI, but it doesn’t support compiled C/C++ libraries.

The typical workaround is to install system libraries separately using an OS package manager, then manually align versions with your Python dependencies. Since these system dependencies aren’t captured in project files, reproducing the environment across machines can be unreliable.

pixi solves this by managing both Python packages from PyPI and compiled system libraries from conda-forge in a single tool.

Quick comparison:

• uv: fast, reliable lockfiles, Python-only

• conda: system libraries supported, but slower and no lockfiles

• pixi: fast, unified, with system libraries, lockfiles, and a built-in task runner

In this article, I compare uv and pixi on a real ML project so you can see how they perform in practice.

📖 View Full Article

☕️ Weekly Finds

datachain [Data Processing] - Process and curate unstructured data from cloud storages using local ML models and Python

label-studio [Data Processing] - Open source data labeling and annotation tool with standardized output format for ML workflows

qsv [Command Line] - Blazingly fast CSV command-line toolkit for slicing, dicing, and analyzing tabular data

💬 Rate Your Experience

How would you rate your newsletter experience? Share your feedback →

🔍 Explore More on CodeCut

• Tool Selector - Discover 70+ Python tools for AI and data science

• Production Ready Data Science - A practical book for taking projects from prototype to production

📅 Today’s Picks

vLLM: Serve More LLM Users on the Same GPU

Problem

Most frameworks reserve GPU memory for the longest possible response, even when the actual output is short.

With multiple concurrent users, this quickly fills the GPU with reserved memory that is mostly never used.

Solution

vLLM’s PagedAttention allocates memory in small blocks as the response grows, instead of reserving everything up front.

This keeps memory usage efficient and allows the GPU to serve more requests.

Handle Messy Data with RapidFuzz Fuzzy Matching

Problem

Traditional regex approaches require hours of preprocessing but still break with common data variations like missing spaces, typos, or inconsistent formatting.

Solution

RapidFuzz eliminates data cleaning overhead with intelligent fuzzy matching.

Key benefits:

• Automatic handling of typos, spacing, and case variations

• Production-ready C++ performance for large datasets

• Full spectrum of fuzzy algorithms in one library

📖 View Full Article | 🧪 Run code

☕️ Weekly Finds

TextAttack [NLP] - Python framework for adversarial attacks, data augmentation, and model training in NLP

stanza [NLP] - Stanford NLP Python library for tokenization, sentence segmentation, NER, and parsing of 60+ languages

GLiNER2 [NLP] - Unified schema-based framework for entity extraction, text classification, and relation extraction in one pass

💬 Rate Your Experience

How would you rate your newsletter experience? Share your feedback →

🔍 Explore More on CodeCut

• Tool Selector - Discover 70+ Python tools for AI and data science

• Production Ready Data Science - A practical book for taking projects from prototype to production

📅 Today’s Picks

Scrapling: Adaptive Web Scraping in Python

Problem

Traditional scraping with BeautifulSoup uses hardcoded CSS selectors to find elements on a page.

If the site updates its layout, those selectors no longer match and the scraper ends up returning empty data.

Solution

Instead of relying only on selectors, Scrapling records how elements appear during the initial scrape.

If the site is redesigned later, it can use that stored structure to find the same elements again.

Ibis: One Python API for 25+ Database Backends

Problem

Many data workflows begin with pandas for quick experimentation, while production pipelines might run on databases like PostgreSQL or BigQuery.

Moving from prototype to production usually means rewriting the same transformation logic in SQL. That translation takes time and can easily introduce errors.

Solution

Ibis solves this by letting you define transformations once in Python and compiling them into native SQL for 25+ backends automatically.

📖 View Full Article

☕️ Weekly Finds

Kronos [Machine Learning] - A decoder-only foundation model pre-trained on K-line sequences for financial market forecasting

pixi [Environment Management] - Fast, cross-platform package manager built on the Conda ecosystem, written in Rust

MinerU [OCR/PDF Processing] - One-stop tool for converting PDFs, webpages, and e-books into machine-readable markdown and JSON

💬 Rate Your Experience

How would you rate your newsletter experience? Share your feedback →

🔍 Explore More on CodeCut

• Tool Selector - Discover 70+ Python tools for AI and data science

• Production Ready Data Science - A practical book for taking projects from prototype to production