Chameth.com

Monthly Meanderings: September 2026

2026-10-01T00:00:00Z

Where has the year gone? How is it October already? Although I’m actually writing this in September, so it isn’t. But the point still stands, I think. Man, I’m getting good at these intros. They just flow right off the page, right? … Right?

Website updates

A couple of new posts appeared in September. Lego, ACME DNS-01, and negatively-cached surprises is a rather snappily titled post about debugging an issue a friend had with Centauri, my reverse proxy. Turns out a combination of default settings in the Lego library and the perfectly reasonable behaviour of systemd-resolved makes for a bad time. Maybe that should have had a spoiler warning.

Then in the expanding scope of coding agents I talk a bit about how my use of LLMs for coding has evolved, and how I “vibed” a perfect-for-me music player with a single, short prompt. It’s a spiritual successor to an app can be a ready meal from last year. Now the microwave is even easier to operate. Or operates on bigger ready meals? It’s a good job I didn’t try to keep the same analogy in the post.

Under the hood, I’ve been slowly working on changing how data on my website is handled. Previously, if I wanted to display something like board game stats, then chameth.com had to have a complete copy of all my board game data so it could query whatever information was needed. As I added more and more bits and pieces, this felt heavier and heavier, and in some cases was straight-up duplicating data and logic that I had elsewhere. I’m instead moving to a model where the shortcodes pull data from a remote source and cache it for an appropriate amount of time. It’s then refreshed in the background for as long as it’s “live”. So the monthly recap embeds you’ll see below refresh until a few days into October to pick up any straggling data, and are then frozen. It doesn’t really make any difference to what you see on the page, but the architecture pleases me, and I got to delete a whole bunch of code.

Finally, I had to tweak the feed builder I mentioned last month. Some scrapers managed to stumble into it, then ignored all the nofollow and noindex tags, and decided to try and scrape every possible combination of posts. That is a lot of combinations. Some of the scrapers are lovely things that pretend to be Chrome and use a different residential proxy per connection, so you can’t simply block IPs or user agents. I’ve changed the builder so that each mutation is a form submission, which seems to have helped a bit, but there are still some hitting all the URLs they discovered before the change.

I drafted this post a few days before publishing it, and originally wrote “the scrapers didn’t actually put any noticeable load on the website, but they did manage to screw up my analytics!” Guess what! Literally as I went to publish this post my monitoring went off because the site stopped responding after one scraper did 100 requests per second from a bunch of different IPs. Guess I’m writing rate limiting and ASN blocking code tomorrow.

Entertainment

Oh look, one of those new cached shortcode things I was talking about! When last month’s post went live, chameth.com had a database of every track I’d listened to since I started logging them. Now instead there’s a dedicated service for that, and it just passes the specific information over. In this case, my most played albums this month:

	Album	Artist	Unique tracks played	Total tracks played
1	The Strange Case of…	Halestorm	7	23
2	From Zero	Linkin Park	7	22
3	Good Girl Gone Bad: Reloaded	Rihanna	6	22
4	KPop Demon Hunters (Soundtrack from the Netflix Film)	KPop Demon Hunters Cast	5	21
5	Love, Drugs & Misery	Eva Under Fire	10	21
6	Hands	Little Boots	7	20
7	THE WAY	Dorothy	6	20
8	Fallen	Evanescence	7	19
9	Villainous	Eva Under Fire	7	19
10	American Dream	DIAMANTE	7	18

As I said last month, this is probably going to be pretty same-y. There are some small movements, but it’s still mostly just “albums I love” combined with “albums I like that have songs with a suitable BPM for running” in some order.

I watched a bit of TV this month, catching up on the most recent seasons of Rick and Morty. It’s nice having something relatively short to watch when you’re at a bit of a loose end, or don’t want to have to remember what contrived plot arc is going on in a longer-form series. I was also pleasantly surprised to discover that SNL UK is back. It’s — as you’d expect — more of the same standard SNL formula, with some hits and some misses, but Weekend Update remains consistently hilarious.

Most of the rest of my entertainment time has been spent in World of Warcraft, in one form or another. I picked up beta access to WoW: Forever, which is basically a semi-modernised version of classic WoW but without following the same expansions as the original. Just… classic… forever. I initially didn’t think I’d like it, given how opposed classic players seem to be to everything nice, but so far it seems like they’ve done a good job balancing it. It feels a lot more like an RPG than modern WoW, where everything feels like a thin veneer over getting gear or various currencies. It’s still early though, so I’m not sure how much “sticking power” it’ll have with me.

In normal WoW, I’ve been playing both my Shaman and Monk healers. I’m leaning back towards Monk now. It’s still undertuned despite several buffs, but I don’t think that actually matters at the level I’m playing at. After playing around with some of the talents, I’m happier with it than I was, and I still find it a lot more fun to play than the Shaman, even if it doesn’t quite perform as well.

Level 90

Female Night Elf

Mistweaver Monk

323 average item level

Miraceth-Terenas

Professions

Midnight Leatherworking		100/100
Midnight Skinning		100/100
Midnight Cooking		100/100
Midnight Fishing		110/300

Mythic+

Altar of Fangs	+10	18:53	334
Den of Nalorakk	+12	27:40	370
Kings' Rest	+12	32:35	365
Murder Row	+12	24:02	376
Ruby Life Pools	+12	21:31	374
Temple of Sethraliss	+10	23:12	330
The Blinding Vale	+10	23:56	328
Voidscar Arena	+12	29:38	365
Total M+ rating	2842

View on blizzard.com View on raider.io

Level 90

Female Dwarf

Restoration Shaman

320 average item level

Hirameth-Terenas

Professions

Midnight Blacksmithing		100/100
Midnight Inscription		92/100
Midnight Fishing		35/300

Mythic+

Altar of Fangs	+12	27:28	368
Den of Nalorakk	+12	28:10	369
Kings' Rest	+14	26:20	403
Murder Row	+12	25:04	375
Ruby Life Pools	+12	25:19	369
Temple of Sethraliss	+12	24:13	374
The Blinding Vale	+12	20:23	377
Voidscar Arena	+12	23:27	373
Total M+ rating	3008

View on blizzard.com View on raider.io

Fitness

A medal for running my first 5k

This has been a fun month for my running activities! I ran my first timed 5k at the start of the month, finishing in 41:22. My aim was for a pace of around 8 minutes per km, and the actual course was 5.2km, so I was pretty much spot on. It’s not a very fast pace, but given I only started running at the end of June I’m pretty happy with it. I’m now working my way up towards 10k, then I’m going to spend a little while just building volume and hopefully some speed.

Now that I can comfortably run 5km, albeit rather slowly, I’ve started going to my local parkrun each week. Naturally I’ve created a webpage that tracks my stats and results. In hindsight I could have started going much earlier, and done some of my walk-run training there, but I didn’t want to be around that many people when I was still finding my feet.

I feel like I’m getting a bit better at pacing myself, but I’m also conscious that I don’t really know what my “all-out” speed is and how long I can maintain it for. I don’t think I want to do a time trial while I’m working towards a 10k, so for now I’ll just stick with slowly but surely pushing my PBs down:

activities

8h 0m

total time

59.8km

total distance

6.5km

longest distance

🏆️ New PB 400m 2:36 2:26
🏆️ New PB 800m 5:54 5:15
🏆️ New PB 1km 7:27 6:40
🏆️ New PB 1 mile 12:11 11:00
🏆️ New PB 2km 15:13 13:35
🏆️ New PB 3km 23:05 20:37
🏆️ New PB 5km 38:45 37:04

I managed to entirely avoid getting on my bike this month. A few planned rides fell through, and the rest of the time the weather was miserable, or my legs were still raising complaints about previous runs, or I was doing this pesky thing called “work”, or I just didn’t feel like it. Hopefully I can squeeze a decent ride in at some point before the weather turns even more, but that list of excuses looks nigh insurmountable.

Around the web

Prompts aren’t real

An interesting presentation from Dan McKinley, who I remember from the boring technology club. He seems to be single-handedly propping up the entire .club TLD. Anyway, it’s an interesting look at how some LLM tooling works, and contrasts starkly with how half-assed a lot of support bots seem to be.

The Contagion of Fear

Bryan Cantrill talks about the recent hysteria concerning the risk of LLMs wiping out humanity. Bryan always seems to have very sensible takes, and presents them very well, and this one is no exception.

Moving from WordPress to Hugo

A post from my friend Simon about redoing his website. I particularly like the screenshots of the previous versions at the end. I’ve been meaning to do a “History of this site” post for a while, and seeing this has moved it up my priority list.

FLIP Fluid on Flip Dots

I find hardware projects like these more and more appealing as the software world gets more and more LLMy. They’re physical, and whimsical, and you can’t just recreate it by typing some words into a prompt. Now if you’ll excuse me, I have a sudden urge to solder something…

The expanding scope of coding agents

2026-09-14T00:00:00Z

It’s time for another post about LLMs! I know, I know, that’s basically all anyone talks about these days. But that sort of makes sense: it’s what a significant number of software engineers spend their day using. And they’re changing so rapidly. Back in May last year, I said:

But how good is it at actually writing code? It’s like having a keen but not particularly thorough Junior Engineer at your beck and call. If you give it a clearly defined task and guidance on how to implement it (and maybe some feedback as it suggests changes), it’s more than capable of doing it. If you don’t give it enough guidance it tends to go more off the rails. I tried having it generate a simple application from scratch with minimal technical guidance and no review of what it was doing, and it made such a mess of it I decided it was quicker to throw it away and start again by hand.

What I was describing there basically amounted to “the coding agent can be responsible for a function, or a group of functions if they’re described well enough”. That post was published at about the time that Sonnet and Opus 4 were released, and there have been several big releases since then.

Graduating from functions to features

Now, I didn’t stick with Claude through all those shiny new releases. Anthropic effectively banned using third-party harnesses with their subscription plans, and did it in a way that rubbed me the wrong way. As far as I’m concerned, I’m paying for inference-as-a-service: it shouldn’t matter if I do that via Claude Code, or OpenCode, or something else. But they disagree. So I jumped ship to Z.ai’s GLM coding plan. At the time I signed up, the cost for a year-long subscription was about the same as a month of Claude, with higher limits.

The GLM models definitely weren’t (and still aren’t) as good as the Claude series, but they were mostly good enough. But as new models were released, the capabilities slowly ratcheted up. I noticed the unit of work I gave them graduated from functions to small, self-contained features. Instead of describing exact implementation steps, I was describing the functionality I wanted. I didn’t stop providing guidance on how to do it, but I was increasingly happy giving it larger chunks of work and getting something reasonable back.

Around the same time, the cost of some of the models dropped quite a bit. Between a new flash model, token discounts, resets, and so on, it got to the point where I couldn’t hit the plan limits even if I tried. So I was throwing more and more work at it: having two to three things going at the same time, with me only dropping in at the end to review and ask for follow-ups.

From features to artefacts

The GLM models weren’t quite good enough to tackle larger units of work. I tried going back to Claude to see what it was like now but bounced off because its output was incredibly painful to read. I wanted to try Fable, their next-tier model, but you can’t do that without one of the amazingly expensive plans or paying API costs directly. Neither of those options is particularly appealing to me. Meanwhile, OpenAI launched Astra, their Fable-equivalent. And you could use it in small amounts on the less expensive plans.

I played around with Astra on a few small things, but I was conscious of the low limits. Plus, GLM-5.3-flash mostly did the bits and pieces that I wanted. I figured I’d give Astra a proper try the next time I had a larger project. Fortunately, some packet loss gave me that opportunity very soon.

I use Navidrome running on a remote server to host all my music, which is fantastic. Until your connection goes a bit wibbly. Apparently, the music player I was using didn’t believe in buffering, so when I developed 20% packet loss to the server the music kept pausing, playing a second, pausing, playing another second, and so on. Pretty much the most infuriating way it could have handled it. Writing my own music player had been at the back of my mind for a little while, and suddenly I had both impetus AND a shiny new tool.

I launched pi, switched over to Astra on low thinking mode, and gave it this prompt:

This is a new project. It’s going to be a native music player written in Go using the Gio library, backed by a Navidrome server. Think foobar2000, but Linux-native, Go, and Navidrome. It doesn’t have to do everything right away, but an MVP should be able to: connect to navidrome (saving credentials), show playlists, play a playlist in order. skip tracks, pause/unpause, adjust volume, etc. It should be tolerant to network issues – buffer a good few minutes of playback data, or an entire track or two. I have two other UI projects using Gio for reference, see ../gtodo and ../glauncher. For actual playback we may want to consider using an established backend like mpv, but that’s not a hard recommendation. For this project you are the overseer/orchestrator. You should use subagents using the zai/glm-5.3-flash model to do recon, implementation, debugging, etc. You can ask me questions if you have any.

I’d seen a few comments from people doing a similar kind of orchestration, and references to tools like prime agent that have first-class support for the workflow. It seemed like a natural fit for my case: Astra can do the orchestration, architecture, and review, but the much cheaper GLM models can do the actual heavy lifting. It asked me a few questions, and an hour later a fully functioning music player popped out:

gmusic, fresh off the press, playing away.

It was exactly what I asked for. A one-paragraph prompt producing a fully functioning piece of software kind of blows my mind. And that was with Astra on low thinking, on the £20/month plan, orchestrating cheaper agents. There was a fair bit of judgement encoded in the prompt, and “think foobar2000” carries a lot of information in just two words, but it still felt very light on the details compared to what I’d usually write. Just a description of what I want in, and a binary out.

I’ve been using gmusic for a week now, and only had to make a few minor additions to go from “MVP” to “comfortable daily driver”: scrobbling support, media keys, and remembering playback/playlist position across restarts¹.

Cattle, pets, prompts, and saying no

The ability to generate a binary from a paragraph of text changes the way I look at software. Sysadmins often speak of treating servers like “cattle, not pets”: if one server develops a fault, you just tear it down and automatically rebuild or redeploy it. It holds no special value, so you don’t need to slowly nurse it back to health, or spend ages recreating it. I think that sort of attitude now applies to software.

If it turns out gmusic has some horrible architectural flaw — and it might, because I haven’t even glanced at the source — then I can just throw the whole thing away, feed in the same prompt with an additional bit on how to avoid the same mistake, and get something similar enough back.

There are some limits here: the “paragraph-to-artefact” pipeline is stochastic, so you might in fact not get something similar enough back. And you have to be willing to throw the whole thing away and wait for a replacement. No big deal for a music app, but I wouldn’t want to take that attitude with a business-critical application. There’s also an interesting wrinkle in the other direction: model capabilities are advancing so much that you might want to throw it out and regenerate it again. Could “regenerate the app from the prompt” become the new “install updates”?

One thing to fall out of that view is that documented intent becomes king. Your prompt and subsequent corrections and additions are more important than the generated code. I like the idea of keeping some kind of decision log that future agents can be pointed at, but I’ve not yet found a good way to do so. Getting the agents to write it out reveals some obvious flaws: they’re very bad at distinguishing deliberate decisions from incidental implementation details; they’re also bad at picking the right level of detail, and seem chronically incapable of breaking with previously documented behaviour.

Agent-managed documentation, in fact, seems to end up resembling a cult. The first pass is probably OK-ish. Then the next agent to touch it will be compelled to extend any list, timeline, or history with whatever it’s working on. Over time, a superfluous comment about how something was made will undergo a gradual epistemological transformation until it’s treated as a commandment from on high by all future agents. It’s a mess.

I think this is part of a bigger problem: models are still way too sycophantic. There’s very little pushback against either the user or the documentation. If I asked an agent to add a feature to gmusic that analyses a webcam image of my toaster and alerts me when the toast is ready, it’d just do it. If you’re not careful, your software will gain 7 kitchen sinks and 3 Swiss Army knives, and at no point will the agent suggest splitting them out, or refactoring. Before you know it, your cattle have mutated into grotesque pets with far too many limbs.

The current generation of models is almost certainly capable enough to push back on bizarre features, stop scope creep, ask questions to determine how robustly to build something or how to handle edge cases, and so on. You can probably even prompt them in a way that they’ll do it, but in their normal state the RLHF² seems to have bulldozed over all that in favour of being a yes man.

From artefacts to systems?

I think the current state of agents is that they can own “artefacts”, having graduated from functions and features. It’s a very deliberate choice of words: they can’t own the full application or system because they won’t independently step back and make the necessary judgement calls.

It’s tempting to imagine a perfect little software factory, where you have an agent in charge of product management, one in charge of architecture, one that manages the documentation, and so on, all with their own points of view and priorities in their prompts. If you’re not careful, you’ll soon be talking about polecats and deacons and writing very large cheques to frontier labs.

I do think there’s some benefit in this kind of orchestration, but there’s also a limit to how much adding agents wearing different hats will help. And there’s also a limit to how much I’m willing to spend on inference! I have got good mileage out of a dedicated code review agent. It often catches one or two problems that the other model overlooked, so I get an obvious and immediate “return on investment”: a few pence spent running deepseek-4.1-flash with a code review prompt earns me fewer bugs.

I think that’s basically the cut-off for me right now. I almost want a “documentation review” agent to try and manage some of the problems I mentioned earlier, but I don’t think it’s worth it. Maybe it’ll make a fun experiment as local models get more capable.

Determinism instead of prompts

One thing that interests me is how much of this problematic behaviour we can get rid of without relying on the model to remember and follow instructions. I had an issue with agents making a mess of the git history with non-fast-forward merges from subagents. The “natural” fix is to prompt the agent not to do that, but that relies on it following that one particular instruction. It doesn’t always do that. Instead I made a simple pi extension that checks the git history and tells the agent to fix it if it’s broken. That has had a 100% success rate so far.

Similarly, in the gmusic prompt I told the agent what model to use for the subagents. After doing this for a while (and promoting the instructions to a skill instead of something I type out every time), I noticed it would occasionally just use a different model. So now I have another pi extension that defines subagent roles using the models I want it to use, and the agents can’t just do their own thing.

This makes me wonder if the next step to expanding agent capabilities isn’t necessarily more capable models, or more agents in different hats, but more rigour in software engineering. If we had a way to accurately assess the need for refactoring, or the quality of documentation, then we could immediately put hard-and-fast rules in that the agents will follow. That’s a load-bearing “if”, though, if you’ll forgive me the Claude-ism.

However we reach it, the future where a prompt can become a fully formed, maintainable, secure, documented piece of software probably isn’t that far away. It’s going to be very interesting when regular users can just summon good software to do whatever they want. I’m not sure what that means for my career as a software engineer: there are still a lot of places in the process that benefit from knowledge, experience and judgement, but maybe that won’t be the case for much longer? There are interesting times ahead for us, either way.

Which actually fixed a long-standing minor annoyance for me: I have a “Daily Mix” playlist generated, well, daily. In my old player it would effectively queue the whole playlist, so when I opened it the next day I carried on listening to the old daily playlist. So instead of just pressing the play button on my keyboard, I had to find the app, click the new playlist, and then press play. Not a problem worth fixing in itself, but still a minor daily papercut that I’m glad to be rid of. ↩︎
Or whatever other post-training is done these days. ↩︎

Lego, ACME DNS-01, and negatively-cached surprises

2026-09-09T00:00:00Z

Recently a friend was deploying Centauri, my reverse proxy service that can obtain TLS certificates using ACME DNS-01 challenges. He asked a seemingly innocent question: “When Centauri is ‘waiting for record propagation’ is there an option to increase the time?” But that’s a question with a hidden, concerning XY problem. We both use the same DNS provider, and it definitely shouldn’t take more than a minute to see a DNS record after it’s been created. Plus, I don’t have issues with it timing out!

Centauri uses the excellent lego library to do the actual ACME dance, and I’ve dug into it before pretty extensively to debug other DNS issues. When I last looked, it used the local recursive DNS resolver to check for CNAMEs and find the authoritative server, then checked for record propagation there. So, naturally, I blamed Simon’s local resolver doing something weird. Turns out that was surprisingly close to correct, but not for the reasons I thought.

Unfortunately for my snap judgements, Simon had a perfect rejoinder: he’d deployed the exact same VM image before and Centauri worked fine. And also while we’d been speaking it had managed to get a certificate after waiting 58 seconds for DNS propagation. Simon suggested that maybe it was systemd-resolved caching something stale, but I dismissed that based on what I knew of how Lego worked.

Diving back into Lego

Of course, after I dismissed the idea, I immediately started doubting myself. Last time I was looking at DNS issues I traced the code all the way across the Lego codebase. This time I just had a coding agent explore and summarise for me. Turns out it DOES use the recursive resolver to check for the TXT challenge record.

The DNS functionality looks like this:

CNAME query on the _acme-challenge record using the recursive resolver.
Maybe an SOA query on the same, depending on the DNS provider, using the recursive resolver.
Actually create the challenge record using the DNS provider.
Query records recursively to discover CNAMEs using the recursive resolver. It doesn’t matter if this fails.
Query the TXT record on every configured recursive resolver, blocking until they all work.
Query the TXT record on the authoritative nameserver.

So yes, a stale response from the recursive resolver can indeed ruin the whole thing. Simon’s domain had a minimum TTL of 60 seconds, so that links in nicely with it working at 58 seconds and failing most of the time: the 1 minute timeout is racing the 1 minute TTL, somehow. But my domains use a much longer TTL and I can see renewals happening in my logs basically immediately. What gives?

NXDOMAIN caching and RFC fun

So I had a theory as to what was happening, but it still had some loose ends that I didn’t understand. I did get a pretty big hint when I started doing lookups from various locations, though. On my desktop if I do a CNAME query then a TXT query for a record that doesn’t exist, I get this:

$ drill CNAME nonexistent.chameth.com
;; ->>HEADER<<- opcode: QUERY, rcode: NXDOMAIN, id: 12630
chameth.com.	3600	IN	SOA	chameth.com. root.chameth.com. 2026339162 7200 3600 86400 3600

$ drill TXT nonexistent.chameth.com
;; ->>HEADER<<- opcode: QUERY, rcode: NXDOMAIN, id: 56402
chameth.com.	3590	IN	SOA	chameth.com. root.chameth.com. 2026339162 7200 3600 86400 3600

And from my server:

$ drill CNAME nonexistent.chameth.com
;; ->>HEADER<<- opcode: QUERY, rcode: NXDOMAIN, id: 7807
chameth.com.	3600	IN	SOA	chameth.com. root.chameth.com. 2026339162 7200 3600 86400 3600

$ drill TXT nonexistent.chameth.com 
;; ->>HEADER<<- opcode: QUERY, rcode: NXDOMAIN, id: 5069
chameth.com.	3600	IN	SOA	chameth.com. root.chameth.com. 2026339162 7200 3600 86400 3600

Notice how the TTL (the first number) decreases locally, but not on the server? That implies my local resolver is reusing the same result when I do the second query, and the resolver on the server isn’t. It turns out that on my desktop I use systemd-resolved, which sends requests to Tailscale, which passes them off to NextDNS. On the server they go straight to Tailscale and then onwards to NextDNS. So systemd-resolved is what’s causing the behaviour. Like Simon guessed right at the start.

But why is it actually doing that? It’s kind of annoying. Well, it’s doing what it’s meant to. RFC2308 says:

A negative answer that resulted from a name error (NXDOMAIN) should be cached such that it can be retrieved and returned in response to another query for the same <QNAME, QCLASS> that resulted in the cached negative response.

A negative answer that resulted from a no data error (NODATA) should be cached such that it can be retrieved and returned in response to another query for the same <QNAME, QTYPE, QCLASS> that resulted in the cached negative response.

Because the record doesn’t exist at all (there’s no other records for _acme-challenge: why would there be?) we get an NXDOMAIN response, and that “should” be cached for any query type. So when Lego queries for the CNAME record, we’re priming the cache with “_acme-challenge doesn’t exist” with a potentially huge TTL on that cache entry. When we then try and query the TXT record we created we get the cached NXDOMAIN back.

If the TXT record was created first then the CNAME query would get a NODATA response instead, which wouldn’t affect us as that is understandably cached per query type. But the point in Lego’s CNAME check is to decide where to put the TXT record, so it can’t just flip the ordering.

I apparently dodged this problem entirely on my servers, because nothing in that resolution path implements this particular caching behaviour.

But why now?

But Simon had this working before. It’s possible that his existing deployments are having this issue now, and are just retrying enough to win the race, but he would’ve noticed if they failed this much when he set them up.

So I did some archaeology. Here’s the timeline:

February 2016: CNAME check added to deal with, well, CNAMEs.
February 2016: Immediate follow-up making a failed CNAME check non-blocking.
September 2024: Option added to check propagation using custom recursive resolvers.
February 2026: That option now defaults to on.

And the mystery is solved: Lego v5 enabled the recursive check by default. That also handily explains why I thought its behaviour was different. It used to be! There were still two things I didn’t understand: why was it enabled, and why didn’t I realise when I upgraded to Lego v5? Looking back, I think this line of the changelog is meant to cover the behaviour:

[lib,dnsprovider] New approach of the DNS calls

The migration guide also mentions the flag being renamed, but not the fact that the default setting also flipped. Feels like burying the lede a little, but hey ho.

As for why, there doesn’t seem to be any documented rationale. Given the recursive resolver check was added to fix a fairly niche problem, it seems like an odd decision to me. The new defaults mean that any recursive resolver that caches NXDOMAIN responses across query types will delay the propagation check, and likely fail it entirely if the TTL is longer than the timeout. That’s… unfortunate to say the least. I opened a discussion suggesting the default gets flipped back but it doesn’t sound like that will happen before v6.

For Centauri, at least, I’ve fixed it by unconditionally disabling the recursive resolver check, taking it back to the Lego v4 behaviour. And after all this, Simon’s original hunch turned out to be spot on: it was systemd-resolved caching, but it was doing the correct thing. Pesky old-man Lego was the one responsible for dropping a rake on the ground then immediately stepping on it.

Monthly Meanderings: August 2026

2026-09-01T00:00:00Z

Another month, another edition of “What’s Chris been up to?”. Fun fact: I very nearly published this post with a “[intro]” placeholder here instead of this paragraph, despite proofreading it multiple times. “Yep, that’s where the intro will go, all good”. Now instead we have this weirdly meta introduction.

Website updates and other projects

A few website updates this month, and one of them neatly addresses the “other projects” bit too. First, I’ve added a new fitness page which has some stats and information about my cycling and running. I’ve also added some fitness-related widgets to support that page and these monthly summaries, and a new music one you can see a bit further down.

I’ve also added what I think is quite a fun new feature: a post feed builder that lets you build RSS feeds containing only posts that are semantically similar (or dissimilar) to other posts. So if you want to only hear about my fitness journey you can pin a few of those posts, or if you want to exclude posts that talk about LLMs you can exclude a few of those. It’s basically super-charged fuzzy tags, but it means I don’t have to actually tag things.

I blogged about building a family of single-user services which is where most of my coding energy went this month. Those projects were almost entirely authored by LLMs, and I’m not hating the process. The models have got a lot better at coding, and I enjoyed getting to focus on the bigger picture aspects rather than getting bogged down in details. Rest assured, all the writing on my website is still 100% me. I am the load-bearing seam, here.

Entertainment

Back in March I said ‘I can’t do “what I listened to last month” stats until next month’, and then for the next four months completely forgot about it. Well, not any more! Now I come equipped with some stats about my monthly music habits:

	Album	Artist	Unique tracks played	Total tracks played
1	Fallen	Evanescence	8	40
2	Love, Drugs & Misery	Eva Under Fire	12	32
3	NEON VOID	Sumo Cyco	6	23
4	The Strange Case of…	Halestorm	11	21
5	Coming in Hot	DIAMANTE	9	20
6	Everest	Halestorm	7	20
7	Glory Days	Little Mix	5	20
8	From Zero	Linkin Park	9	19
9	KPop Demon Hunters (Soundtrack from the Netflix Film)	KPop Demon Hunters Cast	7	19
10	No Need to Argue	The Cranberries	6	19

I suspect I won’t show this every month, as it’s probably going to be quite same-y. I, shockingly, tend to play music that I like more than that which I don’t. I’ll usually either put on my “favourites” playlist, or my “daily mix” playlist which biases higher-rated tracks over lower ones. So effectively this just becomes a noisy view over how highly I’ve rated the tracks in an album. Maybe I can control for that, but then I’m not sure what it’d actually be showing… “Here are all the albums I played this month that I don’t usually play because I don’t like them as much as the other albums I’m not showing any more”? It’s a bit wordy. Back to the drawing board with that idea, I think.

I was away for a few weeks this month, including a few days at a small LAN event. Being at a computer gaming event meant that we, naturally, played some board games. Apparently I hit an h-index of 23 from these plays. That’s 23 games I’ve played at least 23 times each. I’ve been at 22 since December last year: obviously the higher the number goes, the harder it is to reach. I also go on and off games (and the whole hobby at times), which doesn’t help on that front. Anyway, here’s ~~Wonderwall~~ the plays for this month:

6 plays
3 plays
3 plays
1 play
1 play

No films this month, but my World of Warcraft habit has picked back up with the launch of the new season. They’ve made Mistweaver Monk, my previous specialisation, a lot less fun to play, so I’m focusing on one of my many alts: a Restoration Shaman:

Level 90

Female Dwarf

Restoration Shaman

320 average item level

Hirameth-Terenas

Professions

Midnight Blacksmithing		100/100
Midnight Inscription		92/100
Midnight Fishing		35/300

Mythic+

Altar of Fangs	+12	27:28	368
Den of Nalorakk	+12	28:10	369
Kings' Rest	+14	26:20	403
Murder Row	+12	25:04	375
Ruby Life Pools	+12	25:19	369
Temple of Sethraliss	+12	24:13	374
The Blinding Vale	+12	20:23	377
Voidscar Arena	+12	23:27	373
Total M+ rating	3008

View on blizzard.com View on raider.io

I don’t quite like it as much as Mistweaver in season 1, but it’s a lot nicer than Mistweaver in season 2. You can actually make health bars move when you press your healing buttons, rather than ignoring half of them because they’re not worth using.

Fitness

My running kick is still going. I’ve “officially” finished the couch-to-5k programme I was doing, and I actually hit 5k on the last day of the programme. I didn’t actually mean to do that: I was saving the 5k run for this week, but by the time I noticed I’d run “too far” it was close enough that I just kept going. I have an actual 5k race coming up this month, which is exciting. Once that’s over I’m planning to work my way up to 10k. I’ve added a few widgets to keep track of some stats:

activities

6h 5m

total time

103.6km

total distance

42.3km

longest distance

🏆️ New PB 1km 2:17 1:59
🏆️ New PB 2km 5:34 4:29
🏆️ New PB 5km 14:51 12:52
🏆️ New PB 10km 36:00 27:53
🏆️ New PB 20km 1:43:33 1:13:26
🏆️ New PB 30km no previous 1:54:23
🏆️ New PB 40km no previous 2:55:46

activities

6h 16m

total time

43.1km

total distance

5km

longest distance

🏆️ New PB 800m 5:56 5:54
🏆️ New PB 1km 7:35 7:27
🏆️ New PB 1 mile 12:28 12:11
🏆️ New PB 2km 15:35 15:13
🏆️ New PB 3km 24:32 23:05
🏆️ New PB 5km no previous 38:45

As well as the running, I did a couple of long (for me) cycle rides, clocking in at around 40 km. It’s a fun loop, but both times I did it I started flagging towards the end. The second time I made sure to eat and drink plenty along the way, and my legs still raised objections about halfway round. My next goal is 50 km which would let me get to the next town over and back but the route has a lot more elevation to go with its increased length, so it’s probably going to be quite a bit more taxing. I’m not sure when I’ll attempt that, as the weather is starting to turn. I was previously bemused when people mentioned “cycling seasons” and switching to indoor trainers. Then I wanted to go out when it was raining, and suddenly I understood. Running in the rain: surprisingly pleasant; cycling in the rain: no thank you.

Around the web

Hacker News In Uncompromised Detail

When I first read the title my gut reaction was “I know everything I need to know about Hacker News, right?”. The title is accurate though. There’s so much interesting stuff, presented really cleanly. It’s a good read.

A proposal for new Netflix content rating icons

Another dry sounding title, another fun article. It starts with a treatise on rating systems and ends with a lovely satirical list of rating ideas.

Find Git commits by commit message text

I like to think I’m relatively well versed in how to use Git. I can do an interactive rebase and everything! This tip from Ham was new to me, though, and is incredibly useful.

Novice Marathon Training Plan

Hal Higdon has a whole bunch of training plans. He literally wrote the book on marathon training. I’ll hopefully be following this plan next year, assuming I manage the 5k, 10k and half-marathon training! This would be the perfect plan for someone who’s run a half marathon a while ago, and is tempted to join me in my “marathon before I’m 40” goal…

Building a family of single-user services

2026-08-27T00:00:00Z

Last month I made and wrote about a personal service to track my workouts and record personal bests. Since then, things have escalated. I now have eight different services running in the same “family”:

Name	Purpose
Collegiate Room	Simple weather overview for my current location
German Mall	LLM broker for use by other services
Gloss White	Weight tracking
Olive Crosses	Central service hub
Pompei Band	Workout and personal best tracking
Speed Carp	Spaced repetition system
Tiger Island	Reading history and library tracking
Typical Horse	Location history and analytics

The names are all anagrams of something related to their function. Finding those anagrams brings me an unreasonable amount of joy. Unscrambling them is an exercise left to the reader. On top of those eight, I currently have four other service ideas sat in my todo list. It’s going to be a big family.

A postmortem on the previous hodge-podge

Most of this functionality isn’t new to me. When I started out playing around with LLMs, I created a “personal data aggregator” that just kept getting things bolted on. I said at the time:

My biggest just-for-me project is a web app that I started to help me aggregate film recommendations. It’s since morphed into a general personal data aggregation service: it deals with data from GitHub, Todoist, Letterboxd, TMDB, Healthkit, and others. It also lets me make re-orderable lists, store recipes, and more. Parts of this could definitely be open sourced, and I might carve them out at some point, but it’s mostly a glorious hodge-podge of things specific to me. Having all these services in one place lets me make quick and dirty automations, for example: when I create a Todoist note on my phone or watch, I often forget to set the due date, so it doesn’t show up in the “Today” view. It was literally a few lines of code to plumb things together so any inbox task without a due date gets set to today automatically.

In a twist that nobody could see coming, it turns out that a “glorious hodge-podge” is actually quite hard to maintain and very annoying to work with. It didn’t help that it had a fairly extensive Svelte frontend and I really am not a fan of JavaScript. I ended up using it less and less just because it wasn’t fun to use or work on, and I didn’t want to waste the limited LLM tokens on doing massive refactors or reworks.

I’ve got almost two decades of professional software development experience under my belt, so you’d think I would have learnt the lessons on how to write maintainable software. Hell, my CV even mentions that as something I’m particularly good at. So what went wrong?

There were a few factors. One of the obvious things to blame is that it was written mostly with LLMs. Most of that blame isn’t very honest, though. In the year or so since, LLMs have definitely got better at writing good code; but I was manually reviewing all the code at the time, and telling it quite carefully what to implement and how to do it. So the buck really stops with me.

I think it’s actually more because it was my first larger project using LLMs. It’s a bit like learning a new programming language. I don’t think the first sizable project I’ve written in any language has ever been any good. You can read and learn as much as you want, but you need to actually run into some problems headfirst to get a grip on how the language works. Or at least I do. LLM coding agents are basically the same deal.

What the LLMs actually did was mask several problems. The architecture wasn’t right for how the service developed. It started out as a single-purpose app and gradually got things bolted on, without any major changes. Everything ended up in horizontal slices: a massive database layer with every query used by every part of the app, a massive HTTP layer, and so on. Working on a single feature became a tap dance all over the source tree. This sort of friction is normally quite apparent when you’re writing code by hand, and at some point it hurts enough that you throw in the towel and do some refactoring. But the LLM will happily plod on without exposing that pain, so the project needed a more active kind of architecture management that it just didn’t get.

The other problem they covered up was how brittle and unmaintainable the JavaScript frontend was. I’m not even sure how I ended up with a Svelte frontend in hindsight. It’s my preferred framework, but I still only reach for it as a last resort when there’s no other way to avoid using one. It seems like there were lots of ways to avoid it here, but I seem to have… well… avoided them. Anyway, each feature got its own slew of Svelte components, without much thought to reusability, shared patterns, or anything sensible. Some of them were just thin wrappers around data supplied by Go, others had vast swathes of logic in them, with no real rhyme or reason as to which way that would fall. It’s the same issue as before: a human would look at it, say “WTF?” and suggest tidying it up; instead, the LLM just gets on with what you tell it to do.

There’s also a big non-LLM factor: one of the primary reasons all of this unrelated functionality got tossed into the same app was that I’d previously worked on a few projects with a microservice architecture and really didn’t like it. My conclusion was they only really worked in large environments where you can dedicate people or teams to working on all the boilerplate that happens from maintaining lots of interconnected projects. Dumping everything and the kitchen sink into one badly architected monolith was, perhaps, not the best rebound from that.

Pompei Band and beyond

When I wanted to implement ~~Strava at home~~ my PB tracking app, it seemed fairly natural to build it out as a new service, rather than bolt it on to the slowly decomposing hodge-podge that was giving off a funny smell. Then when I wanted a weather dashboard, why not do it in the same style as Pompei Band? The same serving architecture, the same page layout… I could even come up with a similar weird two-word name!

Then wouldn’t it be nice if the weather dashboard knew where I was, so it could show the local weather? I could just build that functionality in, but it’d also be a good opportunity to carve out the location history feature from my old service and make a new, shinier one. Then basically every time I even thought about going near the old service, I mentally sketched out a replacement service.

Olive Crosses showing links to the other services

At one point I had the thought that it’d be nice if the services could all link to one another, but I didn’t want to have to touch every service whenever I added a new one. So I made a “hub” service, which maintains the One True Catalogue, and provides a bit of JavaScript the others can all embed to add a navigation sidebar.

So after complaining about microservices and JavaScript, it sounds like I have landed on microservices (or at least miniservices) and JavaScript? Sort of yes, but sort of no. Each service is still its own thing and makes sense independent of the others. There are some cross-service dependencies, but they’re very simple and don’t have the same cognitive or boilerplate overhead as a login service that talks to an authentication service that queries a user manager and so on. And as for the JavaScript, it’s almost exclusively used for progressive enhancement and a few limited client-side visual things like maps and graphs. All of the logic lives in Go, which is a lot easier to maintain and test, and all of the pages are simple Go templates.

Having these services built in a way that I actually like has motivated me to play around a lot more with new features:

My workout tracking app pulls photos from my private Immich server that were taken during workouts, and shows them alongside. Now I can see all my obligatory end-of-run selfies in one place.
The location history app can detect trips away from home, and get an LLM to automatically title them. My most recent, very exotic, trip has the title “A fortnight in Milton Keynes and Coventry”. Each trip gets its own little map, and in the future I want to pull in images like with workouts.
My weight tracking app now exports weigh-ins to Garmin, as it doesn’t fully integrate with Apple Health (it will export its own weights, but not import others, like the ones from my Withings scales). Stupid walled gardens, but thankfully I can fix it myself.
My book tracking app automatically cleans up the titles of books from the nonsense provided by Amazon to something more palatable. “Killing Eve: Long Shot: A twist on obsession, betrayal and revenge from Luke Jennings, author of the TV sensation Killing Eve” becomes “Long Shot (Killing Eve #5)”. It does this by passing the title to an LLM with a bunch of rules.
The hub generates me a snippet of Tailscale configuration that defines the minimal grants needed to allow the intra-service dependencies to work.

The LLM integrations were inspired by my friend Shane who recently demonstrated an inventory tracking app he’d made, which used Haiku to process images of boxes and describe the contents. I’ve dabbled with LLM integration before, and always disliked the process of fiddling with the prompts, and debugging when the LLM gave a nonsensical response. So I built German Mall, which makes it a lot easier. It lets me define a “workflow” consisting of a system prompt, initial message, and expected response format. I can browse past runs, tweak the prompt, rerun them to see the change, all without touching the services using them. Quick iteration loops are the best. German Mall also provides markdown documentation for each workflow, so integrating it downstream is simply a case of pointing a coding agent at the right documentation endpoint.

The “tidy book titles” workflow in German Mall

It’s not all fun and games: having a bunch of services all following the same pattern means you need to do cross-cutting maintenance on them now and then. But that’s surprisingly easy with LLMs. I put all the projects in a common folder, and I launch cross-cutting tasks from that folder. Usually I’ll make the change in one project, and then the cross-cutting task is simply “Look at commit XYZ in ./foo, make the same change to the other projects”.

I’ve also ended up with a shared library used by all the projects to cut down on some boilerplate. That’s normally something I’d resist, especially with personal projects, just because the extra overhead of working in a separate project, managing releases of it, and so on, is a bit annoying. But, again, LLMs can do almost all of that grunt work. They effectively reduce the “cost” of maintaining separate services to a negligible level, leaving me to focus on the more fun aspects like coming up with new names.