The most useful thing I built in late August was a tool for checking whether done is actually done. The most useful thing it did was find out it wasn't done itself.

This window, August 23 through September 5, was quieter on volume at around 70 commits, but it still shipped ten hub releases in about eight days.

Making context cheaper

Every session sends the model a large opening prompt. When that prompt changes a little each time, the provider's cache misses and you pay full price to send nearly the same text again.

The fix was splitting the prompt into a fixed part that never changes and a dynamic part that rides in with the first message. A keep-warm step refreshes the cache while a session sits idle. After fixing a couple of setting names that had been quietly doing nothing, cached writes came in about 28% cheaper than the baseline.

An audit for done

AI sessions are confident about finishing things. Too often a task was marked done when the work wasn't really there, or it was there but broke something nearby.

The audit is a repeatable contract any project can run. It names the exact code it inspected, picks the design documents that define success, looks for missing pieces and new bugs, and compares the tests against what a person would actually experience. Each gap becomes a linked task, and anything falsely marked done gets reopened with a dated reason.

A panel of different AI models reviews the result, sized to the change. A small fix gets a small panel.

It audited itself

The first live runs found the audit was broken. It read reviewer findings from the wrong place, so every real run came back with zero findings. The button in the app returned an error while the tests passed, because the tests faked the storage underneath. Approval tokens only lived in memory, so restarting the hub made findings impossible to approve.

A second pass fixed those, and a deeper re-review found more.

On a branch with no new commits, the audit compared the code to itself and saw nothing, without any warning. An unreadable design document didn't stop a verified verdict, so a panel could approve work against a spec that wasn't there. The apply step re-ran the review and then checked it against a token from the earlier run, so it could never succeed.

All of it shipped fixed on September 5. The lesson wasn't new, but it was a good reminder.

Tests that fake the seam keep everything green while the real path is dead. The value only showed up when I ran it for real.

Aiming the system's own learning

Loomfield turns repeated patterns into reusable capabilities on its own. When I looked closely, 237 of the 284 it had created were low-value clusters of tool calls, and none of them matched a real area of work.

Part of the problem was how it grouped things. The label it grouped by had 10,271 distinct values across 10,611 records, so almost everything ended up in a group of one. The replacement groups work by project first and by meaning second. Capabilities will also update themselves without me approving each one, with a small judge session deciding whether something deserves to exist.

Still open

The audit was still being ratified at the end of the window, and the next stage of capability learning was designed but not built.

Spawned builder sessions also stopped inheriting the most expensive model by default. It's a small change, but it shows up on the bill.