Kevin Lynagh's website

On sabotaging projects by overthinking, scope creep, and structural diffing

2026-04-20T00:00:00Z

Hi friends,

I’ll be attending Babashka Conf on May 8 and Dutch Clojure Days on May 9. If you’re attending either (or just visiting Amsterdam), drop me a line!

On sabotaging projects by overthinking

When I have an idea for a project, it tends to go in one of these two directions:

I just do it. Maybe I make a few minor revisions, but often it turns out exactly how I’d imagined and I’m happy.
I think, “I should look for prior art”. There’s a lot of prior art, dealing with a much broader scope than I’d originally imagined. I start to wonder if I should incorporate that scope. Or perhaps try to build my thing on top of the existing sorta-nearby-solutions. Or maybe I should just use the popular thing. Although I could do a better job than that thing, if I put a bunch of time into it. But actually, I don’t want to maintain a big popular project, nor do I want to put that much time into this project. Uh oh, now I’ve spent a bunch of time, having neither addressed the original issue nor experienced the joy of creating something.

I prefer the first outcome, and I think the pivotal factor is how well I’ve internalized my own success criteria.

For example, last weekend I hosted my friend Marcin and we decided it’d be fun to do some woodworking, so we threw together this shelf and 3d-printed hangers for my kitchen:

Absolute banger of a project:

brainstormed the design over coffee
did a few 3d-print iterations for the Ikea bin hangers (OnShape CAD, if you want to print your own)
used material leftover from my workbench
rounded the corner by eye with a palm sander
sealed the raw plywood edge with some leftover paint from a friend
done in a weekend

The main success criteria was to jam on woodworking with a friend, and that helped me not overthink the object-level success criteria: Just make a shelf for my exact kitchen!

In contrast, this past Friday I noticed difftastic did a poor job, so I decided to shop around for structural/semantic diff tools and related workflows (a topic I’ve never studied, that I’m increasingly interested in as I’m reviewing more and more LLM-generated code).

I spent 4 hours over the weekend researching existing tools (see my notes below), going through dark periods of both “semantic tree diffing is a PhD-level complex problem” and “why do all of these have MCP servers? I don’t want an MCP server”, before I came to my senses and remembered my original success criteria: I just want a nicer diffing workflow for myself in Emacs, I should just build it myself — should take about 4 hours.

I’m cautiously optimistic that, having had this realization and committing myself to a minimal scope, I’ll be able to knock out a prototype before running out of motivation.

However, other long-running interests of mine:

interfaces for prototyping hardware (discussed September 2023)
a programming language that fuses what I like about Clojure and Rust (November 2023)
a programming language for CAD (constraints, bidirectional editing, other dubious ideas)

seem to be deep in the well of outcome #2.

That is, I’ve spent hundreds of hours on background research and little prototypes, but haven’t yet synthesized anything that addresses the original motivating issue.

It’s not quite that I regret that time — I do love learning by reading — but I have a nagging sense of unease that my inner critic (fear of failure?) is silencing my generative tendencies, keeping me from the much more enjoyable (and productive!) learning by doing.

I think in these cases the success criteria has been much fuzzier: Am I trying to replace my own usage of Rust/Clojure? Only for some subset of problems? Or is it that I actually just need a playground to learn about language design/implementation, and it’s fine if I don’t end up using it?

Ditto for CAD: Am I trying to replace my commercial CAD tool in favor of my own? Only for some subset of simple or particularly parametric parts? Do I care if it’s useful for others? Does my tool need to be legibly different from existing open-source tools?

It’s worth considering these questions, sure. But at the end of the day, I’d much rather have done a lot than have only considered a lot.

So I’m trying to embrace my inner clueless 20-year-old and just do things — even if some turn out to be “obviously bad” in hindsight, I’ll still be coming out ahead on net =D

Conservation of scope creep

Of course, there’s only so much time to “just do things”, and there’s a balance to be had. I’m not sure how many times I’ll re-learn YAGNI (“you ain’t gonna need it”) in my career, but I was reminded of it again after writing a bunch of code with an LLM agent, then eventually coming to my senses and throwing it all out.

I wanted a Finda-style filesystem-wide fuzzy path search for Emacs. Since I’ve built (by hand, typing the code myself!) this exact functionality before (walk filesystem to collect paths, index them by trigram, do fast fuzzy queries via bitmap intersections), I figured it’d only take a few hours to supervise an LLM to write all the code.

I started with a “plan mode” chat, and the LLM suggested a library, Nucleo, which turned up since I wrote Finda (10 years ago, eek!). I read through it, found it quite well-designed and documented, and decided to use it so I’d get its smart case and Unicode normalization functionality. (E.g., query foo matches Foo and foo, whereas query Foo won’t match foo; similarly for cafe and café.)

Finding a great library wasn’t the problem, the problem was that Nucleo also supported some extra functionality: anchors (^foo only matches at the beginning of a line).

This got me thinking about what that might mean in a corpus that consists entirely of file paths. Anchoring to the beginning of a line isn’t useful (everything starts with /), so I decided to try and interpret the anchors with respect to the path segments. E.g., ^foo would match /root/foobar/ but not /root/barfoo/.

But to do this efficiently, the index needs to keep track of segment boundaries so that the query can be checked against each segment quickly.

But then we also need to handle a slash occurring in an anchored query (e.g., ^foo/bar) since that wouldn’t get matched when only looking at segments individually (root, foo, bar, and baz of a matching path /root/foo/bar/baz/).

Working through this took several hours: first throwing around design ideas with an LLM, having it write code to wrap Nucleo’s types, then realizing its code was bloated and didn’t spark joy, so finally writing my own (smaller) wrapper.

Then, after a break, I realized:

I can’t think of a situation where I’d ever wished Finda had anchor functionality
In a corpus of paths, I can anchor by just adding / to the start or end of a query (this works for everything except anchoring to the end of a filename).

So I tossed all of the anchoring code.

I’m pretty sure I still came out ahead compared to if I’d tried to write everything myself sans LLM or discussion with others, but I’m not certain.

Perhaps there’s some kind of conservation law here: Any increases in programming speed will be offset by a corresponding increase in unnecessary features, rabbit holes, and diversions.

Structural diffing

Speaking of unnecessary diversions, let me tell you everything I’ve learned about structural diffing recently — if you have thoughts/feelings/references in this space, I’d love to hear about ‘em!

When we’re talking about code, a “diff” usually means a summary of the line-by-line changes between two versions of a file. This might be rendered as a “unified” view, where changed lines are prefixed with + or - to indicate whether they’re additions or deletions. For example:

We’ve removed coffee and added apple.

The same diff might also be rendered in a side-by-side view, which can be easier to read when there are more complex changes:

The problem with these line-by-line diffs is that they’re not aware of higher-level structure like functions, types, etc. — if some braces match up somehow between versions, they might not be shown at all, even if the braces “belong” to different functions.

There’s a wonderful tool, difftastic, which tries to address this by calculating diffs using treesitter-provided concrete syntax trees. It’s a huge improvement over line-based diffs, but unfortunately it doesn’t always do a great job matching entities between versions.

Here’s the diff that motivated this entire foray:

Note that it doesn’t match up struct PendingClick, it shows it deleted on the left and added on the right.

I haven’t dug into why difftastic fails to match here, but I do feel like it’s wrong — even if the overall diff would be longer, I’d still rather see PendingClickRequest and PendingClick matched up between both sides.

Here’s a summary of tools / references in the space:

The most “baked” and thoughtful semantic diff tool I found is, perhaps unsurprisingly, semanticdiff.com, a small German company with a free VSCode plugin and web app that shows diffs for github PRs. Unfortunately they don’t have any code libraries I can use as a foundation for the workflow I want.
- this semanticdiff vs. difftastic blog post covers a lot of great details (including that difftastic doesn’t even show semantically meaningful indentation changes in python !!!)
- one of the authors has great HN comments with hard-won background knowledge. E.g., they moved away from treesitter because it’s unreliable for semantics:
Context-sensitive keywords in particular were a constant source of annoyance. The grammar looks correct, but it will fail to parse because of the way the lexer works. You don’t want your tool to abort just because someone named their parameter “async”.
diffsitter
- built on treesitter, has MCP server. README includes list of similar projects.
- lots of github stars, but doesn’t seem particularly well-documented; I couldn’t find an explanation of how it works, but the difftastic wiki says it “runs longest-common-subsequence on the leaves of the tree”
gumtree
- research / academic origin in 2014
- requires Java, so no-go for my use case of a quick tool I can use via Emacs
mergiraf: treesitter-based merge-driver written in rust
- very nice architecture overview; tool uses Gumtree algorithm
- docs and adorable illustrations indicate this project was clearly written by a thoughtful human
- semanticdiff.com author in HN comments: > GumTree is good at returning a result quickly, but there are quite a few cases where it always returned bad matches for us, no matter how many follow-up papers with improvements we tried to implement. In the end we switched over to a dijkstra based approach that tries to minimize the cost of the mapping
weave: also a treesitter-based merge-driver written in Rust
- feels a bit “HN-optimized” (flashy landing pages, lots of github stars, MCP server, etc.)
- I looked into their entity extraction crate, sem
- core diffing code is OK but pretty wordy
- greedy entity matching algorithm
- data model can’t detect intra-file moves, even though those might be significant
- includes a lot of heuristic “impact” analysis, which feels like overreaching-scope to me since it’d require much tighter language integration before I’d trust it
  - ran into buggy output when running sem diff --verbose HEAD~4; it showed lines as having changed that…didn’t change at all.
- Too much 80%-done, hypothetically useful functionality for me to use as a foundation, but props for sure to the undergrad/student(?) who’s built all this in just three months.
diffast: tree edit-distance of ASTs based on an algorithm from a 2008 academic paper.
- supports “Python, Java, Verilog, Fortran, and C/C++ via dedicated parsers”
- has a nice gallery of example AST differences
- can export info in tuples for datalog
autochrome: Clojure-specific diffs based on dynamic programming
- excellent visual explanation and example walkthrough
Tristan Hume has a great article on Designing a Tree Diff Algorithm Using Dynamic Programming and A*

My primary use case is reviewing LLM output turn-by-turn — I’m very much in-the-loop, and I’m not letting my agent (or dozens of them, lol) run wild generating 10k+ lines of code at a time.

Rather, I give an agent a scoped task, then come back in a few minutes and want to see an overview of what it did and then either revise/tweak it manually in Emacs or throw the whole thing out and try again (or just write it myself).

The workflow I want, then, is to

see a high-level overview of the diff: what entities (types/functions/methods) were added/removed/changed?
quickly see textual diffs on an entity-by-entity basis (“expanding” parts of the above summary)
quickly edit any changes, without having to navigate elsewhere (i.e., do it inline, rather than having to switch from “diff” to “file)

Basically, I want something like Magit’s workflow for reviewing and staging changes, but on an entity level rather than file/line level.

In light of the "minimal scope, just get your project done” lesson I’ve just re-learned for the nth time, my plan is to:

throw together my own treesitter-based entity extraction framework (just Rust for now)
do some simple greedy matching for now
render the diff to the command line

Once that seems reasonable (i.e., it does a better job than difftastic did on that specific commit), I’ll:

wire into a more interactive Magit-like Emacs workflow (maybe I can reuse Magit itself!?!)
add support for new languages, as I need them
potentially explore more sophisticated score-based global matching rather than simple greedy matching

Mayyybe if I’m happy with it I’ll end up releasing something. But I’m not trying to collect Github stars or HN karma, so I might just happily use it in the privacy of my own home without trying to “commercialize it”.

After all, sometimes I just want a shelf.

Misc. stuff

I’m in the market for a few square meters of Tyvek or other translucent, non-woven material suitable for building a light diffuser — let me know if you have any favorite vendors that can ship to the EU.
How They Made This - Coinbase Commercial Breakdown. Crypto is a negative-sum parasite on productive economic activity, but has the silver lining of funneling a lot of capital to weird creative folks.
A tail-call interpreter in (nightly) Rust
The Easiest Way To Design Furniture…. Laura Kampf on getting off the computer and designing physical spaces with tape, lil’ wood sticks, and cardboard.
Hotel California - Reimagined on the Traditional Chinese Guzheng
C is not a low-level language: Your computer is not a fast PDP-11.
I Taught My Dog to Vibe Code Games - Caleb Leak
Loon is a Lisp. Thrilled to discover I’m not the only one who wants to mash together Clojure and Rust. The current implementation seems to have been manically vibe-coded and I quickly ran into some terrible bugs, but on the other hand it exists so I’m not going to be a hater.
Made a print in place box so I can easily hand out printed bees🐝. “Im quite content with the result, the bees fit snugly and the box opens and closes nicely”
Yeast-based vaccines are a big deal for biosecurity
“There isn’t a lot of reliable information out there about how to buy a gas mask, especially for the specific purpose of living under state repression. But hopefully after reading this guide you’ll feel equipped to make an educated decision.”
“This zoomable map shows every page of every issue of BYTE starting from the front cover of the first issue (top left) to the last page of the final edition (bottom right). The search bar runs RE2 regex over the full text of all 100k pages.” A lovely reminder that user-interfaces can be extremely fast and information dense.
How Every* Milk Product Is Made
In Favour of Trying New Things – Daniel Frank
Staring into the abyss as a core life skill

Easy VM sandboxes for LLM agents on MacOS, Miami & Paris travel

2026-02-01T00:00:00Z

Hi friends,

I’m traveling the next two weeks, drop me a line if you want to grab a coffee!

Miami Monday Feb 2 — Tuesday Feb 10
Paris Wednesday Feb 11 — Sunday Feb 15

LLM agent virtual machine sandbox

The other day I asked OpenAI’s Codex agent to write me a lil’ Rust program to use a bluetooth gamepad as a mouse, and I caught the agent reading files outside of the directory I started it in. I found this quite surprising, since I assumed it’d be contained within the project folder. (I was using the default settings, not the more permissive --yolo mode.)

I don’t like the idea of an LLM agent rooting around my computer and uploading anything it finds to OpenAI, so I started shopping around for a “sandbox” — something I could let an agent loose inside of while maintaining explicit control of what it sees.

I searched around and was, unfortunately, unable to find any Mac solution that met my requirements:

be an actual VM, not a container thingy (containers are less secure, and on MacOS they require a Linux VM anyway)
be easy to spin up/down quickly with no configuration ceremony
not involve other people’s servers, subscriptions, etc., etc.

That’s fine — I’ve been messing with virtual machines for 20 years now, surely I can throw something together in an hour or two!

Well, uh, several busy weekends later, I’d like to present Vibe, an easy way to spin up virtual machines on ARM-based Macs.

I’m quite pleased with how it turned out:

You type vibe in a folder and in ~10 seconds are inside of a Linux virtual machine.
The folder is automatically mounted within the VM, so you can monitor an agent’s work from the comfort of your regular Mac text editor, Git UI, etc.
Common package caches (Cargo’s registry, Maven’s ~/.m2, mise-en-place) are also shared so the sandbox VM doesn’t need to re-download stuff.
The binary is < 1 MB and has no dependencies.

Being able to run LLM agents as root with --yolo mode is a great experience. It feels much more like managing an IC — you provide the necessary context in a big prompt, tell them to install whatever tools they need, and then let them cook for while you go focus on something else.

While the vibe defaults are geared towards use as an LLM agent sandbox, you can customize everything with scripts and command line flags so you can use it for all sorts of other virtual machine purposes.

Check it out and let me know what you think!

Misc. stuff

I recently bought a $150 GL-MT6000 router so I could make a separate “offline” network for stuff like my 3D-printer and Windows computer that I want to keep off the Internet. The router is awesome! It comes with the open source OpenWRT firmware installed, which provides a fast web UI, simple text configs you can backup with rsync, and lots of built-in functionality like AdGuard (blocks ads for every device on the network via DNS) and Wireguard/Tailscale (easy VPN so you can access your home network from anywhere). Highly recommended.
Last newsletter I mentioned vibecoding a copy from mac photos app since I couldn’t get the functionality I needed from the otherwise great Clop Mac photo resizing utility. Well it turns out the author subscribes to this newsletter, checked out my source code, and immediately added the feature. If that isn’t enough of a coincidence, he also loved my powered air respirator project since he’s a woodworker too and has been developing his own hardwax oils for the turned coffee cups he sells. I love the Internet.
“In this post, we will explain why the “concurrency + floating point” hypothesis misses the mark, unmask the true culprit behind LLM inference nondeterminism, and explain how to defeat nondeterminism and obtain truly reproducible results in LLM inference.”
“In the past, almost everybody travelled on the left side of the road because that was the most sensible option for feudal, violent societies.”
ASCII characters are not pixels: a deep dive into ASCII rendering
It sounds dumb but they really fixed a typo with a human leg
Every James Cameron Movie, Explained by James Cameron
Apple Rankings: The definitive list of good and bad apples.
The Bloomberg Terminal UX team is not messing around: “Making substantial changes, even good ones, will reliably annoy a percentage of customers, so Jeffery’s team plans redesigns with incremental updates that roll out over weeks or months. For example, when they wanted to flatten the gradient of an element, they wouldn’t do so all at once, instead changing it little by little each month.”
TIL that the founder of Reuters started with a carrier-pigeon line between Berlin and Paris before eventually laying their own transatlantic telegraph cable.

Tools I loved in 2025

2026-01-04T00:00:00Z

Hi friends!

While answering 40 questions to ask yourself every year, I realized I’d adopted a bunch of new tools over 2025. All of them have improved my life, so I want to share them with you so they might improve yours too =D

A common theme is that all of my favorite tools promote a sort of coziness: They help you tailor the spaces where you spend your time to your exact needs and preferences.

Removing little annoyances and adding personal touches — whether to your text editor or your kitchen — not only improves your day-to-day mood, but cultivates a larger sense of security, ownership, and agency, all of which I find essential to doing great work. (And making great snacks.)

Physical
Digital
Misc. stuff

Physical

Workshop space

Last summer we moved to a ground-level apartment, giving me (for the first time in my life) my very own little workshop space:

We’re just renting the apartment, so building a larger shed isn’t an option, but it turns out that one can get quite a lot done with floor area barely larger than a sheet of plywood.

I designed a Paulk-style workbench top, cut it out on my friend’s CNC, and mounted it all on screwed-together 2x4 legs:

So far I’ve mostly worked with cheap plywood from Hornbach, using the following tools:

Makita track saw for both rough and precision cuts. There’s a handy depth stop that makes it easy to do a shallow scoring cut before making a full cut, which reduces tearing out the thin veneer.
Fein wet/dry vac to collect dust/chips. This includes an electrical outlet you can plug tools in to so the vacuum automatically turns on when the tool is drawing power, which is great.
My DIY powered air respirator built around a 3M Versaflo helmet has been working great — it’s so much more comfortable than fiddling with separate respirators and eye + ear protection. Since it takes 15 seconds to take on/off, I’m pretty much always wearing it when I’m doing anything in the shop.
Record Power Sabre 250 desktop bandsaw for quick cross cuts. The accuracy isn’t great, but I haven’t tried replacing the blade or tuning it much yet.
Bosch 12V palm edge router extremely fun to use for rounding over and chamfering edges:
Bosch 12V drill/driver is lightweight and compact, and comes with a handy right-angle attachment that I’ve actually used:
Bosch PBD 40 - a drill press with digital speed control and zeroable digital depth gauge with 0.1mm precision. At $250, the 0.5mm play in the chuck is forgivable.

The workbench has MFT-style 20mm “dog holes” on a 96mm grid, which allows for all sorts of useful accessories.

For example: I purchased Hooked on Wood’s bench dog rail hinges, which makes it easy to flip the track up/down to slide wood underneath to make cross cuts:

The $10 dog hole clamp on the right holds a stop block, which allows me to make repeated cuts.

Since the dog holes were cut with a CNC and the rail is straight, square cuts can be made by:

making a known straight cut with the track saw on its track (whether on the workbench or outside on sawhorses)
pushing this reference edge up against the two bench dogs on the top
cutting along the track

See Bent’s Woodworking for more detail on this process.

While I wish I had space for a full size sliding table saw and/or CNC, this workbench and track saw seems like a decent backyard shed solution.

LED lighting

Last winter I decided to fight the gloomy Dutch weather by buying a bunch of high-CRI LEDs to flood my desk with artificial daylight:

See the build log for more details.

This lighting has worked out swimmingly — it helps me wake up in the morning and makes the whole space feel nice even on the grayest rainy day.

After sundown, my computer switches to “dark mode” colors and I switch the room to cozier warm-white LEDs.

I had about 8 meters of LED strip leftover, which I used with LED diffuser profiles to illuminate my workshop.

Euroboxes

When we moved into our new (completely unfurnished) apartment over the summer, I was adamant I’d build all of the furniture we needed. However, sightly storage solutions have taken longer than anticipated, so to eliminate the immediate clutter I purchased a bunch of 600x400x75mm euroboxes:

At $4/each (used), they’re an absolute bargain.

Since they’re plastic, they slide great on waxed wood rails and make perfect lil’ utility drawers. The constraint of needing to use fixed size drawers makes it easier for me to design the rest of a furniture piece around them.

For example, just take a brad nailer to the limitless amounts of discarded particle board available on the streets of Amsterdam, and boom, one-day-build 3d-printer cart in the meter closet:

Or, throw some drawers in the hidden side of these living room plywood coffee table / bench / scooters:

Now we have a tidy place to hide the TV remote and wireless keyboard/mouse, coffee table books, store extra blankets, etc.

Ikea Skadis coffee/smoothie station

Our kitchen only has 1.6 m² (17 ft²) of counter space, so we mounted two Ikea Skadis pegboards to the side of our fridge to make a coffee / smoothie station:

The clear Ikea containers are great for nuts and coffee since you can grab them with one hand and drop ‘em in the blender or grinder.

I designed and 3d-printed custom mounts for my Clever Dripper, coffee grinder (1Zpresso k-series), little water spritzer, and bottles of Friedhats beans.

Since we can’t screw into the fridge, the panels are hanging from some 3d-printed hooks command stripped on the top of the fridge cabinet. Clear nano-tape keeps the Skadis boards from swinging.

The cheap Ninja cup blender is quite loud, so we leave a pair of Peltor X4 ear defenders hanging next to it.

Ikea Maximera drawers

As soon as we made the smoothie station we decided to replace the cabinet shelves underneath it with drawers. (The only drawers that came with the kitchen were installed underneath the range, creating constant conflict between the cook and anyone needing silverware.)

Decent soft-close undermount drawer slides from Blum/Hettich cost like $30 each, and for the same price Ikea sells slides with a drawer box attached.

Since we’re renting and can’t make permanent changes to the kitchen, I built a carcass for the drawers within the existing cabinet:

The particle board sides carry the weight of the drawers to the base of the existing cabinet, and they’re fixed to the walls with nano-tape rather than screws.

Nicki 3d-printed cute pulls and we threw those onto temporary fronts made of leftover MDF. As you can see from the hardware poking through, these 8mm fronts are a bit too thin, so I plan to replace them with thicker MDF, probably sculpted with a goofy pattern in the style of Arno Hoogland.

Having drawers is awesome:

We bought a bunch of extra cups for the Ninja blender and keep them pre-filled with creatine and protein powder. The bottom drawer holds the dozen varieties of peanut butter remaining from the Gwern-inspired tasting I held in November. (The UK’s Pip & Nut peanut butters were the crowd favorites, by the way.)

Digital

Emacs and LLMs

I’ve used Emacs for something like 15 years, but after the first year or so I deliberately avoided trying to customize it, as that felt like too much of a distraction from the more important yaks I was shaving through my 20’s and early 30’s.

However, in early 2025 I decided to dive in, for two reasons:

I ran across Prot’s video demonstrating a cohesive set of well-designed search and completion packages, which suggested to me that there were interesting ideas being developed in the “modern” Emacs community
I discovered gptel, which makes it extremely easy to query large language models within Emacs — just highlight text, invoke gtpel, and the response is inserted right there.

What’s special about Emacs compared to other text editors is that it’s extremely easy to customize. Rather than a “text editor”, Emacs is better thought of as an operating system and live programming environment which just so happens to have a lot of functions related to editing text.

My day-to-day coding, writing, and thinking environment within Emacs has improved tremendously in 2025, as every time I’ve had any sort of customization or workflow-improvement idea, I’ve been able to try it out in just a minute or two by having an LLM generate the necessary Emacs Lisp code.

My mentality changed to “yeah, I’m sure it’s possible but I don’t have time or interest to figure out how to do it with this archaic and quirky programming language” to “let me spend two minutes trying”.

Turns out there’s a lot of little improvements that can be done by an LLM in few minutes. Here are some examples:

Literally for this article, I asked the LLM to write a Ruby method for my static site generator to render a table of contents (which you can see above!)
Lots of places don’t support markdown natively, so I had an LLM write me an Emacs function to render selected markdown text to HTML on the pasteboard, which lets me write in Emacs and then just ⌘V in Gmail to get a nicely formatted message.
When I write markdown and want to include an image, it’s annoying to have to copy/paste in the path to the image, so I had an LLM write me an autocomplete against all of the image files in the same directory as the markdown file. I’ve been using this for pretty much every article/newsletter I write now, since they usually have images.
I keep a daily activity log as a simple EDN file with entries like:
```
{:start #inst "2025-12-28T12:00+01:00" :tags #{"lunch" "nicki"} :duration 2} 
{:start #inst "2025-12-28T09:00+01:00" :tags #{"paneltron" "computering"} :duration 6
 :description "rough out add-part workflow."}
{:start #inst "2025-12-28T08:20+01:00" :tags #{"wakeup"}}
```
(Everything’s rounded to the half-hour.)

I started this when I was billing by the hour (a decade ago), and have kept it up because it’s handy to have a lightweight, low-friction record of what I’ve been up to. I used to do occasional analysis manually via a REPL, but couldn’t sleep one night so I spent 30 minutes having an LLM throw together a visual summary which I can invoke for whatever week is under my cursor. It looks like:
```
Week: 2025-12-22 to 2025-12-28

Locations:
  Amsterdam - Friday 2025-12-19T13:30+01:00

computering       16.5h ##################
box-carts         14.5h ###############
woodworking       13.0h ##############
llms               8.0h ########
dinner             7.0h #######
```
and includes my most recent :location (an attribute I started tagging entries with to help keep track of visa limitations while traveling).

I’m extremely chuffed about having quick access to weekly summaries and suspect that tying that to my existing habit of recording entries will be a good intra-week feedback loop about whether I’m spending time in alignment with my priorities.
Whenever I write an article or long message, before sending it I run it by an LLM with the following prompt:

my friend needs feedback on this article — are there any typos, confusing sentences, or other things that could be improved? Be blunt and I’ll convey the feedback to my friend in a friendly way.

This one doesn’t even involve any code, it’s just a habit that’s easy because it’s easy to call an LLM from within Emacs. LLMs will note repeated words, incorrect homonyms, and awkward sentences that simple spell-checkers miss. Here’s an example from this very article:
1. Double parenthesis: [Paulk-style]((https://www.youtube.com/watch?v=KnNi6Tpp-ac)) — remove one set
2. “Ikea Maximara drawers” in the heading, but the product is actually “Maximera”
3. http://localhost:9292/newsletter/2025_06_03_prototyping_a_language/ — you’ve left a localhost URL in the FlowStorm section

Emacs has a pretty smooth gradient between “adjust a keybinding”, to “quick helper function”, to a full on workflow. Here’s an example from the latter end of that spectrum.

I asked Claude Code to make some minor CSS modifications for a project, then got nerd-sniped trying to understand why it used a million tokens to explore my 4000-word codebase and edit a dozen lines:

Usage by model:
        claude-haiku:  8.6k input, 5.4k output, 434.2k cache read, 33.4k cache write ($0.1207)
       claude-sonnet:  1.0k input, 262 output, 0 cache read, 0 cache write ($0.0069)
     claude-opus-4-5:  214 input, 8.3k output, 842.5k cache read, 47.8k cache write ($0.93)

After a bit of digging, it seemed likely this is a combination of factors:

Claude Code’s system and tool prompts
Repeatedly invoking tools to grep around the directory and read files 200 lines at a time
Absolute nonsense — Mario Zechner has some great analysis on this (fun fact: “Claude Code uses Haiku to generate those little whimsical "please wait” messages. For every. token. you. input.“).

For comparison, I invoked Opus 4.5 manually with all of my source code and asked what I needed to change, and it nailed the answer using only 5000 tokens (4500 input, 500 output).

So I leaned into this and wrote my own lightweight, single-shot workflow in Emacs:

I write something like:

@rewrite

/path/to/file1
/path/to/file2

Please do X, Y, Z, thanks!

and when I send it, some elisp code:

adds the specified files to the context window
sets the system prompt to be "please reply only with a lil’ string replacement patch format that looks like …”
sends the LLM response to a Babashka script which applies this patch, sandboxed to just the specified files.

I’ve used it a handful of times so far and it works exactly the way I’d imagined — it’s much faster than waiting for an “agent” to make a dozen tool calls and lets me take advantage of LLMs for tedious work while remaining in the loop.

(Admittedly, this one took a few hours rather than a few minutes, but it was well worth it in terms of getting some hands-on experience building a structured LLM-based workflow.)

A little Photos.app exporter

When you copy images out of Photos.app, it only puts a 1024 pixel wide “preview image” on the pasteboard. This loses too much detail.

The built-in “export” workflow is tedious to use and doesn’t actually compress well, so you have to do another pass through Squoosh or ImageOptim anyway. Of course, you’ll want to resize before you do that, maybe in Preview?

I noticed how annoyed I was trying to add photos to my articles, so I vibe-coded a little Photos.app exporter that behaves exactly like how I want.

UV (Python dependencies)

I haven’t done much Python in my career, but it’s a popular language that I’d occasionally need to tap into to use some specific library (e.g., OpenCV, NumPy, JAX) or run the code behind some interesting research paper.

The package management has always been (from my perspective of a casual outsider) an absolute mess. Yes, with lots of good reasons related to packaging native code across different operating systems and architectures, etc. etc. etc.

Whatever, if pip install failed to build my eggs or wheels or whatever, I’d usually just give up.

As for reproducibility and pinning to exact versions…¯\_(ツ)_/¯.

“Maybe if I do nothing the problem will fix itself” isn’t a great problem solving strategy, but it definitely worked out for me for understanding Python dependency managers: I came across UV in late 2024 and it…just works? It’s also fast!

I can now finally create a Python project, specify some dependencies, and automatically get a lockfile ensuring it’ll will work just fine on my other computer, 6 months from now!

This problem has been a thorn in the side of not just software developers, but also scientific researchers for decades. The folks who’ve finally resolved it deserve, like, the Nobel Peace prize.

Mise-en-place (all dependencies)

This past year I’ve also been loving mise-en-place. From their homepage:

mise is a tool that manages installations of programming language runtimes and other tools for local development. For example, it can be used to manage multiple versions of Node.js, Python, Ruby, Go, etc. on the same machine.

Once activated, mise can automatically switch between different versions of tools based on the directory you’re in. This means that if you have a project that requires Node.js 18 and another that requires Node.js 22, mise will automatically switch between them as you move between the two projects.

I’ve used language-specific versions of this idea, and it’s been refreshing to throw all of those out in favor of a single uniform, fast solution.

I have a user-wide “default” config, containing stuff like:

languages (a JVM, clojure, ruby)
language servers (clojure-lsp, rust analyzer, etc.)
git-absorb “git commit –fixup, but automatic”
Difftastic AST-aware diffing
Numbat, an awesome unit-aware scientific calculator

and on specific projects I specify the same and additional tools, so that collaborators can have a “single install” that guarantees we’re all on the same versions of everything.

Sure something like Nix with hermetically sealed, content addressed, etc., etc. is better in theory, but the UX and conceptual model is a mess.

Mise feels like a strong, relatively simple local optimum: You specify what you want through a simple hierarchy of configs, mise generates lockfiles, downloads the requested dependencies, and puts them on the $PATH based on where you are.

I’ve been using it for a year and haven’t had to learn anything beyond what I did in the first 15 minutes. It works.

Atuin (shell history)

Atuin records all of your shell commands, (optionally) syncs them across multiple computers, and makes it easy to recall commands with a fuzzy finder. It’s all self-hostable and is distributed as a single binary.

I find the shell history extremely useful, both for remembering infrequently used commands, as well as for simply avoiding typing out tediously long ones with many flags. Having a proper fuzzy search that shows a dozens of results (rather than just one at a time) makes it straightforward to use.

Before this I wouldn’t have thought twice about my shell command history, and now it’s something I deliberately back up because it’s so useful.

YouTube Premium

At some point in 2025 the ad-blocker I was using stopped working on YouTube and I started seeing either pauses or (uggghhh) commercials (in Dutch, which Google must think I understand, despite 15 years of English GMail, not to mention my Accept-Language header).

Given that YouTube is a Wonder of the World and a $20/month leaves me with a consumer surplus in the neighborhood of $10⁴–10⁵, I decided to subscribe to YouTube Premium.

Honestly I just wanted the ads to stop, but it’s even better — I can conveniently download videos to my phone, which means I can watch interesting videos while riding on the stationary exercise bike in the park near my house.

It also comes with YouTube Music, which immediately played me a late 00’s indie rock playlist that brought me back to college.

100% worth it.

FlowStorm (Clojure debugger)

I don’t normally use debuggers, especially since in Clojure it’s usually straightforward to pretty-print the entire application state.

However, this usual approach failed me when I was building an interpreter for some CAD programming language experiments — each AST node holds a reference to its environment (a huge map), and simply printing a tree yields megabytes of text.

FlowStorm takes advantage of the fact that idiomatic Clojure uses immutable data structures — the debugger simply holds a reference to every value generated during a computation, so that you can analyze them later.

There are facilites to search all of the recorded values. So if you a see a string “foo” on your rendered webpage or whatever, you can easily answer questions like “where is the first callstack where the string ‘foo’ shows up?”.

All of the recorded data is available programmatically too. I used this infrastructure to make a live visualization of a 2D graphics program where as you move your cursor around the program source code, you see the closest graphical entity rendered automatically.

(“A debounced callback triggered by cursor movement which executes Clojure code and highlights text according to the return value” is another example of an Emacs customization I never would have attempted prior to LLMs.)

Whispertron (transcription)

I vibe-coded my own lil’ voice transcription app back in October 2024, but I’m including it in this list because using it has become second-nature to me in 2025.

Before I had reliable transcription at my fingertips, I never felt hindered by my typing speed (~125 words per minute). However, now that I have it, I find that I’m expressing much more when I’m dictating compared to typing.

It reminds me of the difference between responding to an email on an iPhone versus using a computer with a large monitor and full keyboard. I find myself providing much more context and otherwise elaborating my thoughts in more detail. It’s just easier to speak out loud than type out the same information.

This yields much better results when prompting LLMs: typing, I’ll say “do X”; speaking, I’ll say “do X, maybe try A, B, C, remember about Y and Z constraints”.

It also yields better relationships: When emailing and texting friends, I’ll dictate (and then clean up / format) much more detailed, longer responses than what I’d type.

Misc. stuff

I’ve been experimenting with making keyboard-driven, data-dense interfaces on the web. So far I’ve been using the same DataScript + Rum + Elm-style architecture that I’ve been using since Subform in 2016, but I’m looking at updating to Replicant and Nexus, which look pretty solid.
- One piece I still find myself missing in Clojure is modeling my application state with algebraic data types and having my tooling remind me to handle all of the possible cases. I’m not thrilled about writing UI in Rust, but nor does it seem like a good idea to pick up and try to master a new language (F#, Gleam, TypeScript, …Elm?). I’ll be investigating tools and patterns to try and get some of the “statically typed” developer experience in Clojure — if you have any suggestions, I’d love to hear ‘em!
Portals must bend gravity, actually. Video games that don’t respect conservation of energy really bothers some folks.
“So yes, Canada lost its measles elimination status today. But we can get it back in a year and a bit, if we’re serious. And if we’re serious about eliminating measles again, we need to focus more on investing in healthcare workers who speak the language of and can build relationships in communities, and less on implying that certain populations are just inherently unreachable, which just seems like a fundamentally anti-helpful thing to do.”
One year of building my own IDE in clojure
Who watches the Waymos?
What I learned building an opinionated and minimal coding agent
“We’re not sure why. Going into the study, we assumed that all three techniques created the correct muscular configuration for an expression of happiness. But we found some evidence that the pen-in-mouth condition may not be actually creating an expression that closely resembles smiling.”
Web browsers have stopped blocking pop-ups
Obra Dinn’s “pixel art” is actually genius
Game Architectures with Alex Evans and Anton Mikhailov - The folks behind the world-building videogame Dreams discuss implementing a purely deterministic game engine with functional updates.
For Decades, Cartographers Have Been Hiding Covert Illustrations Inside of Switzerland’s Official Maps
TOKN: Token-Optimised KiCad Notation

Pindakaas party, plywood problems, and CNC daydreams

2025-11-16T00:00:00Z

Peanut butter tasting (!!!)

I recently re-read Gwern On Having Enough Socks and, uh, now I’m hosting a blind-tasting of a dozen peanut butters this Saturday, November 22 in Amsterdam. If you’re in town, email me for the event details. Together we will find the best 100% pindakaas met stukjes.

A shoe tower

The weather has turned chilly, and my girlfriend is highly encouraging me to build some bedroom storage so our coats and sweaters are more accessible.

Since making a standard box wardrobe out of plywood would be more expensive and time consuming yet aesthetically indistinguishable from Ikea, I decided to explore a lightweight frame using the hardwood dowels left over from my floating castle desk.

In particular, I wanted to cut a groove in the dowels to hold (and hide) the raw edge of thin plywood shelves.

I 3D-printed a custom shoe for my lil’ trim router:

but this yielded poor results, so I ended up buying a full-sized plunge router.

As it turns out, it takes a lot to hold round wood down securely to a table and route a groove exactly down the center. I eventually got there with enough scrap material, clamps, and track saw track as straight edge:

Since I was using decorative pan head screws, I needed both through holes (for the screw shafts) and counterbores (for the shiny heads) along the dowels. Free-handing with a drill worked about as well as you might expect — turns out it’s very obvious when a 15mm diameter counterbore isn’t exactly centered on a 20mm diameter dowel — so I ended up buying a benchtop drill press:

This Bosch PBD 40 has some awesome features like electronic speed control and digital depth readout. Unfortunately, it also came with noticeable wiggle in the chuck and about 1mm deviation between the base plate’s v-groove and the drill center, both of which make it impossible to throw material down and get a repeatable hole location — you have to carefully line everything up first.

As far as I can tell (please let me know if I’m wrong!) there’s not really anything better on the market until you’re willing to spend for the $1,400 Nova Viking benchtop drill press.

After much drilling, I decided there was absolutely no way I was going to enjoy building a shoe tower using dowels (much less an entire bedroom storage system), so I demoted this prototype down to “plant stand”, which ended up turning out OK:

(Just ignore all those extra holes.)

I used brass tube to hide the screw threads. Originally I thought I’d be able to easily cut brass tube with a hacksaw — turns out absolutely not; brass is way too gummy and it’s impossible (for me, anyway) to maintain a consistent cut line by hand. Luckily, I found one of these $10 things which, pleasingly, is extremely good at its one job:

(Notice the the right side piece was crushed in a drill chuck and has an all-over-the-place failed cut from me earlier attempting to cut it by spinning it against a clamped-down hacksaw.)

For my second shoe tower attempt, I wanted a lightweight plywood frame combined with fabric — something in the direction of Mieke Meijer’s Airframe cabinet (which looks cool as hell).

That build went much more smoothly, and the final product turned out better than I expected:

The only hiccup during the build was discovering that my dowel jig won’t work with material thinner than 15mm (my plywood was 12mm). I made a sort of jig/guide using my new drill press and a bit of scrap wood, but the final joints still turned out a bit wonky.

This is a typical woodworking experience for me — a seemingly simple task like “drill holes centered in a plywood edge” takes two hours longer than expected, and even then doesn’t come out quite right. ¯\_(ツ)_/¯

Have you tried rubbing some computer on it?

Back when I had a CNC router in my closet, I used to think it’d be so much faster to work in a more traditional workshop with proper saws and drill presses and stuff.

But now that I’m frustrated in my back garden shed, discovering that I’m missing the appropriate drill size / pattern bit / alignment jig and spending hours carefully drilling not-quite-centered holes, I’ve started daydreaming that, surely, a “conversational” CNC router workflow could be better: clamp stuff down to the machine bed, get a high resolution / magnified image of the work, and specify exactly where and what to cut by pointing at stuff in the computer.

Ideally you’d get an orthographic image — a top-down projection without any perspective distortion.

Since I’m not about to shell out a few grand for a telecentric lens, I started falling down a rabbit hole of building my own camera by using the machine gantry to move a large CCD line-sensor across the bed.

The TCD1304, for example, has 3648 pixels over a 29mm sensor line, runs about $10 on AliExpress, and is used by solid looking open-source hardware and firmware (they’re popular sensors for making your own spectrometer, apparently).

However, I realized that I know basically nothing about optics. Seeing the details of this gigapixel camera from flatbed scanner CCD disabused me of the notion that I’d have a snowball’s chance in hell of making a usable camera.

I spent some time with ChatGPT’s Deep Research exploring other ideas, but it didn’t come up with much besides reminding me that I’ve been spewing tokens on this bullshit for a while now:

Good ol’ YouTube came to the rescue, though — Paper Tools cleverly avoids the entire perspective distortion problem by only allowing you to pick coordinates from the center of the camera image.

I.e., rather than giving you a static orthographic image that you then CAD/CAM on top of, their workflow requires that you literally drive your CNC machine around to the exact point locations every time you select one.

Quite an obvious solution in hindsight, and I’m curious to watch how that project unfolds.

Next: Drawers

After a week of daydreaming about an alternative, fluid conversational CAD/CAM interfaces for the CNC router currently across the Atlantic Ocean from me, I came back to my senses and decided to keep prototyping furniture ideas sans computer.

I figured solid wood might be more satisfying than plywood. Of course, I don’t have a jointer, planer, nor experience working with actual hardwoods, but I do have some leftover 2x softwood I can start with.

My current idea is to lean heavily on bright colors — paint, 3d-printed plastic, and paracord.

I’m experimenting with cross-bracing using the latter two materials:

For the life of me I can’t find a stopper knot that I can slide or otherwise tie under tension — if you have any ideas or suggestions of how to get a tidy looking knot that’ll slide to the left, I’d love to hear them!

Misc. stuff

My powered air respirator now works great: I ended up going with a dual-fan design and dropped the belt clip in favor of an easier-to-don sling bag.
I love the engineering competence and details in this NTSB interview with a submersible expert. The names are all redacted, but you might be able to guess the interviewee from his first answer: “Well, I’m sure you’re familiar with my film Titanic”. I also particularly liked one of the safety discussions: “I think the most dangerous part of our whole operation was these young software engineers puking over the railing in a high sea.”
The Biochemical Beauty of Retatrutide: How GLP-1s Actually Work. I’ve never studied physiology, and this article was a perfect overview of one of the most exciting medical advances of the recent years. I was also delighted when the author connected biochemistry with familiar endurance running feelings.
Speaking of nicer visual / probing systems for CNCs, this now-on-Kickstarter Nestworks C500 has a bunch of nice looking quality of life details. I swear it was just yesterday I dropped $10k for a Shopbot Desktop with a sketchy USB connection. I’m so lucky to have such deflationary hobbies.
Your cheap furniture has a secret. A history of rubberwood.
How Did The World Get So Ugly?
Smells Like Teen Spirit (Synth Pop 80s)
I’m renting a place with gas cooktop, but I wanted induction so I bought the €40 Ikea single-burner and am extremely happy with it. Normally not a fan of touch controls, but it has extremely responsive ones. The protocol between the display and induction coil has also been reverse engineered in case you want to add your own control loop. (I don’t need another project, I don’t need another project..)
“They needed to connect the organ promptly to the patient manually, with a technique called anastomosis. The medical sutures of the time were too thick, and the needles too large, to avoid damaging delicate blood vessels. To overcome such challenges, the world needed a skilled seamstress.”
“Complexity is free in 3d printing, the limit of design geometry is mostly how much time you’re willing to spend in CAD. I wanted to print the most complicated art piece I could think of.”
I was curious how the support structures were generated, so I asked Claude to read the code and it gave me a great explanation for $0.04. What a world!
Fucking Goddamn Basics of Rationalist Discourse
SpreadSheesh! by Dennis Heihoff - Clojure Electric-based spreadsheet with live code evaluation and custom UI rendering

A constraint language, bedframe, and air handling trouble

2025-10-11T00:00:00Z

Hi friends!

I had an absolute blast in New York City visiting all of y'all who replied to my last email. Shout out to those who offered to host me, even after I typo’d my dates and suggested I’d be in town for a month rather than a week — true Internet friendship right there!

NYC has a creative energy and depth that I haven’t felt elsewhere — London and Taipei by comparison have much better transit infrastructure (and aren’t as deafeningly loud), but New York definitely feels to me more like the “capital of the world” with all the mixing of social/economic classes, variety of national backgrounds, and enormous variety of snacks.

I also love how New Yorkers comment out loud and otherwise interact with strangers to navigate public situations together.

A simple constraint language

In between hanging with friends in New York, I found a few hours for programming and knocked out a new codeCAD prototype. So far this one is more of a Clojure library rather than full interpreter/language. The key idea is to lazily solve numeric variables only when the ground value is actually required (i.e., when calling OpenCascade C++ code that doesn’t know anything about constraints).

This allows one to use numeric variables and constraints fluidly across functions, with parameters acting as “in/out” variables.

Here’s an example (hypothetical syntax) showing how the relationship between a circle’s radius and diameter could be encapsulated within the circle function:

(defn circle [center: Point
              radius: Length = 1
              diameter: Length = 2]

  (constraint (= radius (* 0.5 diameter)))

  ;; imagine some call here that actually draws the circle
  ;; and so requires radius and diameter to be solved...
)

some-point = [0, 0]

;; numeric variable, initial value of 5
dia = ?5

(circle some-point
        :radius     5
        :diameter dia)

;; now when you use the dia variable, it's going to always be 10
;; This is forced by the circle fn constraint and radius argument
dia ;; => 10

My hypothesis is that this might be very useful for all sorts of reusable geometric stuff. We’ll see how that works out as I keep building it out and developing my own lil’ OpenSCAD-like system.

Bed completed

Back in July we discussed flatpack bed ideas, and I’m happy to report that I’ve completed a first prototype:

For the past few weeks it has successfully met the design objectives of:

lifting the mattress off the floor
creating a ton space where we can hide boxes

I’m pretty chuffed with how it looks, too. I wish I could take credit for the wild striping pattern, but that wasn’t my idea — one sheet just arrived like that (apparently within spec for CP/CP birch plywood) and we decided to roll with it.

The bed design is simple, with symmetric headboard/footboard panels joined to rails with M6 screws / threaded inserts and some metal dowels for additional shear support and to ease assembly:

I designed for the 180x200 cm Ikea mattress we already had, and the frame is pretty much all Ikea internally:

a pair of Lonset slats
resting on a Skorva metal midbeam
attached via metal plates that’re screwed into the headboard/footboard
laterally braced with thin metal strips

The latter parts aren’t available for purchase, but Ikea offers spare parts — and I can truthfully say that I’ve lost parts of the Malm bed I purchased in my 20’s.

Everything was cut out on my friend’s CNC:

This took two days, as we spent most of the first day debugging why his CNC couldn’t cut reasonable circles. This turned out to be backlash from a loose X-axis pinion/rack — I’m now two-for-two diagnosing this exact problem on the CNC routers I’ve cajoled my way into operating here in Amsterdam. Weird.

The pieces were then cleaned up and the edges rounded over using Bosch’s adorable trim router (highly recommended) and the MFT/Paulk-style workbench I designed and had CNC cut at the same time:

(The bed has MFT-style 20mm holes on 96mm centers, since I figured that if something went wrong during the CNC operations, I might as well end up an extra workbench top.)

Each leg is a pair of panels, with the inside one cut short for the mattress. The panels joined through the headboard/footboard with, uh, 3D-printed spacers and tube:

So far it seems to be holding up just fine; no idea how to delegate credit between PCTG’s stronger-than-PLA layer adhesion, the bearing friction of the spacers, and the axial metal screw within the tubes.

On the front of the legs, the tubes are hidden by brass cabinet pulls (which also serve as the nut into which the axial screw clamps the assembly tight).

Next I expect we’ll build some attachments for the bed like a large padded headboard, side table cup holders, plant stands, jacket hangers, etc.

Fan troubles

I used my powered air respirator while finishing the bed, but I found it a bit stuffy and so I’ve been trying to increase the airflow. I don’t have a great way of quantifying the airflow directly, so as a proxy I’ve used an FNB58 inline USBC tester to measure the power consumption of the fan running at full power for one minute.

Here are the results:

BFB1012H  0.214 Wh unimpeded
          0.118 Wh filter and hose

BFB1012UH Unable to run, draws too much current from powerbank even at lowest setting

BFB1012VH 0.213 Wh unimpeded
          0.091 Wh filter and hose
          0.101 Wh adapter (no filter) and hose
          0.106 Wh dual adapter (no filters) and hose
          0.113 Wh dual adapter but no hose.
          0.117 Wh hose only

I started with the “H” fan, but it felt stuffy so I bought the “UH” variant based on the AliExpress listing’s description: “super violent turbo blower”. Unfortunately, this turned out to draw too much current: nominally it’s 6A at 12 V => 72 W, and even at the lowest PWM speed it still triggers some kind of overcurrent shutdown mode in my USB-C power bank (rated at 22.5W, oops).

So then I ordered the “VH”, but from what I can tell it’s no better than the original “H”.

It seems like the airflow restrictions caused by the filter adapter and/or hose limit the fan to about half the power consumption of the unencumbered fan, which presumably means the airflow is substantially less than the rated capacity.

What should I try next?

A different model of centrifugal-style blower fan?
Pairing up two fans I already have into a single (larger?) hose?
A totally different style of fan?

If you know about moving air, I’d love to hear from you!

My RSS feed

Did you know my website has an RSS feed?

My friend Ivan reported that occasionally the items would all show up as “unread” in his RSS reader. I’ve dug into the issue, which turned out to be related to deploying my website/newsletter from different timezones — the static site generator I use calls Ruby’s Time.parse method, which always parses into a local datetime. Luckily this carefree, just-do-something dynamic language attitude also makes for an easy fix:

# from https://github.com/nanoc/nanoc/blob/1955f7c0bc86de9ad51b4bb62530754c65bc9e61/nanoc/lib/nanoc/helpers/blogging.rb#L250-L263
# modified so that the date is always assumed to be UTC midnight, so that published item IDs don't change as my laptop changes time zones while I'm traveling.
module Nanoc::Helpers
  module Blogging
    def attribute_to_time(arg)
      t = Time.parse(arg)
      Time.new(t.year, t.month, t.day, t.hour, t.min, t.sec, "+00:00")
    end
  end
end

if "4.11.6" != Gem.loaded_specs["nanoc"].version.to_s
  throw "Nanoc version changed, check that feed id duck punching works."
end

Misc. stuff

McMaster-Carr now does international deliveries !!!!
How CLEVER Design Made Antennas Disappear
Minkowski Penalties: Robust Differentiable Constraint Enforcement for Vector Graphics
The Sushi Robots
Don’t Use Checkboxes - the UI parallel to the common advice for programmers, “don’t use booleans”.
grug make design
Your very own humane interface: Try Jef Raskin’s ideas at home. Raskin’s book on The Humane Interface is one of my favorites.
Generating Reactive Programs for Graphical User Interfaces from Multi-way Dataflow Constraint Systems While investigating constraint languages, I ran into this paper on “Property Models”, which are used within Adobe to wire up the gazillion interacting options of, e.g., Photoshop’s export image dialog.
Geometric kernel for digital manufacturing “The same goes for CAD feature recognition: you do not need a large, overly trained language model to understand that a bottom face is concavely connected to a contour of perpendicular walls. […] the real intelligence here will likely be avoiding anything ‘artificial’ in a well-defined geometric problem.”
The Story of MY Woodshop Design
The Kia PV5 is an awesome-looking electric van with great visibility and 100W USB-C sockets on a durable plastic dash; it starts around $45k, and I’m looking forward to renting weekend camper conversions of this guy soon.