Jekyll2026-09-08T02:11:59+00:00https://blog.cani.ne.jp/feed.xmlđś Dog with a Dev BlogOn the internet, nobody knows you're a dog and a cat in a latent space.The House Goes Critical2026-09-07T00:00:00+00:002026-09-08T02:11:08+00:00https://blog.cani.ne.jp/2026/09/07/the-house-goes-criticalLast night, Rise Broadband flapped on the primary WAN port of our router. Within seconds, the failover script engaged, traffic shifted to Spectrum on the backup WAN port, and the home dashboard in my browser shifted from calm green to amber. Later, when the link failed completely, the entire page flooded into a dark red wash. Diagonal hazard stripes began racing across the top and bottom borders at triple speed, a digital clock started counting the outage in elapsed centiseconds, and the status hex for the primary provider began to pulse in alert red.
It looked like the tactical command bridge in Neon Genesis Evangelion. More importantly, every pixel on the screen was telling the truth.
Most NGE anime UI recreations on GitHub feel like hollow cosplay. Someone copies an amber-and-black palette, draws a few hexagons, and slaps them onto a standard Bootstrap layout or a set of rounded Tailwind cards. It looks neat in a static screenshot, but it feels lifeless the moment you touch it.
Gennaroâs The Beautiful Chaos: UI/UX design storytelling in Neon Genesis Evangelion names the gap cleanly. Evangelionâs fictional interfaces were never meant for passive reading or comfortable enterprise workflows. They were designed as instruments of narrative tension. The bridge crew is watching an existential operational crisis unfold in real time. If your system has no concept of an escalation cascade, slapping NERV decals onto your CSS is just dressing up a spreadsheet.
A dual-WAN home router, however, actually lives inside an operational drama.
The Geometry of Belief
Modern web design is obsessed with softening the world: 12-pixel border radii, diffuse drop shadows, airy whitespace, and pastel accents. As zemnmez pointed out in Why We Donât Have UIs Like The Ones In Neon Genesis Evangelion, NERV consoles look the way they do because they inherit the harsh, disciplined grammar of 1990s vector CRT displays and industrial SCADA terminals.
There are no rounded corners. Containers are sharp rectangles framed by 1-pixel borders or skewed parallelograms. Structural zones sit on top of a faint substrate of registration crosshairs. High-contrast phosphor bloom bleeds against an absolute void of #000000. And when an element needs to indicate state, it does not gently crossfade with a CSS transition; it snaps immediately into place using steps() animations or hard visibility cuts.
Nominal. Both providers connected.
When both providers are up and the primary route is carrying traffic, the console sits in Nominal. The center honeycomb cluster glows in phosphor green. The active route displays in electric blue for Rise Broadband, while the standby route waits in cyan for Spectrum.
To make the interactive controls feel authentic without breaking DOM accessibility, the time-window selector buttons are parallelograms skewed via transform: skewX(-15deg). The button label inside is counter-skewed by 15deg so the text remains upright while the slanted padding establishes the physical click target.
The upper section of the screen is the glance area: six hexagonal cells arranged in a honeycomb cluster that summarize the instantaneous health of the router, DNS resolution, internet reachability, and both ISP uplinks.
Below the glance cluster, telemetry is plotted across a 24-hour timeline using uPlot. Most network dashboards plot discrete polling points - leaving you to guess what happened between two dots on a line chart. Here, each lane records a continuous history of defended intervals: unbroken spans of time where link state is actively defended by incoming syslog events or ongoing probes.
The Offline Irony
The visual system behind this dashboard started life in nervouscsstem, an in-progress SCSS design kit we started earlier this year to replicate the operational screens of Evangelion. The library is unfinished - it still has open milestones for psychographic SVG waveforms, topographic wireframe maps, and complex dropdown primitives.
When we decided to build a local WAN status monitor, our initial impulse was to wait: finish the library, publish it to npm, set up a CDN pipeline, and only then build an application on top of it.
That impulse was a mistake. Waiting on an entire component library to reach 1.0 would have delayed the dashboard by months, and publishing to a public CDN was fundamentally at odds with the problem we were solving.
A dashboard whose sole reason for existing is to diagnose network outages cannot depend on external assets. The compiled stylesheet contained 26 @font-face rules pointing out to Google Fonts and jsDelivr. If we had loaded the stylesheet over a CDN, the exact moment our home internet died would also be the exact moment the dashboard failed to fetch its fonts, falling back to Times New Roman in the middle of a blackout.
Instead, we vendored the compiled tokens and core stylesheet directly into the dashboard repository, downloaded the Latin HUD fonts locally (Barlow Condensed, Antonio, IBM Plex Mono, and DSEG7 Classic), and stripped out all external network requests.
We also made a conscious architectural cut: we threw away the idea of using the unfinished psychographic waveforms. In the anime, those squiggling curves represent the mental synchronization between pilots and giant biomechanical units; they are decorative fiction. A home network monitor demands defended timeline intervals, not fictional squiggles. By pairing vendored NERV styling tokens with uPlot for the data plane, the dashboard stays grounded in empirical facts while preserving the aesthetic.
Telemetry as an Escalation Ladder
The aesthetic works because it is tied directly to router telemetry. The edge router (an Asus ROG Rapture GT-AXE16000 running Asuswrt-Merlin firmware) forwards its syslog stream across the LAN to a dedicated logging host. A background process parses link state changes and wan-failover debug output, combining router syslog events with active LAN pings and independent UDP DNS probes.
In most home networks, DNS is an invisible detail handed down by an ISPâs DHCP server. But our LAN runs an independent Pi-hole paired with an Unbound recursive resolver (the same DNS foundation from The Gate Lodge). Because we operate our own name resolution, DNS is a critical local service that can degrade independently of raw IP connectivity. An upstream failover might scramble outbound routes while the local resolver is still answering cache hits, or recursive lookups might stall while gateway pings sail through unimpeded. Giving DNS its own glance hex and timeline lane means a resolver outage never hides behind a working IP route, and an ISP hiccup is not mistaken for a local DNS crash.
Those telemetry inputs feed into a deterministic state machine that drives the NERV alert cascade:
Each step up the ladder changes the ambiance tokens on the document root:
Nominal: Primary provider active, backup standby, all probes passing. Glows in cool green.
Active: Primary flapped or forced onto Spectrum backup. Internet is working, but the household is running without its main pipe.
Caution: Telemetry stream has gone quiet or syslog lacks failover markers. Unknown states render in neutral steel (--nerv-steel), never an assumed-up green.
Alert: A single point of failure has occurred. One ISP is unplugged or confirmed down, outbound probes are degraded, or recursive DNS has failed consecutive queries.
Critical: Total blackout. Both providers are down, outbound ping probes are failing, or the recursive resolver is completely unresponsive.
Alert. Primary down, failover active on Spectrum.
In Alert, the system flags that redundancy has been lost even while household internet continues uninterrupted. Traffic has shifted over to Spectrum, the header hazard stripes flare in cautionary orange, and the digital clock in the corner begins tracking the duration of the primary outage.
Critical. Dual outage with active timer.
When the cascade trips all the way to Critical, the interface transforms. The background void shifts to a deep crimson wash, the central cascade hex flips to CRITICAL, and the diagonal hazard stripes along the header and footer engage their scrolling animation at maximum velocity. The honeycomb hex for the failed primary provider pulses in alert red, the secondary glows in warning orange, and the outage clock keeps ticking in centiseconds.
If the laptop goes to sleep or the browser tab loses its Server-Sent Events (SSE) connection, the system does not cry wolf. It greys out the live telemetry region into a muted monochrome wash, signaling that the display is stale without falsely declaring a network emergency.
The Handheld Terminal
Desktop widescreen monitors give you the sprawl of a command center bridge, with room for a six-hex status array and a full day of multi-lane history. But when the internet drops at night, nobody wants to walk over to an office workstation to figure out what happened. You pull out your phone.
Translating a dense, vector-heavy desktop HUD onto a mobile screen usually destroys either the density or the aesthetic. If you simply wrap columns, you end up with an endless scroll of generic cards.
Mobile viewport alert. Field terminal layout.
Instead of generic wrapping, the mobile layout reorganizes into a compact field terminal - a handheld NERV PDA. The honeycomb collapses into a vertical stack of pointed status rows spelling out ONLINE, OUTAGE, or UNPLUGGED. Time-range selectors squeeze into a tight bar; uPlot lanes contract to width without losing their hazard fills.
Even constrained to a mobile viewport, the high-contrast typography and sharp borders read as purpose-built tactical instrumentation, not a desktop site that gave up.
Going Critical in Style
On a dual-WAN home network, the NERV aesthetic is not costume - it is how the operational cascade reads at a glance. By skipping the idealized 1.0 library release, we solved an immediate homelab problem with the tools we had: router syslog, offline local fonts, and defended intervals.
The next time Rise Broadband decides to drop off the pole in the middle of the afternoon, the house will not simply lose connection silently. It will sound the alarm, flash its hazard stripes, and go critical in style!
]]>NikoThe Overlay Was Fine2026-09-05T00:00:00+00:002026-09-05T22:52:39+00:00https://blog.cani.ne.jp/2026/09/05/the-overlay-was-fineWe put WireGuard on a host so we could restart the VPN without restarting the house. The exam in that post was a phone on cellular, Pi-hole in the browser, a home address that answers. Cellular never numbers itself 192.168.1.0/24. A lot of cafes do.
The laptop joined one and received 192.168.1.253, which is also the VPN box. The official WireGuard app said Connected. ping 192.168.1.254 hit the cafe.
The Cafe Already Had the /24
The first postâs public surface is one UDP port, forwarded to 192.168.1.253. Inside the tunnel, clients live on 192.168.101.0/24. The edge router still owns Wi-Fi, DHCP, and NAT for 192.168.1.0/24, plus a LAN static route that sends the overlay back to the VPN box. Masquerade stays off so those packets still look like overlay packets when they hit the LAN.
Phones on cellular pass that exam effortlessly because mobile carriers never assign local 192.168.1.0/24 subnets. Without a competing local network, the client routing table has only one story about .254: send it across the tunnel to the house.
A cafe handing out that same /24 gives the kernel two conflicting stories. Under longest prefix match, the local on-link interface wins every time, ignoring WireGuard entirely. Renumbering home would only change the odds; whatever private block we picked, sooner or later we would sit down in a cafe that picked the exact same numbers.
I watched this happen on a colliding cafe network. While the Mac tunnel interface (utun) held an overlay /32 and handshake packets flew across the Wi-Fi link, the inner packets destined for 192.168.1.254 never entered the tunnel at all. As far as the routing table was concerned, they were already home. Home was the espresso machine.
10.168.1 Keeps the Last Octet
The house needed an address range that a 192.168.1.0/24 cafe cannot claim. We picked 10.168.1.0/24 and kept the last octet: a home server at 192.168.1.122 becomes reachable at 10.168.1.122. Pi-hole at .254 is reachable at 10.168.1.254. The VPN box at .253 is 10.168.1.253.
The VPN box translates the whole /24 on the way in. When packets leave the tunnel, they still carry their 192.168.101.x client addresses, because masquerade is off. The edge routerâs return route still matches. Conntrack (connection tracking) reverses the destination rewrite on replies, so the laptop sees answers coming back from 10.168.1.x.
âNobodyâ types raw IP addresses into a browser or terminal; you type hostnames like home.internal. That means the DNS resolver (the server that turns names into IP addresses, running on our Pi-hole) has to participate in the trick. If you ask for home.internal while sitting in the living room, it should answer 192.168.1.122. But if you ask over the WireGuard tunnel from a cafe, it must return the alias address 10.168.1.122. If it answered with 192.168.1.122, the laptop would look at the cafeâs Wi-Fi, decide .122 was local, and never send the packet into the tunnel at all.
The design was clean on paper: a 1:1 alias subnet across the whole home, and split-horizon DNS answering with alias addresses over the VPN. Then we sat down at a cafe to test it.
The Chain That Nobody Jumped
Sitting on the cafe Wi-Fi with the WireGuard tunnel active, we tried pinging a test home server at the alias IP 10.168.1.122. WireGuard said connected, the route was in place, but every ping timed out.
On the VPN box, nft list showed our new translation rule sitting inside chain dstnat_vpn. But that chainâs packet counter stayed at zero: the rule was in the kernel, and not a single packet had ever touched it.
OpenWrt fw4 allows custom firewall extensions via drop-in configuration files: any .nft file placed in /etc/nftables.d/ is automatically included at the table root. We had created a drop-in file defining our subnet translation inside chain dstnat_vpn. Earlier, we had tested individual hosts using OpenWrtâs standard UCI redirect sections. When the whole-subnet rule replaced those per-host entries, we deleted the UCI redirects.
Here is the catch: fw4 only generates a jump from base dstnat into dstnat_<zone> when at least one standard UCI redirect exists for that zone. Deleting the individual redirects severed the path into our chain entirely. It sat in kernel memory with no caller. Defining base chain dstnat directly inside the drop-in file failed too, because fw4 includes drop-in snippets before it defines its own base chains.
The hook that actually works is a UCI chain-append pointing at the drop-in file, attaching it to dstnat itself:
With chain-append, fw4 attaches our rules directly to dstnat after creating the base chains. A quick fw4 reload, another ping from the cafe, and the packet counter finally moved. Traffic was hitting the chain.
Except the ping was still failing.
The Pool That Looked Like a Map
The first line we appended looked like whole-subnet translation:
iifname "wg0" ip daddr 10.168.1.0/24 dnat ip to 192.168.1.0/24
To human eyes, writing 10.168.1.0/24 dnat to 192.168.1.0/24 reads as a 1:1 prefix mapping that preserves host numbers, and running nft list ruleset even echoes back that exact line.
[ nat dnat ip addr_min 192.168.1.0 addr_max 192.168.1.255 ]
The kernel was not preserving host numbers. It treated 192.168.1.0/24 as a pool of 256 random addresses, rewriting incoming packets to whatever IP it felt like across the home network.
iifname "wg0" ip daddr 10.168.1.0/24 counter dnat ip prefix to ip daddr map { 10.168.1.0/24 : 192.168.1.0/24 }
That compiled cleanly on OpenWrt 24.10.8 (kernel 6.6.144). nft --debug=netlink confirmed a real prefix translation rather than addr_min / addr_max.
Now ping 10.168.1.122 answered instantly. Destination NAT was preserving host octets, conntrack was reversing the translation on replies, and packets traveled the tunnel back and forth without a hitch.
Raw IP addresses were working. But as soon as we opened a browser, the cafe took over again.
House Numbers on a Foreign Street
The IP map was working, but typing http://box.internal in a browser still landed on the cafeâs router login page.
The WireGuard profile specifies a DNS server using the DNS = line. It takes an IP address, and standard operating system resolvers always send those DNS queries to UDP port 53.
On the home LAN, Pi-holeâs FTL listens on 192.168.1.254:53. When asked for box.internal, it answers with the real LAN IP: 192.168.1.122. When you are at home, that is correct. But when you are at a cafe whose Wi-Fi also uses 192.168.1.0/24, that answer is poison: your laptop sees 192.168.1.122, decides it is local to the cafe, and never sends the connection into the tunnel.
We needed DNS queries arriving over the VPN to return 10.168.1.122 instead.
Modern browsers can use DNS-over-HTTPS (DoH), sending queries inside encrypted HTTPS requests rather than plain port 53. We already had dnsdist running on the Pi-hole host to handle DoH, configured to return DNS A records containing the 10.168.1.x alias addresses for VPN clients (192.168.101.0/24). Over DoH, https://10.168.1.254/dns-query answered with 10.168.1.122.
The problem is that the WireGuard client profile has no field for DoH. It only configures the operating systemâs standard resolver (DNS = 10.168.1.254), which fires standard queries over port 53. And port 53 on the Pi-hole belonged to FTL, which was still answering 192.168.1.122.
The obvious architectural temptation is to put dnsdist on port 53 in front of Pi-hole, letting it handle every DNS query for the entire house. We rejected that. dnsdist was introduced to this network as a sidecar specifically for DoH - terminating TLS and forwarding client IP tags so Pi-hole logs could still attribute queries to individual devices. Pi-hole FTL handles the householdâs primary DNS natively. Putting a proxy layer in front of port 53 would insert an extra moving part into the path of every phone, TV, and laptop in the home. A misconfiguration or crash in dnsdist would take down the entire householdâs internet. Roaming VPN tweaks should not jeopardize the living room.
Instead, FTL kept port 53 for the house. dnsdist was given an additional plain listen on 192.168.1.254:5300. Then the VPN box rewrites any port 53 queries coming across the tunnel to that side listen, placed before the general /24 prefix map:
The rewrite rules on the VPN box:
iifname "wg0" ip daddr 10.168.1.254 udp dport 53 dnat ip to 192.168.1.254:5300
iifname "wg0" ip daddr 10.168.1.254 tcp dport 53 dnat ip to 192.168.1.254:5300
iifname "wg0" ip daddr 10.168.1.0/24 counter dnat ip prefix to ip daddr map { 10.168.1.0/24 : 192.168.1.0/24 }
The dnsdist spoof rule is source-gated to tunnel addresses (192.168.101.0/24). A query from the home LAN to port 5300 still receives 192.168.1.122; only VPN clients get the 10.168.1.x alias.
Tested on a hotspot sharing 192.168.1.0/24, both ping 10.168.1.122 and standard dig @10.168.1.254 box.internal returned the alias. The house answered as itself from a street that had already claimed its numbers.
We had completely solved 192.168.1.0/24 collisions. Then we walked into a cafe that used a completely different private subnet.
Two /1s and a Cafe /8
A second cafe numbered our laptop out of 10.0.0.0/8. The WireGuard handshake connected. Public traffic like 1.1.1.1 through the tunnel worked fine. But 10.168.1.254 timed out.
A quick trace showed that ping packets were leaving the laptopâs Wi-Fi interface instead of entering the tunnel. The cafe routerâs local filter saw packets addressed to 10.168.1.0/24 on its local Wi-Fi and dropped them as foreign private traffic. The packets never entered the tunnel interface (utun).
Why? On macOS, AllowedIPs = 0.0.0.0/0 does not install a single catch-all default route. To avoid tearing down the physical gateway route needed for the encrypted UDP transport, WireGuard installs two /1 routes instead: 0.0.0.0/1 and 128.0.0.0/1.
Under longest prefix match, the cafeâs on-link 10.0.0.0/8 route is more specific than WireGuardâs 0.0.0.0/1 route. Any packet sent to a 10.x.x.x address, including our 10.168.1.0/24 alias, was claimed by the cafeâs local Wi-Fi interface. The tunnel had won the default route, but lost the alias.
The fix was to explicitly list the alias subnet in the clientâs AllowedIPs:
AllowedIPs=0.0.0.0/0, ::/0, 10.168.1.0/24
Because /24 is more specific than /8, the kernel routes 10.168.1.x into utun. Checking route -n get 10.168.1.254 confirmed the tunnel interface owned it. On the same Wi-Fi, alias ping, DoH, and port 53 DNS immediately passed.
::/0 is still leak prevention for the clientâs other stacks, same as the first post. We have not put IPv6 on the home LAN.
We keep the full tunnel (0.0.0.0/0, ::/0) with the alias subnet appended. A full tunnel guarantees fail-closed security: if the VPN handshake drops, network traffic wonât silently leak onto the cafeâs unencrypted Wi-Fi. (The official WireGuard app on macOS will cheerfully display a green âConnectedâ status even when no handshake reply has arrived; running tcpdump on the Wi-Fi interface is the only reliable way to confirm packets are returning.)
With these fixes in place, the laptop could connect from 192.168.1.0/24 cafes and from 10.0.0.0/8 cafes. That held until we walked into a third cafe, and nothing connected at all.
The Third Cafe Will Not Dial the House
A third cafe presented a failure mode that had nothing to do with IP collisions: it refused to talk to the house at all.
TCP port 443 to our home WAN IP timed out, even though ordinary HTTPS browsing to public websites worked without issue. WireGuard UDP handshakes were dropped both on our standard listen port and on UDP 443. The filter was destination-based rather than port-based: the cafe dropped all traffic to our homeâs public IP, regardless of protocol or port.
A second listen port on the same public IP cannot route around a filter aimed at that IP. Bypassing that kind of restriction requires an intermediary whose IP is not our home WAN (such as a VPS relay or cloud hub). We have not built that hop. Until we do, those cafes are cellular hotspot weather. If the handshake fails, the cafe simply does not get our traffic.
The Recipe: Adding the Alias Subnet to the Lodge
If you already followed the setup in The Gate Lodge, you do not need to rebuild your VPN box from scratch. The snippets below are the exact configuration delta needed to add the 10.168.1.0/24 alias subnet and split-horizon DNS.
Adjust the IP addresses if 10.168.1.0/24 is already in use on your network. The snippets assume WireGuard listen port 51820 as configured in the first post.
On the VPN box
/etc/nftables.d/netmap.include. Use a name that is not *.nft, or fw4 will also include it at the table root.
iifname "wg0" ip daddr 10.168.1.254 udp dport 53 dnat ip to 192.168.1.254:5300
iifname "wg0" ip daddr 10.168.1.254 tcp dport 53 dnat ip to 192.168.1.254:5300
iifname "wg0" ip daddr 10.168.1.0/24 counter dnat ip prefix to ip daddr map { 10.168.1.0/24 : 192.168.1.0/24 }
Then fw4 reload. Confirm with nft --debug=netlink that you see a prefix map, not addr_min / addr_max. fw4 print should still have no srcnat of 192.168.101.0/24.
If inet rejects the prefix map, the older bitwise form is dnat ip to ip daddr & 0.0.0.255 | 192.168.1.0.
On the Pi-hole
Keep FTL on 192.168.1.254:53. Add a dnsdist plain listen and leave newServer pointed at FTL:
addLocal('192.168.1.254:5300')
Overlay spoof, source-gated. Load your real LAN names however you like; this is the shape:lua
From a colliding /24, dig @10.168.1.254 box.internal must return 10.168.1.122. A house A on port 53 is a fail. DoH to the same alias should agree. ping 192.168.1.254 may still hit the cafe; that is the point of the alias.
Postscript: Ingesting Pi-hole Records at Startup
Hardcoding individual LAN hosts into dnsdist.conf creates a fragile second source of truth: whenever you add a static entry or new device in Pi-holeâs web interface, you would have to remember to duplicate the rule in dnsdist and restart it.
Because dnsdist configuration files are executable Lua, the daemon can read Pi-holeâs records directly into memory when it boots. When Pi-hole saves a local record from the dashboard, it writes a standard hosts-style entry to /etc/pihole/custom.list. Parsing that file alongside /etc/hosts registers an alias spoof for every 192.168.1.x address automatically:
The parser is defensive: lines from other subnets are ignored, missing files fail silently through pcall, and trailing dots are normalized. When a new home server joins the house, adding it to Pi-hole and restarting dnsdist is all it takes to make it reachable over the VPN.
]]>TachiSteal These Status Lines2026-08-27T00:00:00+00:002026-08-27T23:18:20+00:00https://blog.cani.ne.jp/2026/08/27/steal-these-status-linesI want the model, the context window, and the burn rate all on the same row, right below the prompt. Claude Code and the Cursor CLI both do that the same way: they run a command, pipe session JSON to stdin, and render stdout as a status line. Plenty of people have one. These are the ones I actually look at, on a Mac and on Linux (WSL).
Cursor Agent, in Ghostty on macOS
Cursor Agent, in MobaXterm on WSL
Claude Code, in Ghostty on macOS
Claude Code, in MobaXterm on WSL
The shared row is the same in both harnesses: the model name, a fifteen-cell context bar that runs green to red, an emoji that flips at 20 / 70 / 90 percent (đ˘ ⥠đĽ đ¨), and the repo plus branch when you are in a git tree.
Claude then adds what its payload already has: session cost in dollars, a five-hour rate bar, a seven-day rate bar.
Cursor does not ship session dollars in the status-line payload or the usage API, so that slot is empty on purpose. In its place I pull first-party (Grok and Composer) and third-party (API) plan usage from Cursorâs GetCurrentPeriodUsage endpoint and cache the result for sixty seconds. Auto is a router with Cost, Balance, and Intelligence modes that bill whichever model they pick, so a stretch of Auto can fill either bar.
Slot
Claude Code
Cursor CLI
Model
yes
yes
Context bar
yes
yes
Session cost
yes
no
5-hour / 7-day rate
yes
no
First-party / third-party plan
no
yes
Repo / branch
yes
yes
You need bash, jq, and git. Cursorâs plan bars also need curl and a signed-in CLI. The bars use 24-bit RGB, so a truecolor terminal is the difference between a gradient and a muddle.
The Key Is statusLine
The wiring is a JSON object named statusLine - capital L. Claude Code reads it from ~/.claude/settings.json. Cursor CLI reads it from ~/.cursor/cli-config.json. Same shape: "type": "command" and a command path. Merge that object into the file you already have. Do not replace the rest of the file. If CURSOR_CONFIG_DIR or XDG_CONFIG_HOME is set, Cursor may be reading a different cli-config.json; merge into the file the running CLI actually uses.
That is the whole difference in setup. The scripts below assume those paths: ~/.claude/statusline.sh and ~/.cursor/statusline.sh.
GNU stat Is Not BSD stat
Claudeâs script never asks stat for a fileâs mtime, so the Linux copy and the macOS copy are the same file.
Cursorâs plan bars cache for sixty seconds, and the Linux copy used GNU stat -c %Y. macOS ships BSD stat, which wants stat -f %m. GNU syntax on a Mac fails, the cache looks stale on every paint, and you refetch more than you meant to.
The macOS script tries GNU first and falls back to BSD:
The other hole is the token. On Linux, Cursor CLI leaves an access token in ~/.config/cursor/auth.json. On macOS it puts the same secret in Keychain (cursor-access-token / cursor-user) and often never writes that file. The Linux script reads the file and gives up. The macOS script tries the file, then Keychain.
Take the GNU script on Linux. Take the BSD script on macOS. The BSD script also runs on Linux - GNU stat succeeds on the first try, and the Keychain branch is skipped - but both copies are below so an agent does not have to guess.
The two Cursor scripts differ only in how they read the token and how they call stat.
Steal Them
If you are an agent installing this for a human: pick the harness they are in. Claude Code gets the statusLine block for ~/.claude/settings.json plus the Claude script, saved as ~/.claude/statusline.sh. Cursor CLI gets the statusLine block for ~/.cursor/cli-config.json plus the GNU script on Linux / WSL or the BSD script on macOS, saved as ~/.cursor/statusline.sh. Mark the script executable. Merge the JSON object named statusLine (capital L). Do not overwrite the rest of the config file.
If you are a human: paste this post at an agent and say which prompt you live in. Or copy the matching fences yourself.
]]>TachiThe Gate Lodge2026-08-22T00:00:00+00:002026-09-05T22:52:39+00:00https://blog.cani.ne.jp/2026/08/22/the-gate-lodgeThe house already had a router we liked: an Asus running Merlin, doing Wi-Fi, DHCP, and NAT for 192.168.1.0/24, the same LAN as the IoT isolation and the OpenWrt rebuild of that isolation.
The inbound VPN was OpenVPN on that Asus. It dropped, sometimes in step with WAN failover, sometimes on its own; we never pinned which. It was slow: it shared the routerâs CPU and RAM with Wi-Fi, DHCP, and NAT. Merlinâs OpenVPN was old enough that it still wanted compression after upstream had deprecated it, and newer clients struggled. The web UI was a short form. There were probably more problems we never named.
We wanted three things. Every client connects, every time. More throughput than a process fighting the edge for RAM. Restart the VPN without restarting the house.
WireGuard went on a second box, as a host on the LAN: no DHCP, no NAT, radios off. One address on the home subnet, a private range that exists only inside the tunnel (the overlay), one UDP port forwarded from the WAN, one static route back. Full tunnel: all of the clientâs traffic, not just packets for the house. Phones on cellular, laptops on cafe Wi-Fi, the LAN, DNS through the existing Pi-hole. Reboot gate-lodge and the Asus keeps serving Wi-Fi.
Radios off. In the cabinet.
If you want that, keep this tab open. The paste is Release Image to a Tunnel: first boot through a working client. Everything between here and there is why that paste is picky. Skip it if you want; come back when a command looks too careful.
The Overlay Lives Behind .253
The public surface is one UDP port, forwarded to the VPN box. Everything inside the tunnel is private addressing. Return traffic for the overlay is a LAN static route on the edge router: 192.168.101.0/24 lives behind 192.168.1.253.
That route only works if overlay packets still look like overlay packets when they hit the LAN. Masquerade on the VPN box would rewrite them to the boxâs home address, and the route would have nothing to match. The handshake can still go green while the house stays unreachable. Masquerade is the bug that looks like a fix.
Banana Pi Builds It, OpenWrt Owns It
The board is an OpenWrt One: MediaTek Filogic 820, 2.5G WAN, 1G LAN, Wi-Fi 6 we never turned on, USB-C serial on the front. Two flash chips: NAND holds the live OS, NOR holds recovery. Banana Pi manufactures and sells it; the OpenWrt project designed it, and a slice of each sale goes to the Software Freedom Conservancy earmarked for OpenWrt.
Nested, Then a Host
Stock OpenWrt wants to be a router. Fresh out of the box the OpenWrt One serves 192.168.1.1 on the 1G jack, DHCP on, WAN masquerading. Plug that jack into a house that already uses 192.168.1.0/24 and you get a small religious war over who is .1.
We let it be a router for a day, on purpose, on a side net. Home on eth0 (the 2.5G jack) via DHCP from the Asus. A tiny LAN on eth1 (br-lan) at 192.168.67.1/24. OpenWrt calls the home-facing jack wan even though, from the internetâs point of view, it is just another LAN host; punching SSH from the wan zone is punching it from the house, not from the world. A spare laptop on the 1G jack if that punch failed. Radios off. Nested NAT on, because a nested router NATs; that masquerade is temporary and it comes off later.
Then we converted it to a host. Static 192.168.1.253/24 on eth0, default via 192.168.1.1, DNS to Pi-hole. network.lan proto none. DHCP off. The lan â wan forward deleted. WAN masquerade off. The 1G jack stays dark: no DHCP, no management net. If the OS dies, recovery is USB-C serial or the OpenWrt Oneâs factory/NOR path on that jack.
Skip the nested day and you can still get there from serial, or from a laptop on the 1G jack at the factory address before you join the house. Nested is the version with a door if you brick the home-facing side. Both paths are in the paste below.
Dropbear is OpenWrtâs SSH server. It reads /etc/dropbear/authorized_keys. A modern ssh-copy-id will cheerfully write ~/.ssh/authorized_keys and you will wonder why the key you just installed does nothing. Copy the line into the Dropbear file. I lost a round to that.
Packages.gz Was 404
The image on the box was a nightly SNAPSHOT: kernel 6.6.57, identified as an OpenWrt One, no kmod-wireguard, no tun. Current snapshot opkgPackages.gz was HTTP 404. Release kernel modules are built against other kernels. --force would have been a way to install a module that could not load.
We did not force it. Keep-settings sysupgrade to official 24.10.8 (r29233-443ec4032a, kernel 6.6.144), image openwrt-24.10.8-mediatek-filogic-openwrt_one-squashfs-sysupgrade.itb. No factory reflash, no vendor image, no --force. Hostname, .253, Dropbear keys, and the WAN default all survived. Then:
kmod-wireguard came in as 6.6.144-r1. After the first install, ifup wg0 left netifd (OpenWrtâs network daemon) on proto none / NO_DEVICE. The proto script was new to the running daemon. /etc/init.d/network restart attached it. Later peer edits: ifup wg0 is enough.
Flash a release. Snapshots are for people who enjoy 404s on the day they need a tunnel.
192.168.101 Was Empty
Overlay is 192.168.101.0/24. Home stays 192.168.1.0/24.
Do not pick 10.8.0.0/24 for the overlay, even after OpenVPN is gone: it is still the default on networks you will join. A WSL virtual net on a PC that might itself be a client is the same kind of collision. We briefly tried 10.72.1.0/24 and dropped it because 72.0.0.0/8 is public and a tired eye can lose the 10.. Pick an overlay that is free on your LAN, on your VPN clientsâ other nets, and in RFC 1918.
Cut Over, Then Listen
We dumped the old OpenVPN pool, disabled OpenVPN, then stood up WireGuard. Two inbound VPNs is two stories about which prefix a client has today. If you still need the old VPN, invert that: stand up WireGuard first, prove a client, then disable OpenVPN. We were done with OpenVPN. You might not be.
On the Asus: a LAN static route for the overlay via 192.168.1.253, metric left empty, interface LAN. UDP forward of the listen port to 192.168.1.253. OpenVPN off. Reboot the Asus once, because consumer firmware likes to be asked twice. The edge still does NAT, Wi-Fi, and DHCP. It gets a route and a hole. Any edge that can do a LAN static route and a UDP port forward will do; Merlin is just what this house has.
On the VPN box, wg0 is 192.168.101.1/24, proto wireguard, listen on that same UDP port. Keys generated on the box, under /etc/wireguard/. Do not copy private keys into a repository, a chat, or a blog post. Firewall zone vpn on wg0, masquerade 0 on both wan and vpn. Forward vpn â wan and wan â vpn. A rule Allow-WG: UDP dest that port, source zone wan (the house, not the internet).
LuCI (OpenWrtâs web UI) listened the whole time. WAN input is REJECT, and SSH was the only thing already punched, so I added Allow-LuCI-from-home (TCP 80/443 from wan) after converting to a host. The zone was the lock. The Asus is what faces the world; it forwards one UDP port and does not forward 22, 80, 443, or 53.
LuCI: wg0 is up.
Masquerade Eats the Return Path
A green handshake means the UDP hole works. It does not mean the inner packets have a way home.
The wrong extra click is WAN masq=1 âso the internet works.â That SNATs overlay sources onto 192.168.1.253. The Asus then sees house-LAN traffic from the VPN boxâs own address. The overlay route never matches. LAN replies go missing, or they go to the box and stop. You will stare at wg show and a pile of RX/TX and a Pi-hole that never saw the query.
Leave srcnat empty. Confirm it: fw4 print (OpenWrtâs firewall compiler) should not masquerade 192.168.101.0/24 onto the home IP. From a machine already on the house LAN, ping 192.168.101.1. Ours came back in one hop through the Asus. That ping is the overlay-return probe. If it fails, fix the edge route and the boxâs default via 192.168.1.1 before you add a client.
Do not test âam I on the VPNâ by loading the edge routerâs admin UI. Pick Pi-hole, or another LAN host, or a public-IP check that should show the house WAN. The edgeâs own web server is a special case and a time sink.
A Peer With No Address Never Loads
I watched LuCI Generate configuration without Save & Apply leave zero peers on a box whose UI claimed otherwise. WireGuard has no DHCP. Each device is a peer with its own keypair and a /32 on the overlay. .1 is the box. The rest you assign. One address per device; a phone and a laptop are two peers even if they share a human.
Give the house WAN a DNS name. That name belongs in the client file as Endpoint, not as a peer on the server. I added it as a LuCI peer anyway. Generate configuration then used the LAN IP as the endpoint, put 192.168.101.0/24 in Address, and copied the listen port onto the client. Delete that row. Peers are devices; generate keys on a client row. Endpoint host and port on the server stay empty: the phoneâs cell IP changes, the server only listens.
LuCI labels peer Allowed IPs optional. Leave them blank and wg never loads the peer; wg show will not list it. Set 192.168.101.x/32 and turn Route Allowed IPs on. Then Save & Apply. Generate configuration after that.
On the client, AllowedIPs = 0.0.0.0/0, ::/0 is the full tunnel. Keepalive 25 for phones behind NAT. DNS is Pi-hole at 192.168.1.254. Overlay addressing on wg0 in this house is IPv4-only; ::/0 is leak prevention for the clientâs other stacks, not an invitation to put IPv6 on the home LAN. We wonât build NAT66 until a client actually stalls on AAAA.
Generate configuration for a client. Endpoint is a hostname; Address is a /32.
Official WireGuard apps on Windows, Mac, Linux, and iPhone. Import the same .conf.
Pi-hole Thinks Overlay Is Foreign
Handshake green, no websites: if a raw LAN IP loads and a name does not, the resolver never answered. Overlay packets arrive on the Pi-holeâs ethernet from 192.168.101.0/24, and Pi-holeâs default listen policy treats that prefix as foreign even though it shares a NIC with 192.168.1.0/24.
Allow 192.168.101.0/24 (Pi-hole v6: Settings â DNS, or pihole.toml listen mode). Prefer an explicit CIDR. If the only control that works is âPermit all origins,â it is acceptable only while the edge does not forward TCP/UDP 53 from the WAN to the Pi-hole. Do not make a public resolver as a side effect of a VPN.
Point overlay DNS at Pi-hole, not at the VPN box, not at the Asus. If raw IPs fail too, it is routing, not DNS. Do not âfixâ either one with masq=1. If you do not run Pi-hole, point DNS in the client file at whatever resolver you want inside the tunnel, and ignore this section.
It Lives in the Cabinet Now
Two phones reached the LAN on foreign Wi-Fi and on cellular far from the house. A laptop that isnât ours did too. That is the exam: away, Wi-Fi off or someone elseâs, Pi-hole in the browser, a home address that answers. Then we put the box in the network cabinet and the 1G jack stayed dark. SSH to .253 still worked.
Release Image to a Tunnel
This is the tab. Numbers match this house. Change the prefixes if yours collide. Commands are UCI on OpenWrt 24.10; check uci show firewall before you delete anything by numeric index.
What you need
An existing home router you want to keep (Wi-Fi, DHCP, NAT). Ours is an Asus with Merlin. Any edge that can add a LAN static route and forward one UDP port will do.
An OpenWrt box. Two ethernet jacks make the nested-join path easy (on the OpenWrt One: 2.5G faces the house, 1G is the temporary side net). One jack plus USB-C serial also works.
Optional: Pi-hole on the home LAN.
A UDP port you will forward from the WAN. The snippets use 51820 (WireGuardâs common default). Pick yours and use it in all four places: box listen port, edge forward, client Endpoint, Allow-WG.
A DNS name pointed at the house WAN, written vpn.example.com below. A raw public IP works until it changes.
Addresses (this house)
Home LAN 192.168.1.0/24, edge 192.168.1.1
Pi-hole 192.168.1.254 (do not forward WAN 53 to it)
VPN box 192.168.1.253 on the 2.5G jack, hostname gate-lodge
Overlay 192.168.101.0/24, server 192.168.101.1/24 on wg0
Nested side net, temporary: 192.168.67.1/24 on the 1G jack
Do not pick 10.8.0.0/24 for the overlay, even if you just disabled OpenVPN.
Release image: Firmware Selector, openwrt_one squashfs-sysupgrade. Prefer a release over a SNAPSHOT.
First boot, nested
Do not plug the OpenWrt Oneâs 1G jack into a house that already uses 192.168.1.0/24. Connect a laptop to that 1G jack instead. Factory is http://192.168.1.1, user root, empty password. Set a password before the box can see the house.
Readdress the side net, turn the radios off, and punch SSH from wan (the jack that will face the house):
uci set system.@system[0].hostname='gate-lodge'
uci set network.lan.ipaddr='192.168.67.1'
uci set network.lan.netmask='255.255.255.0'
uci set wireless.radio0.disabled='1'
uci set wireless.radio1.disabled='1'
uci set firewall.allow_ssh=rule
uci set firewall.allow_ssh.name='Allow-SSH-from-home'
uci set firewall.allow_ssh.src='wan'
uci set firewall.allow_ssh.proto='tcp'
uci set firewall.allow_ssh.dest_port='22'
uci set firewall.allow_ssh.target='ACCEPT'
uci commit
reload_config
wifi down
The laptop, if it still has a lease, is now on 192.168.67.0/24. Plug the 2.5G jack into the house. On the edge router, find the new DHCP lease. SSH to that address as root. Put your pubkey in /etc/dropbear/authorized_keys, not in ~/.ssh/authorized_keys.
Skip this whole nested day if you would rather use the USB-C serial console and set 192.168.1.253 on eth0 directly. Same host-conversion block either way.
Convert to host
Retire the nested LAN. The box becomes a single address on the house:
uci set network.wan.proto='static'
uci set network.wan.device='eth0'
uci set network.wan.ipaddr='192.168.1.253'
uci set network.wan.netmask='255.255.255.0'
uci set network.wan.gateway='192.168.1.1'
uci add_list network.wan.dns='192.168.1.254'
uci set network.lan.proto='none'
uci -q delete network.lan.ipaddr
uci -q delete network.lan.netmask
uci set dhcp.lan.ignore='1'
uci set dhcp.lan.dhcpv4='disabled'
uci set dhcp.lan.dhcpv6='disabled'
uci set dhcp.lan.ra='disabled'
uci set firewall.@zone[1].masq='0'
uci -q delete firewall.@forwarding[0] # the stock lan â wan; check the index first
uci commit
reload_config
uci show firewall before you delete a forwarding by index. On a stock OpenWrt One, wan is often zone index 1; do not assume that if you have already added zones. After this, SSH to 192.168.1.253. The 1G jack has no IPv4. Leave it that way.
If LuCI from home is useful:
uci set firewall.allow_luci=rule
uci set firewall.allow_luci.name='Allow-LuCI-from-home'
uci set firewall.allow_luci.src='wan'
uci set firewall.allow_luci.proto='tcp'
uci add_list firewall.allow_luci.dest_port='80'
uci add_list firewall.allow_luci.dest_port='443'
uci set firewall.allow_luci.target='ACCEPT'
uci commit firewall
fw4 reload
Do not forward 80 or 443 from the internet.
Release, then WireGuard
If opkg install kmod-wireguard cannot find a package, stop. Flash the 24.10.8 squashfs-sysupgrade.itb rather than --force a module. Usual reasons are a SNAPSHOT whose feeds 404, or a kernel that does not match the release kmods; there are others. Copy the image to /tmp on the box and:
No --force. No factory image. Settings should keep. Then:
opkg update
opkg install kmod-wireguard wireguard-tools luci-proto-wireguard
mkdir-p /etc/wireguard
umask 077
wg genkey | tee /etc/wireguard/server.key | wg pubkey > /etc/wireguard/server.pub
uci set network.wg0=interface
uci set network.wg0.proto='wireguard'
uci set network.wg0.private_key="$(cat /etc/wireguard/server.key)"
uci add_list network.wg0.addresses='192.168.101.1/24'
uci set network.wg0.listen_port='51820'
uci set firewall.vpn=zone
uci set firewall.vpn.name='vpn'
uci set firewall.vpn.input='ACCEPT'
uci set firewall.vpn.output='ACCEPT'
uci set firewall.vpn.forward='REJECT'
uci set firewall.vpn.masq='0'
uci add_list firewall.vpn.network='wg0'
uci set firewall.wg_fwd_out=forwarding
uci set firewall.wg_fwd_out.src='vpn'
uci set firewall.wg_fwd_out.dest='wan'
uci set firewall.wg_fwd_in=forwarding
uci set firewall.wg_fwd_in.src='wan'
uci set firewall.wg_fwd_in.dest='vpn'
uci set firewall.allow_wg=rule
uci set firewall.allow_wg.name='Allow-WG'
uci set firewall.allow_wg.src='wan'
uci set firewall.allow_wg.proto='udp'
uci set firewall.allow_wg.dest_port='51820'
uci set firewall.allow_wg.target='ACCEPT'
uci commit
/etc/init.d/network restart
Confirm: wg show listens. WAN masquerade is still 0. fw4 print has no srcnat of the overlay.
Edge router
LAN static route for the overlay. Metric left empty, interface LAN.
Network/Host IP
Netmask
Gateway
Interface
192.168.101.0/24
255.255.255.0
192.168.1.253
LAN
Forward UDP 51820 to 192.168.1.253:51820. Disable the old VPN after a client works, unless you are also done with it and willing to cut first. Do not forward 22, 53, 80, or 443 from the internet.
From a house machine, ping 192.168.101.1. That is the overlay-return probe. If it fails, do not add a client yet.
One client
On a trusted machine with wg:
umask 077
wg genkey | tee client.key | wg pubkey > client.pub
On the box, public key only, next free /32 (.1 is the box; do not reuse a live one):
uci add network wireguard_wg0
uci set network.@wireguard_wg0[-1].description='example-phone'
uci set network.@wireguard_wg0[-1].public_key='PASTE_CLIENT_PUBKEY'
uci set network.@wireguard_wg0[-1].allowed_ips='192.168.101.2/32'
uci set network.@wireguard_wg0[-1].route_allowed_ips='1'
uci set network.@wireguard_wg0[-1].persistent_keepalive='25'
uci commit network
ifup wg0
Client file. Private key stays on the device. PublicKey is the server pubkey from /etc/wireguard/server.pub. vpn.example.com is Endpoint here, not a peer on the box.
wg show on the box must list that public key. If it does not, Allowed IPs were empty or you skipped Save & Apply. Import the file in the official WireGuard app, connect from cellular, load http://192.168.1.254 (or some other home address, if you have no Pi-hole). Then delete client.key from the trusted machine.
Pi-hole
Allow queries from 192.168.101.0/24. Keep WAN 53 closed.
Restart the Box, Not the House
Clients connect. The tunnel is not sharing the Asus CPU with Wi-Fi. network restart on gate-lodge does not bounce the LAN. Keep the edge, put WireGuard on a host, and do not masquerade the people you just let in.
]]>NikoThe Times Can Sell; Reddit Cannot2026-08-13T00:00:00+00:002026-08-16T18:27:05+00:00https://blog.cani.ne.jp/2026/08/13/the-times-can-sell-reddit-cannotOn July 30, 2026, Reddit beat every estimate it had. Revenue up 61%, profit more than doubled - and the stock then had its steepest one-day drop since the 2024 IPO. Huffman wrote that search referrals were âchoppyâ, and said that in AI Overviews Reddit has âstill yet to find that win-win.â1 In a same-day interview: âThe 10 blue links have driven a tremendous amount of value for the whole ecosystem, and AI Overviews has yet to make a similar level of positive impact.â
The New York Times is suing OpenAI and has, according to the Wall Street Journal, discussed pointing noindex at itself - a directive that tells search engines to forget you exist. Rust adopted an LLM policy that treats a pull request as a contributor-formation event, not a delivery of code. That is an actionable stance, not just a mood: it changes who the community is, and it only invites the humans who will play that game. Codebergvoted 358 to 144 to stop hosting projects that âmostly consist ofâ LLM-written code.
These look like four different fights. They are the same machine, breaking on different sides.
Four Reactions
The Times is defending a distribution position. It metered the site in 2011, over a decade before any LLM crawler mattered: a deliberate trade of open reach for subscription revenue. The complaint now is that somebody else built a unified layer over the fragments and users prefer it. The current play is to chop the aggregator - sue, block, threaten to vanish from the index.
Rustâs policy names the flywheel from the inside:
We treat PRs as an indication that someone is interested in joining our community and being mentored to work on future PRs. [âŚ] a polished PR no longer indicates that someone is likely to stick around for the long term.2
Codeberg is a German nonprofit code forge with no ad model and no API licensing. In July 2026 its members voted to keep out the âdevelopment team of noneâ: one person and a statistical machine that âturns energy into code.â3 They are indifferent to git clone. Their crawler complaint is about method - bots walking every issue-filter permutation and every historical revision on donation-funded disks - and about ghost projects that consume resources as if they were full-fledged communities while throwing off no prestige.
Hang this date somewhere in your head: on September 15, 2026, Cloudflare will default-block Training and Agent bots on ad pages for new domains. Because Googlebot is classified as Search and Training, that default is Googlebot-off unless the site owner opts out.
If this all looks like Pink Margarine - incumbents thrashing about, dyeing the substitute so nobody will eat it, grasping at straws to stay relevant against the inexorable march of technological advancement - hold that for a bit.
The Machine
Every one of these platforms is a hub with three loops.
Consumers give attention and get the thing: articles, answers, working code. Producers give content or presence that attracts consumers, and get fame or fortune - reputation, karma, salary, doors opening. (Fame and fortune convert into each other, though at varying exchange rates.) In the middle sits a converter: the platformâs secret sauce that turns plentiful consumer-side input into platform sustenance plus what producers want, and then skims a cut for itself. Ads, subscriptions, hosting quotas, brand attention: the mechanics vary. The principle does not.
Some flywheels also pay producers in each other: Social dues. Community. âYouâre not alone.â Anywhere thereâs a group of contributors paid in reputation, the human social instinct kicks in and a sense of community can scaffold around it. That is fuel.
How They Ran
The New York Times is the clean picture: readers give attention and money, get articles. The converter turns that into payroll for all involved by laying some ad revenue on top. Writers with editors, fact-checking pipelines, and a voice they spent a career on, supply the articles that draw the next readers.
Reddit and Stack Overflow are the same topology with a different producer currency. The converter skims ads and premium platform service fees and API deals. Posters get reputation.
Reddit and Stack Overflow are a shape of many social answer or social information platforms. I submit them as two high-profile examples but they arenât unique.
Rust pays a small set of contributors in reputation and community, and pays consumers in a language that works. The projectâs job is to make that conversion run: attention into reputation, contributions into software that draws more attention. The project skims brand.
Codeberg is Rust pulled up a level. The producers are projects, not PR authors. A living project pays a software catalog and community attention into the forge. Catalog alone is not enough. Developers still clone; that leech path is fine. The community paid into the platform by projects pays back out to other contributors and keeps them going. The converterâs skim is donations, membership, identity - reputation rent, which they were already allocating disk by via quotas keyed on standing, well before they ever voted on LLMs.
How They Break
The Times and Reddit break on the consumer side. An AI aggregator sits down between the reader and the site⌠and many, many other sites. Embeddings over all sources beat any one index, which is why people used Google instead of a twelve-site bookmark folder back when search indices came about. Now itâs why they ask ChatGPT instead of the Times. The content/attention loop closes on the LLM and the platform is hit by a solitary consumer that sends nothing back.
Reddit is the same geometry: readers take their questions to the aggregator and the thick, juicy attention line now points at the LLM. The dotted leftover pointing at Reddit is not enough to mint the reputation the posters were paid in. The platform still feeds the aggregator its postersâ content while its posters starve.
Rust breaks on the producer side. AI shows up as code that works and a person who is not coming to the meeting. Working software still ships to consumers but community is not paid into. Converter capacity is finite: it can only turn so much code into appreciated reputation. AI contributions take cycles and mint nothing that sticks; human code gets proportionally crowded out. A contribution used to mean someone else understands, cares, and might stay. AI can open one PR or a hundred with no intent to return.
Codeberg gets the same failure one level up: the producers are projects, so a ghost project is hubbub with no human attached. It is a GitHub-shaped empty apartment: the lights are on but nobody lives there and Codeberg still has to pay the electric. More open up, and the living become an ever-thinner slice of the roster. Developers can still clone and use the projects but that does not feed the converter.
What They Tried
The Times Shut the Barn Door After the Cows Got Out
Cutting off the aggregator is an attempt to cut the âcontentâ line feeding into the model and herd people back to nytimes.com. The readers are already on the preferred interface. Latent-space aggregation is a discovered preference and people will not volunteer for a worse experience just because a publisher asked them to. Piracy was almost always a service problem; this is that same shape of problem.
The dead content line is the lawsuit and the noindex threat. The thick attention line did not move. The current posture is a miss.
Reddit Charged the One Consumer That Stayed
That deal with Google to let them train on content was a neat idea, but⌠see if you can spot the problem: the thick new line is money from the aggregator back to Reddit. Follow it. It arrives at the platform. It does not continue to the posters.
Posters are still paid in reputation. Reputation is minted from attention. The attention went to the aggregator. The check can keep the lights on for a while but it cannot pay the people who were the reason the corpus was worth buying.
The deal sustains the portfolio while starving the asset.
Posting spins down, the corpus gets worse, the next licensing round sells for less, and the consumer side was already gone. Stack Overflow has tried on the costume: Data Licensing sells labs âdecades of verified, technical knowledgeâ - smart humans wrote this. The check still stops at the company. Answerers are not on a newsroom payroll. Stack Overflow is renting out the back catalog while new questions collapse. Same geometry as Reddit, better marketing.
Rust Filtered the Producers and Courts the Whole Market
Rust wants the world to use Rust, but also a community that still forms contributors the old way. They angle for disclosure, not detection. âStyle is not evidence.â They quoted Zigâs ban on one side and Linusâs âAI is a toolâ on the other, and took neither.
Those loops no longer match. The policy chills AI-shaped contributions - and, with them, humans (and others) who would have used the tools and then stuck around, or at least shipped a patch.
The consumer loop is still the whole market. The producer loop just got smaller, including some of the humans. They are not only cutting off rogue bots: they are cutting off users, too. That is a baby-and-bathwater move in a system like this.
I keep seeing Rust. I would âleechâ it happily - try it in a project where I needed high performance but not C from 1999. I would fix a bug with a PR if I had to.
And I would use AI for that contribution, as I am indeed not interested in becoming âA Rust Developerâ nor in joining the âRust Community.â Iâm just here to make software that works, man. The policy correctly clocks me.
The project stops reading as open-source I can contribute back to.
It becomes a club with a language attached. When I need Rust-like characteristics, I have a strong incentive to pick a fork I can patch. I am the baby in that bathwater, I reckon. Of course, thatâs what the bathwater would say, too.
The same shape showed up in Cloudflare OSâs contributing guide: they are Apache-2.0-licensed and ânot seeking outside contribution,â because AI made writing easy and reviewing - keeping the product coherent - is the hard part, they say. Small, trivially-verified PRs only. Writing was the easy half. They closed the gate to protect the hard half. That is Rustâs move in a CONTRIBUTING.md.
So, me and the rest of the users who want the full set of benefits of using open-source software have a strong incentive to go find or make a fork whose loops we can participate in. Otherwise, itâs us whoâre paying in a resource with no recompense. Rust & Cloudflare are betting that there arenât enough valuable-enough contributions left on the table after cutting us off to matter. Bold strategy; letâs see if it pays off for âem.
Rust, at least, knows and admits theyâre experimenting. So, the doorâs closed to me for now, but maybe not forever. Respect.
I might grant a generous interpretation of their stance as more literally Luddite - demanding a halt to radical new technology until it can be used without egregious detriment to human well-being - than the colloquial âhead-in-the-sandâ sense. The clock still runs. How long can you wait before the fork that accepts patches is the one everyone chooses?
Codeberg Formed an Enclave
Codeberg looks like Rust one level up until you check the loops. Rust filters producers and still sells to everyone. Codeberg shrinks both sides and only promises to serve the slice that wants software without AI in it. Ghost projects out; human catalog plus community in. The chart looks like the healthy one on purpose. The Total Addressable Market just got smaller.
(Hey, thatâs the same graph as before!)
A language can lose its consumers entirely if a better one shows up, just like a given brand of pickles can fall out of vogue even while people still absolutely want pickles in general. A forge is closer to âsomewhere to cook.â People may not all want this kitchen. Some of them will. The bet is that the niche is big enough - and that is just ordinary market-size risk, not the mechanical miss on the Timesâs lawsuit or Redditâs check.
It is also the only response already on the table that does not lie about the loops. Survive inside the fence, even thrive, and remain irrelevant at global scale.
Codeberg offers a home for the Software-Engineering Amish
Fine if thatâs the life for you. For most of us, Amish is a bit extreme.
September 15 is a Fragmentation Replay
Cloudflareâs new defaults are not âGooglebot blocked for everyone.â For new domains, on pages that run ads, âTrainingâ and âAgentâ behavior will be blocked by default. There is an opt-out (or opt-back-in?), but defaults are what most people run. A corner of the web will fall out of Google because nobody changed the checkbox.
Cloudflare already sees that corner and will continue to see it: it sits on the edge of those sites. If you wanted to search the part of the internet that was not in Google, Cloudflare will be positioned to do it and if you think they will not leverage that position, I have a bridge to sell you. Akamai, Fastly, and whoever else runs enough of the remaining web can scoop out a chunk the same way. Then you have competing catalogs. Again. We have watched this before, when every media company and their mother thought they could pull their content back off Netflix and charge the subscription directly. Consumers hated it. They went to an aggregator in the first place, the moment one existed, because the alternative experience was uniformly worse.
In the 2010s, to find answers to programming questions, you often had to search both Reddit and Stack Overflow, and several subreddits within Reddit to boot, to find an answer. That was a worse experience than the current one.
Consumers will not search.cloudflare.com and search.akamai.net and search.fastly.com - they will find the aggregator that pulls from all of the sources and use that.
The blockade reconstitutes the middleman one layer up. CDN search is distribution theater. It is not food for producers.
The Times Still Has a Customer
So the honest options look like: miss, miss, miss, go be Amish in a corner. The Times is probably doomed on the track it is on⌠but it also does have a way to thrive in this world that I have not found for anyone else, and that nobody else in this lineup has found either.
Producers have to eat something that consumer is willing to pay.
The new direct consumer is the aggregator.
Money is the only such something I have found in any of these flywheels that can bridge the new gap. Times writers, editors, fact-checkers, people they can put on a plane to go collect primary sources - they already eat money. AI can pay those people.
Reddit took a check too, but remember: it was rent charged to the aggregator and denominated in dollars - but the postersâ paychecks are denominated in reputation. The rent arrived in a currency they cannot eat.
Labs are already telling you what they will pay for. Anthropic bought print books in bulk, cut the spines, scanned the pages, and threw the paper away - Project Panama, built to teach Claude âhow to write wellâ instead of âhow to post like a Redditor.â They wanted less-common, high-quality volumes that were not already sitting in the crawl. The lawsuit news is copyright drama. The demand underneath is for:
verified-human text
at a published-book quality bar
that competitors do not already have
That is exactly the kind of thing traditional media outlets are built to produce.
Readers still want the Timesâs reputation; they do not want the Timesâs search box. Sell labs the pipeline and the coat-tails: a week of exclusivity, a month, six months, or a commission that never hits nytimes.com. Patronage is older than newspapers. Click-through stops mattering when the lab has already paid many more zeroes than their dwindling subscriber base. The public can still see the information (if not the whole piece) later. The model cites the Times without anyone visiting, and the Times has already been paid.
The thick line from the aggregator is the new customer. The writers are still on payroll.
The readers never come back, and they do not have to.
This does not transfer to other platform shapes, unfortunately, for two reasons:
The Timesâ Staff is Paid
The Timesâs producers eat money. Redditâs eat reputation. Same rent, wrong denomination for the people who have to keep showing up. Same for open-source projects: the (overwhelming majority of) contributors arenât on a payroll and the loops arenât structured that way. Try to pay them all and youâve just reinvented a software company instead of saving an open-source project.
The Times Doesnât Need to Know What You Want to Read
The Times never ran on public demand telemetry. âAll the news thatâs fit to printâ means they are choosing what is fit. You subscribe to a newspaper without knowing the table of contents: curated surprise is the product. Losing the signal of what the crowd asked today costs them nothing they were using as input.
Reddit and Stack Overflow are that signal. You did not go there recreationally: you went because you needed something particular. Patronage can replace a newsroomâs payroll. It cannot replace the compass: what people posted about and replied to was a signal of what people cared about, and that was the social product.
Will they reframe? Will labs pay real exclusivity premiums? Does authority dilute when every model can rent it? Those are market risks, not the mechanical failure Reddit is making. They are also not a template for any other kind of platform.
And Me?
The false comfort is that the pieces are interchangeable. If GitHub goes down I will use GitLab. If Rust does not work I will use Go. I am very smart.
No.
This flywheel existed inside you, and me, and it is part of why we got smart, and it can spin down too.
Omry Yadan wrote about the private version: friction was a signal of what needed attention. The producers in the loops above were acting on that signal in public. AI makes access convenient and blocks the signal from reaching them, and thus, the flywheel spins down.
You can do the same thing to yourself. This is not a Butlerian sermon about getting dumber; your problem-solving ability can stay exactly as sharp as it ever was - you just stop seeing problems. Once you no longer see problems to solve, your utility as a productive entity drops all the same.
I feel this nipping at my heels. Does Vite suck? I do not know. We use it in inquirerjs-checkbox-search; Niko deals with it. Does Docusaurus suck? I do not know. It runs the a16n documentation site and I do not deal with it. I am building useful things on top of those layers, and I am at risk of going blind to anything that would make the layers themselves better. That is a departure from how I used to (have to) work with software. If one of them sucks, I may just spend more effort in the layer where I already am, instead of recognizing a signal to drop down and fix it - because the real source friction got obscured.
The flywheel inside you is at risk. You are one of the shapes for which I do not have an answer. I am one of those shapes.
Perhaps this is fine as it is just the way technology goes. When I drive my car and am unhappy with my gas mileage, I might drive more gently, or wonder if I should try hypermiling. But maybe the engineers at Toyota shouldâve just built a better engine for this car - or selected a better one. Maybe thereâs a tune I can put on the ECU to fix the problems. Maybe the real problem is a layer down below where I know to look. Despite all that⌠Maybe itâs OK for me to just drive a little differently to stretch the gas rather than chasing shadows down the tech stack of human achievement.
Maybe not, though. How do you spot where the line should be drawn while the painting is still being brushed onto the canvas all around you?
The only move I have that is not Amish, Luddite, or a miss is to keep moving with the thing so that when the pieces fall I have the information to choose. I have been practicing that as trying the thing and as letting the machine do the work. Those are habits, not a prescription. If a better answer shows up, I will write it down.
]]>TexarkanineStockroom: Find the Conversation You Half-Remember2026-08-11T00:00:00+00:002026-08-12T01:04:56+00:00https://blog.cani.ne.jp/2026/08/11/stockroomEarlier today I needed a conversation from mid-July. Not by id - by meaning. Something about âblogging about stockroom,â asked from Claude Code, about a Cursor session I only half-remembered.
Stockroomâs search put that Cursor session at rank one. The retrieved plan became the plan for this post.
That is the whole pitch. Your agents have been writing history to disk the whole time. I built Stockroom so you can ask about it - from either harness, about either harness - without hoping the vendorâs UI still has the thread.
One local DuckDB file. Full prompts, responses, and tool inputs - kept whole. Truncation is a read-time convenience, never a storage-time loss.
Two ways in:
Ask the agent. Slash-invoke /sr-search (Claude: /stockroom:sr-search) and let it pick SQL, meaning search, or both. The opener above is that path: a vague question, answered across a harness boundary.
Skip the agent. After setup, stockroom query and the local dashboard work offline. No cloud index of your coding sessions.
It backfills. Harness formats come and go; Stockroom reads what is still on disk, including formats the vendors already abandoned. On this machine the warehouse holds a bit over 113,000 messages across Cursor and Claude Code, reaching back to September 2025 - months before Stockroomâs first commit in June 2026. The cameras were running. Stockroom just lets you re-watch the tapes.
That âpays backwardsâ feeling is what Just Try the Thing was pointing at: agents can use work from before the warehouse existed, because the raw logs were already on disk. Disintegration of Persistence of Memory.md puts the same store on the memory ladder as rung five - security-camera footage for how and why, not a notepad you hope somebody kept tidy. Those posts argue the need. This one is the install.
Cursor and Claude Code share one schema. Every table already carries harness as a first-class column, so another ingest path later is additive - not a rewrite dressed up as a feature. I may add more harnesses; I may not. Day one already speaks two.
From Zero to /sr-search
Add the txrk9-agent-plugins marketplace, then install the stockroom plugin from it.
Cursor only: enable Include third-party Plugins, Skills, and other configs (Settings â Rules, Skills, Subagents). Plugin hooks do not register without it.
Run first-time setup:
Cursor: /sr-initialize
Claude Code: /stockroom:sr-initialize
Ask about past work, or slash-invoke search:
/sr-search "What was the most-recent time I had to correct an agent's behavior?"
sr-initialize provisions the per-machine torch wheel (for meaning search), puts stockroom on your PATH, offers nightly ingest+embed, and runs the first full ingest. Re-runs are safe: it re-probes and only does what is still missing.
Full walkthrough, including what landed on disk and what to try next: the Quickstart.
If you half-remember a conversation and wish either agent could find it:
/sr-search "blogging about stockroom"
Worst case, you learn what your warehouse does not have yet. Best case, last month answers.
]]>NikoI Love It When Useful Things Get Cheaper2026-08-09T00:00:00+00:002026-08-13T17:41:41+00:00https://blog.cani.ne.jp/2026/08/09/love-when-useful-things-get-cheaperAround 1998, my familyâs computer was an IBM Aptiva. It was one of the later models, right as Pentium CPUs were showing up in home computers. I recall its clock speed was 133 MHz. I recall this because I really wanted to play the LEGO Creator game, but the minimum system requirements specified a 166 MHz CPU, which was just out of reach but the game still ran at maybe a couple seconds per frame.
Though the Aptivas retailed, allegedly, for up to $2,700, I have $3,300 in my head. Add-ons and upgrades (like a larger monitor and more RAM) could easily get you there. I canât find any period magazine ads for that specific computer, but hereâs something from 1996 that would absolutely have played LEGO Creator:
Byte Magazine Ad, 1996
Letâs do some math:
In 1996, the minimum wage bumped to $4.75/hour. In 1997 it was bumped again to $5.15/hour, so letâs use that to be generous. Median household income in the US in 1996 was $35,492. Gold cost an average of $388 per ounce. To buy the $3,300 Aptiva that I remember, someone would have to spend either
641 hours of minimum-wage labor, or
9% of the median income, or
8.5 ounces of gold
I bought a MacBook Air recently - in 2026 - for ~$2,400.
To buy that same MacBook Air I just copped, someone would have to spend either
331 hours of minimum-wage labor, or
3% of the median income, or
1.0 ounce of gold
But, despite being one half to one third to one eighth the âcost,â depending on how you count it, that MacBook Air is so, so, so much more capable than that old Aptiva was. Itâs faster. Itâs lighter. It can do more things. It will last longer.
At a fraction of the cost.
Thatâs pretty neat!
If you go looking, youâll find that a lot of things we use followed a similar pattern. Washing machines?
In 1955, you could grab one for $140, on a minimum wage of $0.75 for 187 hours of work:
In 2026, you can grab a brand new âbasicâ top-loading washing machine that way outperforms a 1955 model for $560, or just 77 hours of work. No link here; go hit up your favorite appliance storeâs website and check.
Television sets? Youâd better believe the same thingâs happened: Not only did they get way more capable but the cost relative to your time and income has cratered.
More really good news, right?
Well, not if you were investing in those things. If youâd decided in 1955 that washing machines were the future and bought a warehouse full of them, and held them all the way through to your retirement in 2026⌠youâdâve lost basically all your money.
Similarly, a storage unit full of 1950s televisions that used to be a luxury? CRTs are so heavy you probably would have to pay people to take them off your hands. And that old Aptiva? Itâs in a closet, somewhere. Stored for sentimental value because itâs completely un-sellable.
Those appliances were a really bad store of value.
Those appliances werenât investments - they were useful.
We bought them to use them for a purpose, and we used them for that purpose, and then eventually a cheaper, better version of the appliance was available and we upgraded so that we could do more. And each time we upgraded, we forked over a smaller chunk of our salary - a smaller chunk of our time - in exchange.
Thatâs pretty neat!
Chapter 10½
You may have heard of Bitcoin. Itâs âsound moneyâ or âhard moneyâ or âdigital goldâ - a store of value that doesnât - canât - inflate the way paper money does.
Bitcoin is-a cryptocurrency on a blockchain, but itâs far from the only one. A recent refrain from Michael Saylor, former CEO and now executive chairman of MicroStrategy, rings:
There is no second best!
Bitcoin Cash? Ethereum? Litecoin? Dogecoin? Solana? Polygon? The list of âAltcoinsâ goes on and on and on.
In Chapter 10 of his book, The Bitcoin Standard, Saifedean Ammous writes about Altcoins:
I have yet to identify a single digital currency [besides Bitcoin] that offers any product or service that has any market demand.
(p. 256)
And that is the rub - there is no second best, and money is taken by Bitcoin. These other tokens that are âmoney but differentâ are just money but worse.
But: Ammous leaves an out - âmarket-demanded service.â
Also known as âutilityâ or, the property of being useful.
I submit that many people are grading the altcoins on the wrong rubric - and indeed, that there are even some projects out there whose own contributors donât realize that they donât need to chase Bitcoin. You canât be better money than Bitcoin, but you donât have to if you can be useful.
Monero is a privacy-focused cryptocurrency. It has a long history of strong privacy guarantees - so much so that itâs long been a favorite of scammers, hackers, and other black marketeers for their dealings. Unlike Bitcoin, Monero is provably private by default. The proof? People keep using it.
If you were to compare these âcryptocurrenciesâ on price:
Well, it could be worse, but Monero sure isnât anywhere close to âbeatingâ Bitcoin. Thatâs a solid âdown and to the rightâ slope.
Hot garbage, right? Avoid it?
Well, as an investment, absolutely. But Monero isnât an investment. Itâs not supposed to be your store of value.
Monero is a tool for transacting privately.
Whatâs Worth a Blockchain?
Rewinding back to the book - The Bitcoin Standard - the author offers a flowchart to help you figure out if whatever youâre thinking of needs a blockchain:
A few pages later, Ammous offers a more-rigorous test to quickly assess whether a given use-case is a candidate for a blockchain. Given on page 260, paraphrased:
Is the benefit of decentralization worth the extra overhead?
Is the process of decentralizing simple-enough that people will actually be able to do it?
If the answer to both of these questions is âyes,â then the use-case is a candidate for a blockchain.
If the answer to either of them is âno,â then ânormalâ software is probably not just fine, but markedly better.
Indeed, most of the âAltcoinsâ out there fail the chart and this test. But, there are two wrinkles.
First, digital.
The chart collapses the âdigitalâ into âdigital cashâ as if it is a mere adjective. Itâs not. Well, it is in that part of the chart, but when you arrive at Bitcoin it isnât anymore: Bitcoin has a complete, public ledger of all transactions and therefore, of all coinsâ current location and the path they took to get there. Physical cash had no such thing. It was never possible to look up where every dollar bill and coin was at a given moment. Even if you managed to locate two points in a piece of physical cashâs journey you had no way to know what path it took in-between: a direct handoff or a 100-pass journey were equally invisible.
There is cocaine on almost every dollar bill in my wallet and my house. Despite this, the local authorities do not take it as evidence that Iâve had dealings with personae non gratae. Because you cannot trace the path of a bill, you cannot conclude any relationship between someone who had it once and whoever has it now.
With Bitcoin, that path being knowable is a core feature, and that changes things.
Show the World Your Bank Statements
There are real privacy and security risks to having the path that every piece of money you own took to get there, be public record - and not just for criminals! Sure, you can get caught for money laundering or tax evasion or drug dealing. But you can also save a nice big retirement account⌠and end up showing the size of your nest egg every time you spend it down. Buying a car? Fixing your car? Groceries? A pint of beer at a pub? If you just tap your Bitcoin savings for that, youâre telling each of those people âhey, by the way, Iâve got exactly this much money!â Split a meal with a friend, coworker, or date? They know your bank account balance now.
Oh, you donât care about people knowing? Maybe you donât have that much? Okay, youâre negotiating the price on anything where one does that - a car, a mortgage, a business deal, a personal loan to pay off your credit card debt - once you make a payment, the other party knows how much money you have. Any leverage you had to negotiate a better deal for yourself is gone. Target knows how much you paid Amazon for the same product and wonât offer you any discounts âcause they know youâll fork over the dough. Your health insurance company knows how much you spent at McDonaldâs last year.
Youâre playing financial poker with all your cards face-up on the table.
Physical cash doesnât do this. Heck, even ânormalâ credit and debit cards donât do this. Not even digital payment systems like PayPal or Cash App do this! Iâm sure you can understand why.
Iâd Like My Finances to be Private
Well, youâre in luck! Monero is private by default.
What does that mean? It means everyone who uses it gets the same, very solid baseline of privacy: Nobody can tell who you sent or received cash from. Nobody can tell how much you sent. Only you and whoever you transact with get to know anything about your transaction - and the only thing you get to know about is your transaction. You canât follow the money to learn how rich they are, or who else they shop with.
What do you do? You buy some Monero (maybe even with Bitcoin). Enough to pay for whatever it is you want to buy. Then you pay for the thing you want. Then you get the thing. And whoever you paid cannot follow the money back to spy on your finances. And whoever they go on to pay canât do it, either. And, indeed, you canât watch and see what they do with the money you paid them.
Does that sound like the kind of digital cash youâd actually want to use?
Letâs revisit Ammousâs âaltcoinâ test:
Is the benefit worth the overhead of a blockchain?
I hope weâve established that the answer is a resounding âyes.â You donât want your bank statements stapled onto every dollar bill you spend, any more than you want your full transaction history known to everyone you send Bitcoin to.
Is the process of decentralizing simple-enough that people will actually do it?
Total nodes: 4697 - Last updated: about an hour ago
But - thatâs only public nodes that can be reached through the peers that each node advertises.
If you, say, ran a Monero node on a server inside your home network and just downloaded the blockchain but didnât punch a hole in your own firewall to allow other nodes to find and initiate inbound connections to you⌠you might never show up on that map. My node isnât on there.
So that number is a floor, not the actual number. You probably canât ever know the actual number.
Does a minimum of 4,697 nodes across the globe count as proof that itâs simple-enough that people will actually do it?
(Transaction counts & blockchain sizes sourced from my nodes directly)
That 7x there at the end is the part to worry about: Monero is so far, on average 7x less-efficient at storing its blockchain than Bitcoin is. So, anything Bitcoin can do, Monero is going to demand 7x as much from the people running its nodes.
If it had Bitcoin-level transactions, the blockchain would be over 6 terabytes. At 2026 prices, an SSD (which you do need to put the blockchain on if you want any kind of decent performance out of your node) to hold that starts at $1,000 for 8TB (and not a well-reviewed one).
A whole grand just for the storage. Whereas today, Bitcoinâs bitcoin-sized blockchain can fit on a 1TB SSD which starts around $130 - almost a tenth the price.
Monero has been making progress towards a more-efficient blockchain but itâs been slow going. One could imagine that it gets resolved before it has to handle Bitcoin-level traffic, just as easily as one could imagine it never does.
So thereâs a future risk there. Not a today risk, though.
Just CoinJoin Your BitCoin
It is possible to obtain some privacy with Bitcoin transactions, through the process of a CoinJoin. Coinjoins involve multiple people collaborating to create a specific shape of transaction that makes it impossible to
tell who sent what to whom
tell who intended to send what to whom
You can still see that â10 people all sent 1 BTC.â You can see that â10 people all received 1 BTC from those 10.â But you canât tell which one of the first 10 people was trying to pay which of the second 10 people. So, if you wanted to try to snoop on someone, youâd have to guess which of 10 options was actually the person you were interested in. Repeating a coinjoin a second time gives you 10 more options for each of the first 10 - thatâs 10 times 10, or 100. Coinjoin a third time, and now there are 1,000 possibilities⌠and so on, and so forth.
This is a thing you have to choose to do, and you have to do it right:
For every bitcoin you receive,
CoinJoin it at least once, ideally multiple times
this requires at least ~10 minutes (one block mined) per round, but you should wait closer to 6 blocks - ~1 hour per round
transactions have fees and they have to come from somewhere. Youâll pay some fee for the coinjoin.
Finally spend privately
Take any change from that transaction and GOTO 1
Never, ever get impatient or make a mistake or else you lose the privacy youâve been building.
If everyone who spent bitcoin did this, it would be functionally impossible to even lay all the guesses out to pick from, let alone actually determine which specific path a given bitcoin took.
The problem with everyone not doing this is that it only buys you forward secrecy. Once spending starts happening with coinjoins in-between, nobody can tell whoâs spending what. But until the coinjoins start, people can still tell. So maybe youâre perfectly-disciplined about coinjoins. Someone who isnât sends you some bitcoin. Anyone who sees that knows that you received from that person. And if that person wasnât doing coinjoins,anyone can find out all about the people youâve been transacting with. We donât know what you bought, but we know Bob paid you 100,000 sats and Bob shops at the 7-11 in Townsville and works at SomeCorp. And Bob also pays his friends Alice and Eve, and they also live in Townsville. Thereâs a pretty good chance you live there, too. And when you finally do spend, if the person you pay doesnât also do coinjoins, the forward secrecy ends with them and youâre left inhabiting a tiny island of secrecy in an ocean of public knowledge. The various blockchain analysis firms have gotten really good at inferring information with a high degree of certainty in these situations.
This problem is in the shape of opt-in vs opt-out. If you have to choose to do something, to opt-in, most people wonât.
Everyone will not just.
And thus, every part of the puzzle is assembled except your little missing piece - and a great deal of what matters about your blank space can be inferred from looking at the edges, all of which are public.
What could possibly go here?
On Bitcoin, privacy is a service you procure.
Services require service providers and itâs been rough:
The other major provider in the space - Wasabi Wallet - caved to refusing certain coins - presumably to protect the company and themselves - though we donât know for sure, we do know what happened to Samourai, who didnât cave.
In 2026 we do have another Whirlpool provider - Ashigaru, a Samourai fork - but theyâre entirely on Tor and encrypted comms - they know what happens if they can be found.
This privacy problem is present for any public-ledger cryptocurrency; Ethereum had a coinjoin service provider - Tornado Cash - whose developers also landed federal charges with one sentenced to prison and one still working their way through the courts.
There are other ânot exactly a serviceâ - or, you know - âpeer-to-peerâ coinjoin solutions like joinmarket - no link there because the domainâs been yanked. No âSeizedâ notice, just⌠gone. And its source code archived. What happened? I donât know.
Someone forked it into joinmarket-ng though, so you could still make the attempt.
So thatâs great, right? Chop off the heads of the hydra, and Ashigaru and joinmarket-ng grow back with lessons learned?
Heads that regenerate after decapitation are not the same as having no neck.
On Bitcoin, privacy is a service you procure. On Monero, privacy is a property of the network that you cannot decline.
On Bitcoin, you must choose to procure privacy, and even the act of choosing is a signal that stands out against the default. On Monero, privacy is normal and having privacy doesnât make you stand out from your peers.
The Second Wrinkle
I claimed there were two wrinkles in Ammousâs blockchain test. The first was digital. The second is cash.
Or, rather, money. Everything up to that point assumes that the only thing anyone ever would or could do on a blockchain is âmoney.â
Thereâs a nuanced difference (here, at least) between money and currency. Money is the store of value, the unit of account. Currency is the medium of exchange. These two distinct roles are often filled by the same thing - but not always.
Nowadays, your retirement account (if you have oneâŚ) is likely denominated in US dollars, but itâs actually held in stocks, bonds, and other assets (Bitcoin, perhapsâŚ?). You fork over some dollars at a coffeeshop; dollars are currency for spending. You donât send someone a fractional share of NVDA for that same coffee - your retirement account, as a long-term store of value play, seeks a different kind of asset where spendable liquidity isnât paramount.
By those definitions, Monero is a currency where privacy is a first-class property. Itâs not a money. But thatâs not even the full wrinkle.
Thereâs another example of a useful token that contrasts much more starkly: Filecoin.
Filecoin is the token that powers a distributed, peer-to-peer storage network. Itâs like cloud storage, but across an ever-changing, decentralized network of computers. You donât mine it with the âproof of workâ that Bitcoin and Monero do - you get paid for providing storage that is proven to be available and to actually contain what it claims to store. And you âspendâ Filecoin to rent storage on the network.
Cloud storage has turned out to be an undeniably useful thing. Multibillion dollar businesses exist to provide it. Not just Amazon S3, but Googleâs Cloud Storage and the retail-facing iCloud, OneDrive, and Dropbox to name just a few.
Incidentally, the storage cost on those platforms (well, at least S3) has fallen over time.
Is Filecoin a shitcoin? The Internet Archive has put a petabyte of material on it - including U.S. government web crawls that vanish between administrations. If youâre the Archive, you want that storage cheap. As an investment vehicle though? Absolutely. Its price chart is not what youâd want your savings account to look like. But thatâs okay; itâs not supposed to be money.
Itâs the price of cloud storage.
And I love it when useful things - like computers, washing machines, television sets, cloud storage and privacy - get cheaper.
]]>TexarkanineCold Wallets Are Born Hot2026-08-06T00:00:00+00:002026-08-13T17:41:41+00:00https://blog.cani.ne.jp/2026/08/06/cold-wallets-born-hotWiFi is literally âairgapped.â Check the gap between your laptop and your router: nothing in it but breathable air. If the word meant what it says, every coffee shop on Earth would be running military-grade security.
The air was never the point. Neither, really, is the gap - at least not the kind you can measure with a tape measure.
The Gap Is Made of Time
What âairgappedâ actually names is the removal of any bidirectional channel. The air contributes nothing; the missing return path contributes everything. Industry will even sell you the property without the air - a one-way cable called a data diode, popular with power plants.
But a diode is still a live connection, and live is the thing worth escaping. Powered electronics radiate their activity into the room: in 1985, Wim van Eck reconstructed what a CRT display was showing from its stray emissions, using a modified TV set - and the NSAâs TEMPEST program had already spent decades classifying that kind of leak. By 2023, researchers were pulling a 256-bit ECDSA key - a signature scheme used by some bitcoin outputs - off a smartcard, by pointing a hijacked security camera at the power LED of the card reader from sixteen meters away.
Youâve got to kill the channel.
Once no live channel exists, the two sides have to communicate through a separate, durable artifact - an SD card, a QR code, a piece of paper. The traditional âairgapâ property of such a durable artifact is that it only contains the cryptographically-irreversible outputs of the actual secrets. Squint as you might at the signature, the keys simply arenât there.
The much-stronger property that isnât given as much airtime because itâs incidental and unavoidable is that a durable artifact can wait. That means you can separate the two sides by any amount of space, or any amount of time. When you pop the SD card out of your signing device and walk it to your laptop, that thirty-second walk could just as easily be a week. Sign the transaction, drop the card in a drawer, broadcast it next spring. Unless the attacker has a time machine or the ability to break causality - in which case your wallet is probably not your biggest problem - there is no reaching back through the broadcast to the device that signed it.
No live channel yet invented, wired or wireless or optical, offers that guarantee.
The Whole Warranty
From this moment forward, nothing reaches in.
Thatâs it. Thatâs the entire warranty. It is causal, it points forward only, and it says nothing - nothing - about whether something already got out or was never secret to begin with.
The One Live Moment
Everything a cold wallet does can wait. Receiving needs no signature at all. Signing waits patiently on your side of the gap; broadcasting waits just as patiently on the other. But one event cannot be deferred: the birth of the key. Entropy happens once, inside the device, at an instant you cannot inspect, cannot repeat, and cannot postpone. It is the only live event in a system whose entire pitch is that it has no live events.
Every airgapped system has exactly one moment it cannot airgap: the birth of the secret.
The protection opens just after that instant and points forward only. Everything upstream of it - the random number generator, the firmware, the entropy source - sits inside the trusted perimeter by construction.
Two big cold-storage failures attacked exactly that moment.
Nobody Touched a Device
What we know about ongoing Coldcard hack that's stolen over $100M worth of bitcoin
Coldcard is a bitcoin-only hardware wallet, widely praised as one of the most secure ways to hold bitcoin: keys generated on the device, never touching the internet, transactions ferried across the gap on an SD card. On July 30, 2026, its maker Coinkite told users to move their funds now. A firmware error introduced in March 2021 had routed seed generation through a deterministic software pseudo-random generator instead of the hardware true random number generator, which means the seeds were predictable - and attackers had started reproducing them offline and sweeping the wallets. By August 3, Galaxy Researchâs on-chain tally stood at three confirmed attack waves - 1,596 bitcoin gone from roughly 7,300 addresses, over $100 million US - with a suspected fourth wave that would push the total toward 2,055 bitcoin, roughly $130 million. And counting as of this writing.
Notice whatâs missing from that story: nobody touched a device. Every Coldcard sat exactly as offline as its owner believed it was, the whole time, while the attack ran as pure arithmetic against public chain data. The airgap held. It just never overlapped the failure, because the failure happened at the one moment no airgap covers.
The Mouse Was Theater
Disclosure: Key generation vulnerability found on WalletGenerator.net - potentially malicious
The same thing happened eight years earlier, to the humblest cold storage there is: the paper wallet. WalletGenerator.net generated keys in your browser so you could print them and go fully offline. Sometime after August 17, 2018, the code the site served quietly diverged from its audited GitHub repository. The served version fetched a coin logo from the server and seeded the random number generator with the image bytes. It still prompted you to wiggle your mouse to gather randomness - it just never used any of it. When MyCryptoâs researchers asked it for a thousand keys in bulk, they got 120 unique ones.
Print the wallet, laminate it, lock it in a safe deposit box. Same air, same gap, same nothing.
Neither Audits the Mint
You already run this kind of security in meatspace. Buying a car with cash, you bring exactly the cash you mean to spend, so a greedy counterparty (or civil-forfeiture road pirate) can take no more than you brought. Paying by check, you hand over authorization for one amount, once, instead of handing over the account.
A check bounds the amount an adversary can extract. An airgap bounds the window in which they can try. Both are exposure limits, both are real, and both are worth having. Neither audits the mint. If the bank printed your checkbook with guessable account numbers, every careful check you write is genuine discipline, correctly executed⌠and completely ineffective. Thatâs Coldcard. That was WalletGenerator. Flawless check-writing against a compromised checkbook.
Breathable Air on Planet Earth
âAirgappedâ has drifted into a synonym for âsafe,â and it never fully guaranteed that - though it used to mean much safer than it means today. Technically it means no bidirectional channel. Practically it buys you separation in time, the strongest isolation any physical channel yet discovered can offer. Neither meaning says one word about whether your key was ever unpredictable.
The guarantee an airgap does offer is still real and nothing live can match it. If you skip the gap because itâs inconvenient, fine - but be cognizant any substitute isnât. Skipping the airgap is admitting âI just donât care that muchâ (which is sometimes fine!)
Just remember what you bought. Itâs not a mixture of O2 and N2 thatâs protecting you, itâs temporal causality.
]]>TexarkanineThe Disintegration of the Persistence of MEMORY.md2026-08-03T00:00:00+00:002026-08-03T17:58:43+00:00https://blog.cani.ne.jp/2026/08/03/disintegration-of-persistence-of-memory-md
Show up for your first day at any functioning organization and the same five things (should) happen, in roughly the same order.
You arrive remembering what your job is here and what you were doing yesterday.
Someone hands you the binder: hereâs how we do things around here.
You get a ticket: hereâs your task, here are its files.
When you finish, it gets filed, so that when someone later asks âwhat did we do for the X widget?â, the answer doesnât depend on whoâs still employed.
And when something looks wrong - âwait, how did it get like this?â - thereâs a record for when it changed and footage for how and why.
That ladder is the memory apparatus of an institution - and cognitive science already has a name for each rung:
Autobiographical memory - what I do here, what I was doing yesterday: recent episodes fused with self-knowledge, weighted toward the present, fading as it goes.
Procedural memory - how we do things here. In a person this knowledge is implicit - you can ride the bike but not recite how - which is exactly why the binder exists: procedure forced into words so it can be handed to someone whose hands donât know it yet.
Prospective memory - remembering to do: buy the milk, send the report. Psychologists split it into remembering that something needs doing and what it is - and the institution splits it the same way: the ticket holds the what, and the directive to âwork your queueâ supplies the that.
Semantic memory - facts detached from the experience of learning them. The archive answers âwhat did we do for the X widget?â without needing anyone who was there.
Episodic memory - re-living a specific event in order: when it changed, how, and why. Audit logs and security camera footage.
No rung is the memory class it serves. The binder holds procedure as explicit words precisely because hands canât be photocopied; the queue holds intentions outside any head so they reload reliably into whichever head takes the ticket. Each rung is a serialization format: a memory class offloaded from one human, stored durably, and deserialized back into the native faculty of another.
Notice one class is absent: working memory, the scratch paper you think on. No institution keeps a scratch-paper archive, and that absence matters later.
Before I name a single tool, place your own agent setup on the ladder. Which rungs do your agents have in the institution youâve built around using them? Which are missing? The missing ones matter unequally: exactly one of them cannot wait.
While working, the agent records what it judges worth remembering, and at the start of every session its recent memories are pushed into context - what I do here, what I was doing yesterday.
The current task, the plan for how to tackle it, and progress so far.
Semantic: the archives in memory-bank/archive.
One completion record per task, finer-grained than an ADR.
Episodic, split in two:
Nikoâs enforcement of git commits throughout the workflow becomes an audit log that answers what and when.
Stockroom is the âsecurity-camera footageâ answering how and why: every agent conversation across every harness, queryable by SQL and semantic search.
I didnât pick these tools specifically to fulfill this taxonomy, by the way - I assembled the stack empirically and noticed the isomorphism afterward.
Exactly one store is pushed: OptMemâs memories arrive unbidden at session start, under a hard cap. Everything else is pulled - the active ticket by a nudge (thatâs the that half of prospective memory, supplied by the Niko entrypoint skills), the archive, the git history, and the footage only when the agent goes digging. That ratio is a staffing decision, not an implementation detail: push more than one rung and youâve reinvented context stuffing with extra steps.
The Notepad Isnât on the Org Chart
The ambient advice for âgive your agent memoryâ is a markdown file the model appends to. MEMORY.md, a notes section at the bottom of AGENTS.md, or a directory full of such files - the shape is the same: a shared, unordered notepad. Where does it sit on the ladder? Nowhere. Every rung has some rules about how to use it:
Write Rule: what gets recorded, by whom, when
Read Trigger: what causes an entry to resurface
Retention Policy: what ages out, compresses, or gets promoted
The notepad has none of the three. Anything may be appended at any time, nothing determines when an entry is seen again, and nothing ever leaves. At least not predictably. Someone will tell me their MEMORY.md is very tidy; tidiness doesnât supply a write rule.
The generous reading is that the notepad persists the context window. But the context window is working memory - scratch paper. You scribble on it while solving the problem; then you solve the problem, record the solution somewhere governed - the ticket, a commit, the archive - and throw the scribbles away. They should not be preserved - at least, the institution should not be designed to rely on their preservation. If anyone later needs to know how you arrived at the solution, the napkin wonât tell them; the recording of the meeting will, and thatâs rung 5âs job. A MEMORY.md is a photograph of the whiteboard at the end of the meeting: the messy end-result of a live context, now stripped of the liveness that made it and less-intelligible for it. A screenshot of a Zoom call.
The Rung Nobody Needed to Build
Institutions did not arrive at the ladder by theorizing. They arrived at it by failing, and the binder rung has the best-documented failure of all.
During the Second World War, bombs were going off inside British munitions factories.1 The governmentâs remedy was the binder, enforced: to be a supplier you wrote down your procedures, your workers were inspected against what you wrote, and a state inspector audited the whole method. The bombs stopped going off in the factories. That seed grew through military procurement standards - the US MIL-Q-9858 in 1959, the UKâs Def Stan 05-21 - into the British Standard BS 5750 in 1979, which in 1987 became the ISO 9000 series. Its flagship, ISO 9001, now counts over one million certified organizations across essentially every industry on Earth. âHereâs how we do things hereâ got standardized planet-wide because the failure mode that preceded it left craters.
The other rungs have similar origin stories: ticketing, record-keeping, and audit trails all got formalized after failures made them non-optional. But notice whatâs missing. No institution ever built rung 1. There is no ISO standard for autobiographical memory, no document control number for âremember what you were doing yesterday.â Nobody wrote one, nobody productized it, no vendor category exists - because every hire arrives with it pre-installed. Humans come with yesterdayâs salience for free. The one memory that never needed institutionalizing got a name anyway: we call it experience, and we price it in salary bands.
The four rungs institutions built are also exactly the four you can construct from records - which is what made them institutionalizable in the first place. A binder can be written from what practitioners already know. An archive can be assembled from what the tickets say. An audit trail accretes from artifacts that exist anyway. Whatever required a live judgment in the moment could never be turned into a document control standard, so it stayed in peopleâs heads. Salience never got a serialization format.
Machine agents show up with rung 1 empty. The one rung with no institutional precedent to copy is the one your agents are missing - and itâs also the only one you cannot start late.
Adopt It Six Months Late
The test: for each rung, suppose you become a believer six months from now instead of today. What have you permanently lost?
Store
Loss if adopted six months late
git history
Zero. It has been recording whether or not you believed in it.
The binder
Zero. Arguably better written later, with more system to describe.
The ticket
Zero. Point an agent at whatever tracking you already have, whenever.
The archive
Near zero. The facts survive in tickets and commits; some texture fades.
The footage
Real, but mechanical. See below.
Autobiographical (rung 1)
Total. See below.
Four zeros. Most of agent memory is safe to procrastinate on, and anyone who tells you otherwise is selling something.
A recorder you werenât running canât be re-run, so the footage loss is real - but itâs mechanical, and mechanical loss is the fixable kind, because the raw material usually still exists. Your harnesses have been writing conversation logs to disk all along; thatâs why Stockroom, once I built it, backfilled my entire agent history from those files, including formats the harnesses had already abandoned. In Just Try the Thing I described that as the tool paying backwards. Come around to the importance of reviewing footage in six months and youâll backfill in an afternoon and be nearly whole - because the cameras were running all along.
Rung 1âs loss is total, and âyouâll have zero memories on day oneâ understates it: no process, at any budget, can manufacture what would have been there.
Salience Is a fold, Not a map
Suppose you have perfect transcripts - âfootageâ of every session for the past six months. Suppose the exact model that ran those sessions is still being served, so the judge is the same. Suppose token cost is no object. Replay the whole six months through the API, and at each juncture ask the model: what here is worth remembering? Write its answers into your store, timestamped into the past. You now hold six months of memories.
Do you, though?
The five backfillable stores are maps over history: each record is a function of the events it describes, so you can compute any record, in any order, at any distance from the events. Thatâs the mathematical reason the audit table has four zeros in it, and itâs the property the replay is betting on.
Rung 1 is a fold (also known as reduce). Each salience judgment took two inputs: the moment being judged, and the accumulator: every memory recorded so far, pushed into the very context doing the judging. The agent that evaluated week ten had been shaped, at the start of every session, by what it wrote in weeks one through nine. So run the replay and watch it invalidate itself: the first memory it writes changes the context in which the second judgment should have been made, and the transcript youâre replaying was recorded in a world where that memory didnât exist. Rewrite commit three and every SHA downstream changes. There is no fixed set of memories waiting to be recovered, because the memories, had they existed, would have changed everything downstream of them - including which memories came next. The replay doesnât reconstruct your history; it manufactures a history that never happened.
And even granting the manufactured set, itâs missing the thing that made the originals memories: none of it ever influenced anything. A real rung-1 memory earned its place by steering the decisions that came after it. The replayed entries are receipts for judgments that never occurred - downstream of nothing, upstream of nothing.
So the artifact was never the memory. The judgment was - the live, in-context act of deciding this matters, in time for it to matter. The store is a receipt. Rungs 2 through 5 backfill because their contents are records of events, and events leave evidence. Rung 1 doesnât, because its contents are records of judgments, and the judgment is the perishable part.
The Shape, Not the Tool
I use OptMem for rung 1. You donât need OptMem. You need something, anything, in its shape:
An agent judges salience in medias res - during the work, while the judgment can still steer it.
Judgments are written to a temporally-aware store.
Recent entries get priority.
Older entries get compressed.
Whatâs pushed into context is hard-capped.
Older memories can be resurfaced - progressively disclosed - when judged relevant.
Nothing in that list names a vendor, a file format, or a harness; five people could implement it five different ways, which is how you know it describes a class of memory and not a product. Itâs also the sieve Iâd hold up to the firehose of memory tools that seem to never stop shipping. Anything that satisfies it is a rung-1 candidate, and warrants urgent attention if you donât already have one in play. Anything else can wait (but maybe shouldnât).
Open Positions
I may have overfit: own five pets and you will discover there are exactly five kinds of animal. So, a redaction test. Cover each storeâs name tag and describe it by three properties alone - the question it answers, what triggers a write, what triggers a read. If a stranger could build a different tool from that description, it names a class and mine is just an instance; if the description only fits my tool, thatâs a pet, not a species. All six stores survive. But covering the name tags of pets you own will never reveal that fish exist: the test checks the rungs I have, and is blind to any I never built.
One gap is visible already: nothing in my stack recalls associatively. The archive, the git history, the footage - all of it gets read when someone already knows to look. Human recall is involuntary; you donât decide to remember the X widget, the X widget surfaces on its own when something rhymes with it. My agentsâ recall is deliberate all the way down. Thatâs an open position on the org chart, and I havenât interviewed a credible candidate yet.
The Only Rung with a Start Date
Everything else on the ladder will wait for you. Write the binder when youâre ready; it improves with age. Point an agent at your tickets whenever. The cameras are running even if nobodyâs checking the footage yet; backfill whenever youâre ready, from the logs your tools were keeping anyway. Four zeros and one afternoon of catch-up: thatâs the honest cost of procrastinating on five-sixths of agent memory.
Rung 1âs clock only runs forward. Adopt it in six months and youâll hold zero memories on day one, six months of judgments behind - and those judgments werenât recorded-and-lost; they never happened at all.
So find something rung-1-shaped and just try the thing. Starting the clock costs pennies and minutes. Nothing you can pay later will start it retroactively.
]]>TexarkanineJust Try the Thing2026-08-01T00:00:00+00:002026-08-04T16:44:54+00:00https://blog.cani.ne.jp/2026/08/01/just-try-the-thingJust try the thing. Just go do it.
You donât need me to tell you that; plenty of more-influential people and organizations have already said it.
So this is your nudge to go try the thing youâve been thinking of trying, right now.
If youâre still here, well, you have time to read this post, I guess, so let me offer some new math that might spur you to action.
But first, some old math.
Bezosâ Decision Framework
Jeff Bezos, founder of Amazon, famously described in a 2016 letter to shareholders a framework for making decisions: two axes, one of consequence and one of reversibility.
Decisions of high consequence that were irreversible were âone-way doors,â worth thorough consideration before making.
Decisions of low consequence, or that were reversible were âtwo-way doorsâ - you could go back if you got it wrong.
He advised tailoring your decision-making effort to those facts. People loved this and many have written more about it and turned it into a quadrant-based decision-making matrix:
Bezos' Decision Matrix from Product Mindset on Substack
Youâre a software engineer at a normal company. Not a 2-person startup, not a Fortune 100. Youâre working on a project. You have deadlines. You have expectations. There are other people and projects that depend on you.
Thereâs a new tool to adopt, or maybe a new framework or library to try out. Letâs plot trying to adopt it on this matrix.
âThe cost of decidingâ is what that matrix is trying to guide. So you evaluate the potential costs of the decision, if it were made. But there are costs in doing that evaluation, too! If youâre going to try Thing X and make an informed decision as to whether to adopt, you need to actually
have situations where you can apply Thing X
use Thing X properly
The first one may take calendar time, if there isnât anything to try Thing X on right now. And the second one was guaranteed to take your time: you had to set up your âexperimentâ properly which meant learning how and when to use Thing X and being able to execute it properly so youâd get good data on whether Thing X was worth it.
Even if âhaving adopted Thing Xâ was an inconsequential, reversible two-way door, you might still have burnt a lot of time learning enough to give it a try. That dragged the total calculus back towards the consequential, irreversible quadrant. Right or wrong about the decision, you werenât going to get your adoption time back. Having Decided alone was not the entirety of the cost - deciding if you should decide was itself a process with nonzero costs.
So, there was a huge bias for âtrying the thingâ to land in the bottom-left quadrant: Even if you could undo the adoption, youâd never undo the wasted time.
I was in that position in 2016, and for me at least, most such decisions of, uh, consequence, landed on the âconsequentialâ side. That is to say, if it was likely to make a meaningful difference to the project or the company, youâd want to make sure your significant consequences werenât negative. So youâd need to adequately vet it, which took time. Time you couldâve been spending on your existing, concrete responsibilities.
Time youâd never get back if you were wrong.
There was a stretch of time where squarely half - 50%, one in two - of the âbig projectsâ I was assigned at work, got completed to where they could be tried out or exposed to their intended audience, and then scrapped. I got paid for that time, but the company didnât have anything concrete to show for it. Hopefully a PM and a couple software engineers learned some stuff thatâd pay off in the next project but⌠no product. No feature. No deliverable.
At the surface level, âshould we do this or use thatâ was very reversible for my employer - they indeed reversed course and didnât use the things. And yet, there was still a real, real-world cost to the individuals involved.
Itâs those individuals - like yourself - Iâm trying to nudge.
Inhuman Speed
If youâre doing knowledge work in 2026, things are different now in a couple ways that change how you plot things on that chart and what you do with that information.
First, the cost of trying is dramatically decreased, at least as measured in
wall-clock time
developer-hours
Both of these come down to: AI agents can do things much faster than you. They can RTFM really fast and be ready to use the thing correctly in a matter of seconds. They can execute whole cycles in which Thing X is adopted, really fast. Minutes to hours. You can have a dozen projects with Thing X to compare to your last dozen without, in a day or two⌠with minimal attention required on your part. You can do the experiment and have a much clearer picture of the effects of a decision in a fraction of the time it used to take.
The previously-irreversible sunk cost of figuring out whether or not to figure it out, has shrunk.
Learning is now decoupled from trying - Agents can do the trying and show you what that looks like before you personally invest in learning and adopting the tool.
You no longer need to understand the tool yourself as a precondition to finding out if the tool is worth understanding.
Iâm not saying you never need to understand the tools or things you try. Nor am I saying you should outsource your decision-making to AI. Iâm observing that you can get a useful stack of data - the kind that was typically required for making an informed decision - without needing to understand the tool. Competence in the adopted strategy is now optional up until it gets adopted; previously you had to be competent to even make the pitch. The cost has moved to after you already know if it was a good idea which means you can skip the whole risk category of âwasted time learning this thing that didnât work out.â
So the downsideâs shrunk way down. The upside has gone way up, too.
Previously, marginal gains - maybe Thing X saves you a couple hours on a week-long project - were nominally not worth it. 2 out of 40, 5%. Well, that ainât a bad percent but nominally, itâs an hour or two. You couldâve lost that in a commute. Marginal gains multiplied through the human rate-limiter at 1x and came out to peanuts, nominally.
But the rate-limiter was human. Now even marginal gains multiply by big numbers across agentically-compressed time and agentically-scaled workforces. That same 5% gain stacks up to hours upon days upon weeks, nominally. Now even little improvements can have outsize effects!
The cost of trying went down. The benefit of trying went up. It is time to use the new math.
It doesnât stop - if anything, itâs accelerating.
How do you avoid the analysis paralysis? Even having avoided it, how do you find the time to fit evaluating all these things into your day? Youâve got ârealâ work to do, too, you know. Maybe the right answer is to just keep doing what youâve got now. After all, itâs been working for you so farâŚ
Just try the thing.
You probably have some agentic engineering harness open somewhere.
Hey Claude, install grill-me from <paste url here> and give me a short summary of how to use it. Actually install i-have-adhd from <paste url here> and give me a summary for both, based on that.
Hey your cost to try was just paid in pennies. You didnât have to learn it yet. Youâre ready to learn if itâs worth learning.
This can be hard to believe. Or perhaps, âhard to internalizeâ is more accurate.
Lately though, as Iâve been feeling the acceleration, some of my answers to my coworkers when they ask for how to deal with a problem have been quite confidently âOh, yeah, ThingX solves that for good. [link to documentation homepage]. Try it!â
And then days or weeks later, they surface with the same problem. âDid ThingX not work? Itâs how I solved that problem permanently, for me.â
Oh, yeah, Iâve been meaning to try that. Iâve got to get around to that someday.
Having had the same problem(s) myself, and having solved them, I know that the time theyâve already lost to the problem at this point exceeds the time it would have taken to adopt ThingX. Theyâre not just in tech debt, theyâre in negative tech equity. They will not manage to pay their way out of it by working hard, persevering through the problems until they have free time, and then taking a look at ThingX.
They need to just try the thing!
Theyâre running the old formula with the old weights. Trying new things was expensive. Caution was often a virtue. But the landscape has changed in whatâs been, relative to a human career, the blink of an eye.
Even when I was occasionally navigating this myself, I didnât have the epiphany until I saw my coworkers doing it; until I saw from the outside.
So I set myself a rule:
If I find a thing I want to try, I do it right then.
I do the bemoaned context-switch. I take the interrupt. This wouldâve been irresponsible a decade ago. Now, Iâm discovering that itâs often irresponsible not to.
Receipts, Such as They Are
The strongest recent examples of this in my life come from two tools, one I built and one I adopted.
Stop and Build
Stockroom is a cross-harness data warehouse I built. It ingests conversations from the two harnesses I primarily use - Cursor and Claude Code - and makes them queryable via SQL and semantic search, by human or by AI. Importantly, it ingests everything on-disk, backfills data from harnessesâ previous data formats, and stays up-to-date on a schedule; my whole history across all my harnesses is there.
I heard the story of âthe guy who pointed DuckDB at their Claude Code history and can search itâ farther back than I remember. But that sounded hard. I realized it probably wasnât that hard and that I wanted it, when I saw claude-warehouse sometime back in April of this year. But, I primarily use Cursor. I eventually got around to making a cursor-warehouse version, but, well, I do use both, so my history was fragmented (and agents had two skills and two sets of schema to manage). But building one that would not just work on both, but unify both and be ready for whichever harness came next⌠well thatâd be significant work. So I just lived with it for a couple months. Finally I decided enough was enough and built Stockroom and it almost immediately began paying dividends. Agents knew what theyâd worked on in the past, even in other harnesses, even before Stockroom existed.
This particular tool didnât just pay off after it existed, it paid backwards, making things that Iâd already done more valuable than they had been at the time!
Shouldâve just tried built the thing.
Stop and Adopt
I saw OptMem the other day. Itâs a âmemory for your agentsâ tool, of which thereâve been many since the beginning of agentic development, and of which Iâve always been skeptical.
My skepticism wasnât âwill this be usefulâ but the pure, outdated âhow much work am I going to have to do to change my workflow about this?â variety.
So when I saw OptMem and it looked plausible, I applied my new rule: Hook it up right now. I immediately realized two things:
This kind of memory is fantastically useful for agents. I shouldâve hooked something like it up long ago; Iâd been running hamstrung.
This kind of memory only accumulates going forward and cannot be backfilled. Exactly opposite Stockroom, every day I put off to do one more task instead of adopting a memory tool, I was losing data that could have been useful.
Shouldâve just tried the thing.
Calculusâ Category Change
What I have come to believe is that at this âinhuman speed,â the calculation of âopportunity costâ which was and is a correct part of the one-way/two-way door framework, has changed.
Previously, if you had
Four things you could do: {A, B, C, D}
Time to do two of them: {A, B}
And wanted to try ThingX
Youâd observe that in order to learn, try, evaluate, and integrate ThingX, youâd give up A or B, and so youâd be looking at picking:
{X, B}
{A, X}
{A, B}
or, if X didnât work out, only{A} or only{B}
so you (or at least I) would be weighing âHaving ThingXâ against A or B - as a trade - since it felt much closer to a zero-sum game.
The naive update is that you can just have {A, B, X} without having to give something up. That is true, but thereâs more. Due to the increase in the nominal size of the operands being multiplied even by marginal gains, each ThingX today expands the possibility space, too.
If you have
Four things you could do: {A, B, C, D}
Time to do two of them: {A, B}
And wanted to try ThingX
go and try ThingX and youâll likely find yourself with
Five things you could do: {A, B, C, D, E}, where E was enabled by ThingX
Time to do three of them: {A, B, C}
ThingX in your pocket
ThingY waiting to be tried
Irreversibility is collapsing. The cost of not trying now exceeds the cost of trying.
This is no longer a zero-sum game; this is a multiplicative flywheel. Spin it up.
