copyedit is just a personal tool, built with agentic coding, in the spirit of Simon Willison. It prompts an LLM to copyedit text. At first, I wasn’t sure how well it would work, but I’ve been using it to clean up posts here for a while now. It actually works quite well.

There’s likely a plethora of ways to solve this problem (e.g. vale), but I’ve had fun putting this together.

In building it I’ve learned a few things:

• The utility of hijacking a CLI module like Willison’s llm has been immense. There’s a lot of underlying plumbing that comes in handy. At the same time, llm hasn’t clicked as a Python package for me.
• With a bit of prompting, LLMs are pretty good at keeping my general style, but there are a few mannerisms I’m going to need to add to the system prompt, for example leaving off leading ‘Is’ and ‘Its’ on fragments.
• Annoyingly, LLMs don’t seem to comprehend word wrapping, although I should actually test that out. It feels a bit heavyweight to apply AI to that task, so I should probably apply a word-wrapping post-processing step.

Speaking of vale:

Vale is an open-source, command-line tool that brings your editorial style guide to life.

And looks like there’s a good book from Pragmatic Programmers:

Write Better with Vale

Automate Your Style Guides and Lint Prose Like You Lint Code

by Brian P. Hogan

Create consistent content that gives readers confidence with Vale, the open-source prose linter that helps you enforce your style guide automatically. Use battle-tested rules based on freely available, popular style guides, apply your brand’s terms with a custom vocabulary, and integrate Vale into your text editor, Git hooks, and CI pipeline. Catch typos and inclusive-language issues before they ship, and spend your energy on shaping ideas instead of fixing copy. Whether you’re a technical writer working in a docs-as-code environment, or a software engineer who occasionally writes, you’ll ship clean, consistent copy every time.

I’m gonna’ make an investment into Ghostty for some of my agentic coding adventures. This will supplement my long-lived, go-to terminal, iTerm2. Two projects I want to actively explore — Amp and opencode — suggest they fit better with super-modern, graphics accelerated terminal emulators. Also, it’s probably time for me to get out and about a bit in the terminal space. There’s evidence that I’ve been using iTerm2 for at least 13 years 😳!

Mitchell Hashimoto’s “About” statement for the project resonates.

About Ghostty

Ghostty is a terminal emulator that differentiates itself by being fast, feature-rich, and native. While there are many excellent terminal emulators available, they all force you to choose between speed, features, or native UIs. Ghostty provides all three.

In all categories, I am not trying to claim that Ghostty is the best (i.e. the fastest, most feature-rich, or most native). But when I set out to create Ghostty, I felt all terminals made you choose at most two of these categories. I wanted to create a terminal that was competitive in all three categories and I believe Ghostty achieves that goal.

Before diving into the details, I also want to note that Ghostty is a passion project started by Mitchell Hashimoto (that’s me!). It’s something I work on in my free time and is a labor of love. Please don’t forget this when interacting with the project. I’m doing my best to make something great along with the lovely contributors, but it’s not a full-time job for any of us.

Full disclosure, I’m a GitHub sponsor of the iTerm2 project for a token amount monthly.

After picking up Festivitas last year, I enjoyed the app so much that I basically ran it all the time on multiple personal computers.

Meanwhile, Simon Støvring, the Festivitas author, shipped out an email with the following information:

This season, Festivitas turns your Mac into a winter wonderland with snow. Just like the festive lights, the snow is fully customizable so you can create anything from gentle drifting flakes to a full blizzard ❄️

The update will be automatically installed when you launch Festivitas on your Mac.

And for the first time, Festivitas comes to iPhone and iPad with animated festive lights on your Home Screen 🎄📱

Snow on the desktop is pretty cool ⛄️!

I did a quick install and poked around the iOS app. I’m not quite sure I understand how it’s supposed to work, but I’m game to give it some more time. I may just make some in-app purchases to support Simon.

You can search this blog and see that I’ve got a long history with Discogs Data Dumps. Over the years, though, it seems that some glitch would prevent delivery of a dump for a month here or there. I should do an analysis to illustrate the most recent calendar year that had a “complete” set of dumps.

The good news is that 2025 resulted in captures for all twelve months. I’ve been monitoring the Discogs discussion forums, and unfortunately there were continual data-quality issues. Seems like they got solved with the latest captures for November and December. Way to finish strong, Discogs.

Here’s to 2026 being a banner year for Discogs Data Dumps 🤞!

Pola & Bryson’s mix has been in my rotation for a couple of months now. Had some highway time today, and it demanded an audience with CarPlay. It’s of a piece with the work of DJ Marky and Calibre. There’s probably a more fashionable term, but I call it “Soulful DnB”. Definitely drum ’n’ bass at the core: less jump-up, not much toasting, more soulful vocals, and yes, piano licks (yellow shoes …).

FABRIC MIXES

FABRICLIVE presents Pola & Bryson

Rising D&B duo Pola & Bryson launch FABRICLIVE presents, a brand new mix and compilation series paying homage to the iconic FABRICLIVE series, which ran from 2001 to 2018 and became a defining platform for bass music culture in the UK.

It includes lead single, ‘Worlds Apart’ ft. Emily Makis, and the much-awaited follow-up collaboration since 2023’s ‘Phoneline’. More new music comes from Etherwood & Hugh Hardie, Xeonz, Charli Brix and Molecular, not forgetting a jam-packed mix featuring heavyweight names in D&B such as Camo & Krooked, Mefjus and Breakage, alongside newcomers like IYAMAH, Monrroe, and Thread.

Regular readers know I’m in the tank for anything Fabric London. I’ve got a digital version of all 100 releases for both of Fabric and FabricLive, plus a decent collection of the original physical CDs. What I didn’t realize is that this Pola & Bryson episode is the start of a new mix series. I had just read it as another release in the Fabric Presents series.

Looking forward to seeing more from the renewed FabricLive.

Memo to self: download that Fabric Presents Floorplan, stat

Link parkin’: Amp

Why Amp?

Amp is a frontier coding agent for your terminal and editor, built by Sourcegraph.

• Multi-Model: Sonnet, GPT-5, fast models—Amp uses them all, for what each model is best at.
• Opinionated: You’re always using the good parts of Amp. If we don’t use and love a feature, we kill it.
• On the Frontier: Amp goes where the models take it. No backcompat, no legacy features.
• Threads: You can save and share your interactions with Amp. You wouldn’t code without version control, would you?

Amp has 2 modes: smart (unconstrained state-of-the-art model use) and free (free of charge, using fast basic models).

Want to go much deeper? Watch our Raising an Agent podcast that chronicles the first few months of building Amp, and see our FIF.

This post was started before a recent edition of Hamel Husain’s newsletter arrived in my transom today (apologies, can’t find a Web page version to link to). He’s positive on Amp as well:

Even though Cursor is my daily driver, I frequently try new coding agents. One that’s stood out for me over the last few months is Amp. Amp is the Omakase experience of coding agents: the team maniacally experiments with the frontier of coding models, and tweak the tools, system prompt, etc accordingly for you. For example, over the past week they moved the default model from Gemini 3 to Opus 4.5. (BTW all of this is backed by rigorous internal evals, which allows them to move quickly).

Typical of Husain, his email contains much more detail, including caveats for working with Amp. For example, the version of Amp that he uses is priced on a per-token basis. This can get expensive if you’re not careful. Also, he reported that the Amp CLI had problems with iTerm, but works well in Ghostty. Hopefully it’ll be made available somewhere easy to reference.

The field of terminal user-interface coding agents is getting crowded, but Amp is worth watching.

TIL: podcast-archiver

A fast and simple command line client to archive all episodes from your favorite podcasts.

Podcast Archiver takes the feed URLs of your favorite podcasts and downloads all available episodes for you—even those “hidden” in paged feeds. You’ll end up with a complete archive of your shows. The archiver also supports updating an existing archive, so that it lends itself to be set up as a cronjob.

For my retrocast project, I’ve been casting about for a solution to reliably download all the episodes from an RSS feed. aria2 is the current path being pursued. The approach has been to fork aria2 as a subprocess and then feed it episode URLs over one of aria2’s RPC-over-HTTP interfaces. Not as elegant as I’d like.

A trick I’ve picked up is hijacking click‑based CLI projects and blending them into my own CLI projects. Either via eyeball inspection or metaprogramming, it’s easy to grab commands and wire them into my own app. This technique needs some refinement to deal with potential configuration impedance mismatches between CLI toolkits. I’ll go into detail in another post, but I put it to good effect by integrating Simon Willison’s llm package into another personal project. I got the 90% of llm that seamlessly manages models, plugins, prompts, and AI vendor APIs. My extra bits of functionality and porcelain benefit from it.

So next up, let’s apply this to retrocast and podcast-archiver.

Bonus TIL: rich-click

rich-click is a wrapper around Click that renders help output nicely using Rich.

• Click is a “Python package for creating beautiful command line interfaces”.
• Rich is a “Python library for rich text and beautiful formatting in the terminal”.

The intention of rich-click is to provide attractive help output from Click, formatted with Rich, with minimal customization required.

Discovered this because podcast-archiver uses rich-click to implement a pretty text interface. I’m a heavy user of both packages, so this is definitely one to take a look at.

Link parkin’: TaskiPy

The complementary task runner for python.

Every development pipeline has tasks, such as test, lint or publish. With taskipy, you can define those tasks in one file and run them with a simple command.

I’m sort of in the tank for PoeThePoet, but it’s good to be aware of other options. Need to track down a comparison.

Via Vincent Warmerdam

Link parkin’: Onyx

Onyx is a feature-rich, self-hostable Chat UI that works with any LLM. It is easy to deploy and can run in a completely airgapped environment.

Onyx comes loaded with advanced features like Agents, Web Search, RAG, MCP, Deep Research, Connectors to 40+ knowledge sources, and more.

From the docs:

Why Onyx?

Why choose Onyx over ChatGPT, Microsoft Copilot, Google Gemini, or Glean?

• Reliable Responses from Internal Knowledge: Onyx builds a knowledge index using LLM-native techniques. Powered with contextual retrieval, advanced RAG, hybrid search, and AI-generated knowledge graphs, Onyx ensures the most relevant results and the least hallucinations.

• Open Source: Onyx is made for security, data privacy, and ease of self-hosting. It’s easy and free to get started. For teams investing in a long-term GenAI strategy, Onyx can be easily extended or customized to your team’s future needs.

• Highly Configurable: Onyx is designed to be flexible, so you can optimize the experience for your team. Plug and play any LLM model, connect only the data you need, and enable the features you want your team to use.

You can’t have too many options for implementing interfaces for AI applications.

In my agentic coding explorations, I really like the coding agents provided by GitHub Copilot. Here’s the 101 intro.

Earlier this year, GitHub introduced an integrated, enterprise-ready coding agent for Copilot. Coding agent is a software engineering (SWE) agent that runs independently in the background to complete assigned tasks — similar to a peer developer.

The agent starts its work when you hand it a task. Then it spins up a fully customizable development environment, powered by GitHub Actions. You can track it every step of the way, from issue to pull request to review to approval.

The agent is designed to help you offload tasks like fixing bugs, test coverage, or refactoring code, so you can work on what interests you most. ✨

More from the docs:

Benefits over traditional AI workflows

When used effectively, Copilot coding agent offers productivity benefits over traditional AI assistants in IDEs:

With AI assistants in IDEs, coding happens locally. Individual developers pair in synchronous sessions with the AI assistant. Decisions made during the session are untracked and lost to time unless committed. Although the assistant helps write code, the developer still has a lot of manual steps to do: create the branch, write commit messages, push the changes, open the PR, write the PR description, get a review, iterate in the IDE, and repeat. These steps take time and effort that may be hard to justify for simple or routine issues.

With Copilot coding agent, all coding and iterating happens on GitHub as part of the pull request workflow. You can create multiple custom agents that specialize in different types of tasks. Copilot automates branch creation, commit message writing and pushing, PR opening, and PR description writing. Developers let the agents work in the background and then steer Copilot to a final solution using PR reviews. Working on GitHub adds transparency, with every step happening in a commit and being viewable in logs, and opens up collaboration opportunities for the entire team.

The integration with GitHub, no surprise, is excellent and has been working well for me. It’s easy to interact with an agent through a PR. Launching agents based on GitHub Issues is trivial and natural. I can push commits to an agent’s development branch seamlessly. The UX for agent session tracking has been better than what I’ve experienced with Claude Code, Codex, and Jules. Not a huge difference, but the polish feels a notch above.

The only downside so far is that you don’t have any way to specify a particular model to use. Despite that, the code results have been on par with what I’ve seen from other coding agents. In any event, I ponied up for a $10-a-month subscription, and I’m already cranking through features on personal projects. It feels like good value.

Link parkin’: Agor

Think Figma, but for AI coding assistants. Orchestrate Claude Code, Codex, and Gemini sessions on a multiplayer canvas. Manage git worktrees, track AI conversations, and visualize your team’s agentic work in real-time.

TL;DR: Agor is a multiplayer spatial canvas where you coordinate multiple AI coding assistants on parallel tasks, with GitHub-linked worktrees, automated workflow zones, and isolated test environments—all running simultaneously.

Picked this up from an episode of the Data Engineering Podcast featuring Max Beauchemin of Apache Airflow and Apache Superset fame. Definitely give it a listen.

In this crossover episode, Max Beauchemin explores how multiplayer, multi‑agent engineering is transforming the way individuals and teams build data and AI systems. He digs into the shifting boundary between data and AI engineering, the rise of “context as code,” and how just‑in‑time retrieval via MCP and CLIs lets agents gather what they need without bloating context windows. Max shares hard‑won practices from going “AI‑first” for most tasks, where humans focus on orchestration and taste, and the new bottlenecks that appear — code review, QA, async coordination — when execution accelerates 2–10x. He also dives deep into Agor, his open‑source agent orchestration platform: a spatial, multiplayer workspace that manages Git worktrees and live dev environments, templatizes prompts by workflow zones, supports session forking and sub‑sessions, and exposes an internal MCP so agents can schedule, monitor, and even coordinate other agents.

It’s very early days for Agor, but the UX Beauchemin described was interesting. Effectively, he hijacked Kanban cards as a frontend for agent orchestration. The claim is that Agor is great for individual users and is showing promise for teams. Also, a wide range of agentic coders are supported, including Claude Code, Codex, Gemini, and opencode. User interfaces in the orchestration space should be open season for experimentation.

Link parkin’, from Addy Osmani: Gemini CLI Tips & Tricks

This guide covers ~30 pro-tips for effectively using Gemini CLI for agentic coding

Gemini CLI is an open-source AI assistant that brings the power of Google’s Gemini model directly into your terminal. It functions as a conversational, “agentic” command-line tool - meaning it can reason about your requests, choose tools (like running shell commands or editing files), and execute multi-step plans to help with your development workflow.

In practical terms, Gemini CLI acts like a supercharged pair programmer and command-line assistant. It excels at coding tasks, debugging, content generation, and even system automation, all through natural language prompts. Before diving into pro tips, let’s quickly recap how to set up Gemini CLI and get it running.

Tip 16 on integrating shell interaction seems particularly handy. Seems like all the other CLI tools have this in one form or another, but this tip is a good discussion of the utility of the feature.

Previously, I found Gemini CLI to be less effective than Claude Code. Just last week, Google had a raft of AI announcements, including a batch of agentic coding upgrades connected to Gemini CLI.

Gemini 3 Pro is now available in Gemini CLI

We’ve integrated Gemini 3 Pro, our most intelligent model, directly into Gemini CLI to unlock a new level of performance and productivity in the terminal. This powerful combination delivers state-of-the-art reasoning for executing better commands, enhances support for complex engineering work through agentic coding, and enables smarter, more tailored workflows via advanced tool use.

It’s probably time to revisit Gemini CLI, although the passel of agentic coding CLI tools is getting hard to keep track of.

Parul Pandey has a lot of experience with JupyterLab and Notebooks. He switched to marimo and documented the whys and wins.

TL;DR: After years of using JupyterLab, I have moved most of my work to marimo notebooks, a new kind of Python notebook that addresses many long-standing issues with traditional ones. This article covers the reasons behind my transition and how marimo fits naturally into my current workflow, with full gratitude to Project Jupyter for building the notebook ecosystem that shaped data science, research and education.

There’s a lot of content, but it captures much of the marimo upside that has come across my transom. None of the observations were particularly new to me, but it’s good to have them in one place.

Pandey’s point on AI integration covered an item I discussed previously, JupyterAI.

marimo also has some really useful AI-assisted coding features built in, which have been very helpful for me. To be honest, Jupyter also has a JupyterLab extension for AI features called JupyterAI (and yes, I have written about that too), but having AI support built into marimo removes a lot of the friction for me.

JupyterAI is the Jupyter project’s effort to bring in AI capabilities. I just generated some top-level thoughts, but Pandey wrote up his experience, Build Your Own AI Coding Assistant in JupyterLab with Ollama and Hugging Face, in depth. It’s good:

As you can gauge from this article, Jupyter AI makes it easy to set up a coding assistant, provided you have the right installations and setup in place. I used a relatively small model, but you can choose from a variety of models supported by Ollama or Hugging Face. The key advantage here is that using a local model offers significant benefits: it enhances privacy, reduces latency, and decreases dependence on proprietary model providers. However, running large models locally with Ollama can be resource-intensive so ensure that you have sufficient RAM. With the rapid pace at which open-source models are improving, you can achieve comparable performance even with these alternatives.

Armin Ronacher has been working on agentic systems. He’s one of the reasons I’m skeptically optimistic about AI coding agents. His work is a prime example of principled, considerate, measured, and well-informed exploration of the possibilities.

Currently he thinks Agent Design Is Still Hard

TL;DR: Building agents is still messy. SDK abstractions break once you hit real tool use. Caching works better when you manage it yourself, but differs between models. Reinforcement ends up doing more heavy lifting than expected, and failures need strict isolation to avoid derailing the loop. Shared state via a file-system-like layer is an important building block. Output tooling is surprisingly tricky, and model choice still depends on the task.

Lots of goodness and, to be honest, stuff that’s over my head at the moment. I’m definitely not as deep in the weeds as Armin. However, I was struck by this statement:

Testing and Evals

We find testing and evals to be the hardest problem here. This is not entirely surprising, but the agentic nature makes it even harder. Unlike prompts, you cannot just do the evals in some external system because there’s too much you need to feed into it. This means you want to do evals based on observability data or instrumenting your actual test runs. So far none of the solutions we have tried have convinced us that they found the right approach here. Unfortunately, I have to report that at the moment we haven’t found something that really makes us happy. I hope we’re going to find a solution for this because it is becoming an increasingly frustrating aspect of building an agent.

I’m primarily attracted to the plumbing aspects, tracing and observability, but AI evals practice does not seem to be converging on common processes.

L. M. Orchard had an intriguing reference to a narrative table top role playing (TTRP) game, entitled Last Tea Shop Complete

Last Tea Shop Complete is a revised and expanded version of a one-page solo game about tea and conversation. Set up your stall and wait for visitors to emerge out of the mist. Over a cup of tea, chat to the visitor about their life and help prepare them for their trip into the Lands of the Dead. Record their thoughts, fears, dreams and hopes in your journal for posterity.

Orchard put this in a category of solo journaling games. Considering myself a connoisseur of good narrative and a halfway decent writer, this might be a way to cut down on screen time and exercise the creative muscles.

Here’s a quick Kagi search discovery for a definition from Tina Alberion

Solo journaling games are incredibly diverse, but their unifying elements are prompts and recording/documenting. Many solo journaling games allow the player to determine their journaling method. Some strongly recommend a specific method for thematic purposes (like voice recordings for Call Your Exes), but for the most part, players may use a journal, voice or video recordings, or even just their imagination to play.

And a deeper dive from Jordan Rocke

What is a Solo Journaling TTRPG?

OK, so what are they? Basically, it’s a sub-genre of TableTop Role Playing Games (like Dungeons & Dragons, etc). TTRPGs are games where you tell a story with some friends, using some external element to determine how successful you are at doing what your character wants to do. That’s normally dice, but coins, playing cards, tarot cards and other elements are slowly entering the field.

The issue with games like Dungeons & Dragons, and basically all the other big name RPG systems, is that they only function as multiplayer games. Clearly, as being an adult is scheduling hell, a lot of people hit the point where they wanted to try playing games that weren’t reliant on a group of busy people finding time and energy to play. Enter solo TTRPGs! …

Instead, let me try to sell you specifically on solo journaling RPGs! The premise is simple: you are writing an account of your experiences from the perspective of a fictional character. The normal format is that you are given a prompt, and have to write a short (or sometimes long) passage to respond to it. The line between TTRPG and creative writing exercise is a little murky, but it’s fun all the same. The specific ways these games work varies A LOT, and it’s a little difficult to actually summarise in any way that covers all solo journaling RPGs. So, let me take you through some of the games I’ve tried, and maybe you’ll see something interesting!

I think I’ve found a new rabbit hole to fall into.

I’m not huge on affirmations. Lean more towards stoicism than positivity spiritually manifesting success. On a daily basis, though, I try to mentally hold on to a few concise phrases for motivation and emotional guardrails. Shorter is better, and singular words are often best.

Today, I became enamored of the verb hone, defined in Wiktionary as:

Verb

hone (third-person singular simple present hones, present participle honing, simple past and past participle honed)

1. (transitive) To sharpen with a hone; to whet.
2. (transitive) To use a hone to produce a precision bore.
3. (transitive) To refine (a skill especially) by learning.
4. To make more acute, intense, or effective.

The last two meanings resonate. Moment to moment, I’m working to refine myself into a more acute, intense, and effective instrument. Added to the kit.

TIL that click, my favorite CLI processing toolkit, has a mechanism to determine how a CLI option was provided Context.get_parameter_source

Get the source of a parameter. This indicates the location from which the value of the parameter was obtained.

This can be useful for determining when a user specified a value on the command line that is the same as the default value. It will be DEFAULT only if the value was actually taken from the default.

Via Stack Overflow

I’m probably going to spring for MacWhisper Pro.

Quickly and easily transcribe audio files into text with OpenAI’s state-of-the-art transcription technology Whisper as well as Nvidia Parakeet. Whether you’re recording a meeting, lecture, or other important audio, MacWhisper quickly and accurately transcribes your audio files into text.

It got solid marks from Simon Willison. Vincent Warmerdam is only using the free version, but he’s got MacWhisper wired up to a programmatic keyboard. Both gentlemen have good taste in my eyes.

Initially, I’d use it like Warmerdam for agentic coding. If it can be CLI automated, it could become an essential part of the retrocast pipeline.

Herewith, some recommendations of independently published eBooks. If you’re inclined to shop small, give these authors a shout.

Adam Johnson is a Django project committer. He’s written multiple books on DX or “development experience” in my book. Instruction on how developers can improve their experience using certain development tools.

First, the older Boost Your Git DX:

This book covers the best command-line Git tools, techniques, tips, tricks, and tactical tidbits I’ve encountered from over a decade of using Git. The selection reflects my preferences for well-maintained tools that provide high value with little need for customization.

Note that this book is not an introduction to Git and assumes that you’re already using Git on a daily basis. It offers ways to improve your developer experience with Git that ultimately help you code faster.

I bought it a while back and read it end-to-end. Since I’m a magit user on a minute-to-minute basis, much of it wasn’t directly relevant. But I learned a lot about Git, and there are some recommendations I need to implement for those actual terminal interactions with the Git CLI.

Second, the newer Boost Your GitHub DX:

This is a book about using GitHub more effectively, touring you through the fundamental features with my experience-based commentary. It covers settings, keyboard shortcuts, hidden features, syntax, techniques, CLI commands, and even improving your writing. These tools will help you collaborate more effectively with your team and deliver higher-quality software faster.

This book is aimed at anyone using GitHub daily, assuming you have some familiarity with GitHub and Git and want to go deeper.

Purchased but not yet read. As I attempt to push more development onto agentic coders, I’m using GitHub as the central platform to coordinate with systems like Claude Code, Codex, and Gemini. Specifically, I want to heavily leverage issues and PRs to track feature implementation. I bet Adam’s book will come in handy, especially in taking advantage of the GitHub CLI tool.

Third, Michael Kennedy’s Talk Python in Production:

Welcome to Talk Python in Production, a hands-on guide for Python developers determined to master real-world deployment and infrastructure management. Have you ever felt locked into pricey cloud services or struggled with overly complex DevOps configurations? This book’s stack-native approach offers a refreshing alternative.

You’ll learn to containerize Python apps, secure them with NGINX, tap into CDNs for global performance, and manage everything on a single, powerful server, without sacrificing reliability. Along the way, you’ll see exactly how we evolved Talk Python’s own web infrastructure over many years of practical deployment experience. This isn’t just theory: discover cost-saving tips, real-world examples, and step-by-step tutorials you can put to use right away. By the end, you’ll be confident in running your Python applications at scale, with minimal cloud lock-in and maximum control over your technology stack.

My primary interest here is in self-deploying HTTP traffic analytics and uptime monitoring. I’ve got multiple sites on the web and a minor interest in understanding visitors to one or two. I’ve plunked down for Kennedy’s book and am looking forward to getting stuck into it. Full disclosure: I’m a TalkPython fanboy, having bought the course bundle multiple times and listen to the podcast often, along with PythonBytes.

Link parkin’: “Claude Code: Best practices for agentic coding”

Claude Code is a command-line tool for agentic coding. This post covers tips and tricks that have proven effective for using Claude Code across various codebases, languages, and environments.

In particular, I’m looking at extending my own Claude Code environment as documented in this piece to integrate the GitHub CLI.

For repeated workflows—debugging loops, log analysis, etc.—store prompt templates in Markdown files within the .claude/commands folder. These become available through the slash commands menu when you type /. You can check these commands into git to make them available for the rest of your team.

Custom slash commands can include the special keyword $ARGUMENTS to pass parameters from command invocation.

For example, here’s a slash command that you could use to automatically pull and fix a GitHub issue:

I need to do some research on whether this approach or Agent Skills is better. Maybe this note from the skills docs will solve the question:

How Skills are invoked: Skills are model-invoked — Claude autonomously decides when to use them based on your request and the Skill’s description. This is different from slash commands, which are user-invoked (you explicitly type /command to trigger them).

TIL opencode:

The AI coding agent built for the terminal

OpenCode is fully open source, giving you control and freedom to use any provider, any model, and any editor.

As someone who has used Claude Code CLI, Codex CLI, Gemini CLI, and aider, seems like a no-brainer to give opencode a test drive. The only hesitation is the terminal program requirements:

Prerequisites

To use OpenCode, you’ll need:

A modern terminal emulator like:

WezTerm, cross-platform

Alacritty, cross-platform

Ghostty, Linux and macOS

Kitty, Linux and macOS

API keys for the LLM providers you want to use.

I’m quite happy with iTerm2. These are all advanced variations on a terminal, typically with accelerator driven graphics and/or AI integration. Sounds wonderful but a bit heavyweight for me. Hopefully the “like” is applicable to iTerm2.

Via Alex Ellis. His prototype Code Review Bot post is worth a shout as well.

KuzuDB is a professional take on a graph database engine. Also embeddable so sort of like SQLite for graph and vector data.

Unfortunately, the company behind the open source project, up and pulled stakes according to The Register. One of the more annoying possible outcomes of a VC backed project (c.f. Marimo).

The KuzuDB embedded graph database, open source under the MIT license, has been abandoned by its creator and sponsor Kùzu Inc, leaving its community pondering whether to fork or find an alternative.

A few days ago, the GitHub project was archived and a note appeared stating that “Kuzu is working on something new.” In addition, the documentation and blog post archive were moved from the Kuzu website to GitHub.

Since the project was developed with a generous open source license, forking was quite an eminent possibility. Enter LadybugDB:

LadybugDB is a modern graph database designed with a primary focus on object storage. Unlike traditional databases that treat storage as an afterthought, LadybugDB places object storage at the core of its architecture, enabling efficient management of complex, interconnected data structures while maintaining the flexibility and scalability that modern applications demand.

Built on top of KuzuDB, LadybugDB inherits a robust and modular implementation of cypher. KuzuDB was previously developed by Kùzu Inc.

Here’s the repo. The emphasis on object storage takes it in a bit of a different direction though. Now moving into DuckDB territory.

Work on my scrobbledb project has been moving along. As scrobble and track metadata archiving solidifies, the eye turns to how to exploit that data. Given my predilection to DJ mixes on Apple Music, I became curious on what was available to leverage Apple’s music streaming service. Turns out quite a bit.

First off, the Apple Music API

Use Apple Music API to access information about media in the Apple Music Catalog and a user’s personal iCloud Music Library.

• Apple Music Catalog includes all resources available in Apple Music.

• iCloud Music Library contains only those resources the user adds to their personal library. For example, it contains items from Apple Music, songs purchased from iTunes Store, and imports from discs and other apps. This library can include content that’s not in the Apple Music Catalog.

Use this API to retrieve information about albums, songs, artists, playlists, music videos, Apple Music stations, ratings, charts, recommendations, and the user’s most-recently played content. With proper authorization from the user, you can also create or modify playlists and apply ratings to the user’s content.

Matt Palazzolo put together a Python module for the Apple Music API, docs, focused strictly on the catalog. Apparently accessing a user’s iTunes library is a hairier prospect.

Interestingly, the Apple Music API docs point to a bulk metadata download service the Apple Music Feed.

Apple Music Feed contains the catalog content of Apple Music products in bulk for consumption as feed exports. These bulk exports are appropriate for offline use cases, complementing Apple Music API, which is best for online use. Apple Music Feed includes content metadata for albums, songs, artists, and popularity charts, and fully refreshes every 24 hours. You access the Apple Music Feed using Apple Media Feed API to request an export of a data set.

With access to the raw data and the information in this documentation, you can use Apple Music Feed in many ways. For example, if you want to build a discovery engine for Apple Music, your team can examine the data and determine endpoint requests to serve such an engine.

Apple itself provides code examples for the Music Feed.

Clearly this will be relevant to building on top of scrobbledb. Also, seems like a possibility for an MCP server

1Password has a great command line interface (CLI) framework. As my secrets manager of choice, I like to keep API keys in 1Password.

Meanwhile, I also use direnv to automagically establish environment variables in project directories. AI toolkits typically pick up their API keys via environment variables. OPENAI_API_KEY is the canonical example. Direnv picks up the variables to set up via a .envrc file.

Being super lazy, I’d rather not cut and paste from 1Password to append the right information to .envrc. I thought of writing a script from scratch, but then started poking around on the web. Then there’s this interesting comment on GitHub in a repository about connecting direnv and 1Password:

I just found out that you can just do this in .envrc, so I’m actually not sure what’s the main benefit of the plugin if that already works. Maybe I’m missing a use case though.

export MY_SECRET=${MY_SECRET_2:-$(op item get 'db/some-database' --fields password --format json | jq -r .value)}

I asked Claude to turn that one-liner into a script and wound up with this:

#!/bin/bash

# Usage: ./set-env.sh ENV_VAR_NAME OP_ITEM_SPEC [FIELD]

ENV_VAR="$1"
OP_ITEM="$2"
FIELD="${3:-token}"

if [ -z "$ENV_VAR" ] || [ -z "$OP_ITEM" ]; then
    echo "Usage: $0 ENV_VAR_NAME OP_ITEM_SPEC [FIELD]"
    exit 1
fi

EXPORT_LINE="export ${ENV_VAR}=\${${ENV_VAR}:-\$(op item get '${OP_ITEM}' --fields ${FIELD} --format json | jq -r .value)}"

# Check if the variable already exists and update/insert
if grep -q "^export ${ENV_VAR}=" .envrc; then
    # Update existing line
    sed -i.bak "/^export ${ENV_VAR}=/c\\
${EXPORT_LINE}" .envrc
    echo "Updated ${ENV_VAR} in .envrc"
else
    # Append new line
    echo "${EXPORT_LINE}" >> .envrc
    echo "Added ${ENV_VAR} to .envrc"
fi

Next up, hand this off to Claude Code Web to turn it into a Python CLI tool. I’d like to have more introspection and interactive selection of keys.

Generating a Bash script, test driving, then handing off to Claude Code for conversion to Python seems to be a development process that works for me.

From the end of a 3 part series by Sam Ruby Disciplined use of Claude

Reading Reddit and other places, I see lots of people have had problems with Claude, mostly rate limiting and hallucinations. This most definitely has NOT been my experience. I’m on the Claude Max 5x plan, I’ve used it hard for several months with no issues, particularly since Sonnet 4.5 was released. Many have identified strategies making use of various tools and agents. Other than creating a CLAUDE.md file and starting to experiment with skills, I have done none of this.

What I bring to the equation is domain area expertise and discipline. What Claude brings is a broader area of expertise and raw speed, both in analyzing and coding. As I mentioned, others employ various tools to make Claude take a more disciplined approach, Sequential Thinking seems highly recommended, but as I said, I have not had any need or experience with any of this.

The components of discipline are simple: plan, document, and test.

As I’ve been getting in more reps with Claude Code, I’ve independently followed a similar trail to Ruby. I spend a significant amount of time creating plan documents, having the coding agent generate plans along with implementation summaries, and making the agent process error messages to create tests. Helpful confirmation since he’s a way better developer than I am.

Apropos of nothing, feels like I’ve been reading Sam’s work for ages. He was a very early, high quality tech blogger, especially around RSS. He seems to have come back to the trade after exiting a stint with fly.io which is great. Courtesy of him, TIL about Vector. That’s for another post though.

Link parkin’: convert2json, GitHub repo

Utilities for use on the command line to convert BSON, CBOR, CSV, INI, MessagePack, Plist, RSV, TOML, XML, & YAML to JSON. For each supported format, there is a tool for use in a pipe as well as a wrapper that passes the converted input or files in the arguments to jaq or jq for further querying and processing.

This is one of the few tools I’ve seen that’s both fast and reasonably error-resistant for converting XML to JSON.

I have a work in progress repository for turning Discogs Data Dumps, which are big to ginormous, into a DB ingest-friendly format. The dumps are in XML. The goal is XML —> JSONL —> Parquet —> DBs. discogs-xml2db is written in Python, and to date, I have only been able to get it so robust (old datasets are sketchy with mojibake and ill-formed XML) and performant (newer datasets are gigabytes of compressed XML). I’m going to give a coding agent a chance, but I’m not all that hopeful.

In the event that route doesn’t pan out, I’ll fall back to wrapping convert2json, crate, or binary CLI within a Python module. It could be an interesting experiment just by itself.

Speaking of personal projects, I wandered off on a sidequest to create my own CLI tool for copyediting my text. The idea is to have something that can take text in, prompt an LLM to proofread, and ship the result back. Following UNIX norms, the baseline is to read and write to standard input and standard output. After that, it’s bells and whistles.

read more ...

Over the past year or two, I have acquired a taste for loguru, which has excellent documentation, for logging in Python:

Loguru is a library which aims to bring enjoyable logging in Python.

Did you ever feel lazy about configuring a logger and used print() instead?… I did, yet logging is fundamental to every application and eases the process of debugging. Using Loguru you have no excuse not to use logging from the start, this is as simple as from loguru import logger.

Also, this library is intended to make Python logging less painful by adding a bunch of useful functionalities that solve caveats of the standard loggers. Using logs in your application should be an automatism, Loguru tries to make it both pleasant and powerful.

One thing that the loguru package didn’t have out of the box is a way to do configuration from a file. I went poking around on the ’Net and found a somewhat moribund loguru-config package. Support for TOML files was particularly attractive.

Loguru-config is a simple configurator for the Loguru logging library. It extends the functionality of Loguru by allowing the user to configure the logger from a configuration file. This package provides a much-needed feature to Loguru, which is the ability to configure the logger from a configuration file (for example, using loguru alone, one can’t automatically configure the logger to write to sys.stdout or sys.stderr from within a configuration file).

The configuration can have syntax similar to the one used by the native logging library in Python (i.e. support cfg://, ext://, etc.), but extends it to support even more features. It can also be easily extended to support even more features quite easily (see Extending the configurator for more details).

The configurator supports parsing of JSON, JSON5, YAML, and TOML files (out of the box) and can be extended to support other formats (again, see Extending the configurator below).

No commits might have just indicated the work was finished. However, when I tried to put it to work, it didn’t play nicely with modern Python packaging (a. k. a. uv and friends). Also, the TOML package it relied on seems to have not kept up with Python releases, so was effectively end-of-life.

Thus for fun, and reps, I figured I’d try my hand using agentic coding to modernize the codebase a bit. Unsurprisingly, the package name remains the same. It’s just a fork under my GitHub account. Yeah open source! 🎉🎉🎉

For this project, I targeted Codex Cloud. The experience was pretty good even though I’ve been primed by Claude Code as a first impression of agentic coding. Somewhat annoying is the fact that the user can’t add commits to a branch shared with Codex. All of the code has to be generated via prompting the agent. That said I was able to significantly refine the package into a workable state with little effort. And I even got it to generate a bunch of example configuration documents for all of the supported formats!

I need to review the code a bit more, but I already have an existence proof of plugging this config module into another personal project. Of course I did it by simply pointing another coding agent at the URL for my repo, but on first CLI blush, things seem to be working.

If I have some spare cycles, maybe I’ll dig in to the Codex logs and assess what worked, what didn’t, and whether it increased productivity. To be honest though, even if I could have done it faster by hand, I’m not sure it wouldn’t have come out worse, and frankly it was just fun giving this new software development style a whirl.

The following from Kyle Kingsbury is powerful. Read it and share. It deserves wide distribution

I want you to understand what it is like to live in Chicago during this time.

…

Understand what it is to pray in Chicago. On September 19th, Reverend David Black, lead pastor at First Presbyterian Church of Chicago, was praying outside the ICE detention center in Broadview when a DHS agent shot him in the head with pepper balls. Pepper balls are never supposed to be fired at the head because they can seriously injure, or even kill. “We could hear them laughing as they were shooting us from the roof,” Black recalled. He is not the only member of the clergy ICE has assaulted. Methodist pastor Hannah Kardon was violently arrested on October 17th, and Baptist pastor Michael Woolf was shot with pepper balls on November 1st.

I spent nine wonderful years in the greater Chicagoland area. Still have extended family and friends that live there. My heart breaks that such blatant tyranny has come to an iconic American city.

I implemented search here earlier this year, using Pagefind. It’s been working out pretty well for me.

In a nice bit of independent confirmation, Tim Bray, a blogging hero of mine, just recently discovered Pagefind himself, 😲, and used it to replace Google for search on his own site.

Pagefind · Tl;dr: I downloaded it and installed it and it Just Worked out of the box. I’d describe the look and feel but that’d be a waste of time since you just tried it out. It’s fast enough and doesn’t seem to miss anything and has a decent user interface.

How it works · They advertise “fully static search library”, which I assumed meant it’s designed to work against sites like this one composed of static files. And it is, but there’s more to it than that; read on.

Of course Bray has plenty of thoughts on his approach and results. Definitely read on. I picked a bit of intel here:

The one thing that in the rear-view seems unnecessary is that I had to add a data-pagefind-meta attribute to the element at the very bottom of the page where the date is to include it in the result list. There should be a way to do this without custom markup. John Siracusa filed a related bug.

I’ve been desiring to have dates integrated into search on MPR but not the time to figure out. This seems like a hint on where to look.

Bottom line?

Thanks! · To the folks who built this. Seems like a good thing.

Totally agree!

Previously I noticed that Claude had a skill for generative art. Since I’d like to build my own, non-browser, generative art platform I haven’t put it to the test. But it does provide an avenue for experimentation.

Les Orchard also discovered the Claude skill. And he actually used the skill to create some generative art:

Anthropic recently introduced the notion of Agent Skills for Claude, which Simon Willison wrote may be “a bigger deal than MCP”. Figured I should check things out and noticed one of the example skills was for producing algorithmic art. That dovetails nicely with my own noodlings in web-based art sketches. So, I gave it a shot.

Long story short, here’s a sketch I made with Claude’s help, wrapped up as a web component that hopefully works in your browser:

Go visit the post to see the result. I actually find it quite compelling.

He documents his process along the way, which serves as a case study of using agentic coding for generative art. One thing that caught my eye was the desire to capture intermediate results. I’m not sure if there’s a good model between continuous, implicit version capture (expensive, granularity?) and explicit user version commits (human toil). Wonder if an over the shoulder agent could monitor the state of the work and intelligently prompt the user at various points for explicit confirmation?

A final thought from Orchard:

If you’d like the source, I’ve got it up on GitHub. It’s messy and it’s not groundbreaking art, but the process was gratifying. While Claude generated the bulk of the code, I didn’t just sit back: I gave it ideas, did some debugging and coding, and steered things to make it my own.

I don’t listen to too many episodes of Jon Gruber’s The Talk Show. When I do, I find the show’s unofficial transcripts at PodSearch, really useful.

Here’s the backstory on how David Smith brought PodSearch into the modern AI era:

Thankfully since then OpenAI has released Whisper a powerful speech-to-text engine that I can run right on my Mac and results in transcripts that are shockingly good. They aren’t quite at the level of a human transcriber but they get darn close in many instances. Getting close to the level where you could use them to grab a pull quote with only a little bit of tidying up to do.

Moreover, because I can just run this locally it is essentially ‘free’ to run, costing only my CPU time. So I can much more easily keep it up to date and incorporate the entire back catalogs of the shows I’m indexing.

…

The updated site can be found at podsearch.david-smith.org. I hope you find it helpful and fun to explore. You can easily search for the occurrences of particular keywords within a particular show and find the timestamp of when it was said.

Previously I’ve noted my appreciation for marimo notebooks, especially how their reactive cell model was different from Jupyter notebook. Marimo has also been developing an interesting narrative around integration with agentic coding.

In this blog we explain why agentic coding tools like Claude work exceptionally well with marimo, especially when compared to other notebooks such as Jupyter. We also share tips on how to best use Claude when working with marimo. While this blog focuses on Claude Code, you don’t have to use your terminal if you don’t want to: in a future blog post we’ll describe how marimo provides a batteries-included AI-native editor, with a best-in-class experience for working with LLMs and your data in a single development environment

However, Jupyter is an established, robust, and large ecosystem. With a lot of smart people at the forefront of data science and machine learning. So I should have known the Jupyter team would not stand still in the face of AI advances.

Enter Jupyter AI

read more ...

Daring Fireball’s Jon Gruber conducted an amusing interview with Brian Mueller, the developer behind Carrot Weather.

Carrot tells me my first install was a little under 4 years ago, on November 12th, 2021. Feels like it’s been much longer. I’ve probably opened it over 95% of the days since then.

Awaiting the unofficial transcript for some interesting pull quotes.

The fact that the app has personality is one of its best features. I first heard of the Will Smith / Chris Rock contretemps from Carrot.

It’s an extremely well designed, well featured, and non-intrusive app. I highly recommend it to all meatbags.

I’ve heard a lot of good things about Cursor, but thought it was another IDE with AI inside. And I am not an IDE guy.

Turns out Cursor has a CLI! From the docs:

Cursor CLI lets you interact with AI agents directly from your terminal to write, review, and modify code. Whether you prefer an interactive terminal interface or print automation for scripts and CI pipelines, the CLI provides powerful coding assistance right where you work.

Claude Code, Codex CLI, aider, Gemini CLI, and Cursor CLI. The quiver is getting mighty full. Time to get back to work.

Ned Batchelder is a wise elder of the Python community. He recently offered this advice on side projects, “Forgive yourself”

My advice is: forgive yourself. It’s OK to rewrite the whole thing. It’s OK to not rewrite the whole thing. It’s OK to ignore it for months at a time. It’s OK to stop in the middle of a project and never come back to it. It’s OK to obsess about “irrelevant” details.

The great thing about a side project is that you are the only person who decides what and how it should be.

As someone who’s using side projects as “auditionware”, I need to keep this philosophy in mind.

Batchelder also plenty of other good bits of advice in that post. Especially the nugget about how “nice” becomes easier the more you do it. Gotta get the reps.

Meanwhile, just go read the whole thing.

I haven’t extolled it too much here, but I’m a fan of what marimo has been doing in the computational notebook space. As a small, venture backed, startup it was relatively safe to root for them. Of course venture backed implies a certain space of outcomes and one of them came to pass. Marimo joined CoreWeave.

TL;DR Marimo is joining CoreWeave. We’re continuing to build the open-source marimo notebook, while also leveling up molab with serious compute. Our long-term mission remains the same: to build the world’s best open-source programming environment for working with data.

marimo is, and always will be, free, open-source, and permissively licensed.

I’m hopeful that this won’t severely impact marimo for at least two to three years. There’s a fair bit of underlying robustness and stability that could be added amongst the strong drive on features. Given similar acquisitions I’ve seen, beyond that timescale is a crapshoot. Blitzscaling startups or existing Big Tech organizations purposefully make acquisitions fundamentally different as they become further integrated. It’s sort of the point.

Of course some folks will be bent out of shape and declare “back to Jupyter!!” That’s reasonable, except from what I understand you can’t get to marimo from Jupyter.

Simon Willison puts the proper nuance on the current state of play

Give (sic) CoreWeave’s buying spree only really started this year it’s impossible to say how well these acquisitions are likely to play out - they haven’t yet established a track record.

It’s early days but I had a really nice initial experience using Claude Code Web

Claude Code on the web runs Claude Code tasks remotely, working with code from your GitHub repositories. This article explains how it works, when to use it instead of running Claude Code in your terminal or IDE, and what workflows it enables.

Simon Willison has a post with a much more detailed interaction, but overall he seems to align with how I felt.

I used it to modernize an old repo, lastfm-to-sqlite, which ingests Last.fm scrobbles into an sqlite database. The workflow just naturally progressed from using Claude Code on the cli. Maybe I went overboard with the summaries, but I found it extremely helpful throughout the development process. My hope is that the summaries can become either archival documentation or rolled into release notes.

As I was working, the integration of Claude Code, on the Web and command line, with the GitHub CLI makes for a nice combination. My next experiment will be to see if I can sketch out some requirements in a GitHub issue, have Claude Code Web fetch it, and then churn out a solid PR. Leveraging GitHub issues and PRs as a system of record for agentic engagement with a codebase might be a best practice.

Also on my TODO list is giving Codex on the web a try.

Link parkin’: Pygame GUI

Pygame GUI is a module to help you make graphical user interfaces for games written in pygame. The module is firmly forward looking and is designed to work on Pygame 2 and Python 3.

The “Quick Start Guide” in the documentation leans on pygame CE

GitHub source repo

Link parkin: cargo-update

A cargo subcommand for checking and applying updates to installed executables

Handy if you cargo install tools like starship and atuin, amongst others. Was sort of surprised cargo didn’t have something like that baked in.