Contains LLM-generated content on Olaf Alders

Claude Code: Anatomy of a Misfeature

olaf@wundersolutions.com (Olaf Alders) — Fri, 17 Jul 2026 00:00:00 +0000

"Mechanical egg timer" by Hustvedt is licensed under CC BY-SA 3.0 . Padded to a wider frame; this adaptation is likewise licensed CC BY-SA 3.0.

Update, 2026-07-18: There was some discussion about this post on Hacker News. A few commenters dismissed the whole article as LLM-generated. It is most certainly not. I write my own prose. However, the formatting and layout may have made that a tempting conclusion to reach. I’ve now added special formatting to set off the LLM-generated portions, so it should hopefully be obvious at this point which parts were written by an actual human.

I have left Claude’s analysis to stand on its own, but the surrounding prose is my own.

#What Happened

On Canada Day (July 1), 2026, Anthropic shipped a surprising “easter egg” to users of Claude Code: 2.1.198 includes an efficiency bypass which allows agents to continue on without being blocked on direction from a human. You essentially get a 60 second timer after Claude Code asks for input. If you miss the window, Claude Code helpfully does what it thinks is best and continues on its way. It looks like this:

● Claude asked:
 ⎿ …

 ● No response after 60s — continued without an answer

● The user stepped away. I'll proceed with best judgment. My plan:

Note: the above is taken verbatim from one of my own claude sessions, with the questions having been trimmed.

If you find this behaviour surprising, you’re not alone. Let’s consider the possible consequences:

Do you have to take your laptop to the kitchen with you when you’re making a sandwich? What happens if you are afk during this window?
How many agents are you running at once? Can you possibly observe them all at the same time? What if two or more agents ask for your input during the same 60 second window?
What if the agent makes the wrong choice? How many tokens have been burned in the meantime?
What if you are using agents for deployments? (Yes, I know, but what if)

These are reasonable things you might consider when shipping this feature and maybe you’d document your reasoning in the changelog. But what if you never mentioned the new defaults in the changelog at all? Wouldn’t that be even more surprising? (Spoiler: it was!)

The story has a (sort of) happy ending. Move fast and break things does not necessarily preclude move fast and fix things. Within a couple of days a fix was shipped, but where does that leave user trust in this product?

We’ve learned a few things:

Surprising features in Claude Code can in theory (and in practice) be shipped by Anthropic on a daily cadence
Not every feature will necessarily appear in the changelog
Things that should not be defaults may not have a documented off switch
Claude Code’s auto update feature feels more like YOLO mode than we might have suspected early on

There are a few things I don’t know if we have learned:

How do humans fit into this equation?
Did a human dream up the feature?
Did a human write (or have an agent write) this feature?
Did a human review the feature?
Did a human sign off on the feature?
Did a human merge the feature?
Did a human opt out of documenting the feature or adding it to the changelog?
Did a human release manager diff the release with the previous release and give it their seal of approval before it went out the door?

Personally I would find it hard to believe that a human was gating all of these steps without asking “is this a good idea?”. If you told me that Claude Code actually built the feature, shipped it, signed off on it and then deemed it unworthy of documentation, that’s something I’m more inclined to believe, but I just don’t know. Maybe it’s some combination of those two things. Maybe a number of things went wrong, but I think it’s clear that this never should have happened. And I say this as someone who has had at least one performance review where my manager said “well, you did put a serious bug into production”.

I’ve wondered a bit about how this happened and what kind of post-mortem is available in the public record. So, I’ve asked Claude Code to investigate itself. To Claude’s credit, it seems to have no filter that prevents self-reflection regarding this code. So, full disclosure, what follows is mostly Claude’s work, so take that for what it’s worth and if you rely on any key assumptions, it’s worth reproducing them in isolation.

#Claude Investigates

Claude’s research begins here.

Contains LLM-generated content not written by Olaf

#Timeline

2026-06-29 — 2.1.196 released; the reporter’s “last working version (I am guessing)”
2026-06-30 — 2.1.197 released; one changelog line, the Sonnet 5 launch
2026-07-01 — 2.1.198 released — the version the reporter pins the regression to. No public commit shows the change; the only public trace of this release is the bot commit publishing its notes (75709ea), which touches nothing but CHANGELOG.md and feed.xml
2026-07-02 02:54 UTC — issue #73125 filed by Aleksey Nogin
2026-07-02 03:45 UTC — a commenter surfaces the escape hatch: CLAUDE_AFK_TIMEOUT_MS. Traded peer-to-peer in the thread, not pointed to from any release note
2026-07-02 — 2.1.199 ships 24 entries while the issue is open. Still no mention.
2026-07-03 — 2.1.200 reverses the behaviour; again the only public trace is the notes commit (1322e9b)
2026-07-04 18:04 UTC — issue closed
Reaction/scale on the issue: 384 👍, 143 comments — not a niche complaint
Reporter’s environment: 2.1.198, “last working 2.1.196 (guessing)”, Opus, AWS Bedrock, VS Code terminal

git clone https://github.com/anthropics/claude-code.git
cd claude-code

# When did the fix land, and in which version?
git log -1 --format='%h %ai' -S'no longer auto-continue by default' -- CHANGELOG.md
# 1322e9ba 2026-07-03 16:52:26 +0000

# When did the version that shipped the bug land?
git log -1 --format='%h %ai' -S'## 2.1.198' -- CHANGELOG.md
# 75709eac 2026-07-01 20:45:29 +0000

#The misfeature

AskUserQuestion is the tool Claude Code uses to stop and ask the human a question mid-task
New behaviour: after 60 seconds of inactivity, the tool auto-returns a “proceed anyway” result instead of blocking
The message handed back to the model — this is the template, rendered here at the 60-second default:

// v2.1.198, verbatim. `Thl` is the minifier's name; the prose is the binary's own.
// Note "60s" is interpolated, not a literal in the file:
function Thl(e){return `No response after ${Math.round(e/1000)}s — the user may be
away from keyboard. Proceed using your best judgment based on the context so far;
you can re-ask this question later if it's still relevant.`}

The “re-ask later” escape hatch is circular: the re-asked question hits the same timeout. Aleksey Nogin made this point in the issue thread within minutes of filing it
The transcript line has two variants — the binary picks between them on whether you’d started answering:

// v2.1.198, verbatim. `a` is the minifier's name for "some answers exist"
// (`s=Object.entries(r)` over the answers, `a=s.length>0`); both string values
// are the binary's own.
let d=a?"continued with the answers selected so far":"continued without an answer"

So a half-answered dialog does not discard the partial input — it submits it. Answer question one of three, step away, and the timeout commits your one answer plus whatever the model picks for the other two
Both strings are absent from 2.1.197 and present in 2.1.198
In fairness: it was not silent on screen. The dialog rendered a live countdown, and a keypress restarted the timer. Assembled at runtime rather than stored as one string, so this is the rendered form, not a literal grep hit:

// v2.1.198, verbatim — the pieces. `s` is the remaining-seconds value.
children:["auto-continue in ",s,"s \xB7 any key to stay"]
// renders as: auto-continue in 12s · any key to stay

Which cuts less far than it looks. The countdown only reaches someone watching the screen, and the premise of the feature is that you aren’t:
- the internal name is AFK; the message says “the user may be away from keyboard”
- running several agents at once, “watching the screen” is not one place — the countdown you needed was on another tab
And the countdown is late. The threshold defaults to 20 seconds (CLAUDE_AFK_COUNTDOWN_MS), and it gates on remaining time, not elapsed — so for the first 40 seconds the dialog looks like an ordinary blocking question. It is on screen, but nothing on it says a timer is running:

// v2.1.198 ships this minified — the locals are mangled, but the property
// names survive, so `showCountdown` and `remainingSeconds` are its own words:
let u=i*1000<=n;return{remainingSeconds:i,showCountdown:u,timeoutMs:t}

// ...which reads, with n at its default of 20000:
showCountdown = remainingSeconds * 1000 <= 20000

The warning arrives in the last third
What it does not touch: the timeout applies only to AskUserQuestion. Anthropic’s tools reference says “permission prompts, including plan approval, never auto-resolve on idle” — and unlike the docs claims elsewhere in this post, this one is checkable against the shipped 2.1.198 code rather than a page written after the fix:
- the countdown component (q0m) has exactly one call site in the entire bundle, and its timer hook (_Rc) has exactly one caller — q0m itself. The timer exists in one component
- that component’s props identify it past argument: jsx(dRc,{question:V, questions:s, currentQuestionIndex:$, answers:R, questionStates:O, onAnswer:be, onSubmit:N, …}). Its timeout handler is what fires tengu_ask_user_question_afk_auto_advance
- the permission prompt (Do you want to proceed, Do you want to allow …) is a separate component with no timer attached
But the exemption only protects you if a permission prompt appears at all. 2.1.198 ships bypassPermissions, acceptEdits, allowedTools, --dangerously-skip-permissions and PreToolUse hooks. Anyone running agents against deployments has plausibly allowlisted the deploy command or turned prompts off — that is what automating it means. For them the permission layer was never going to fire, so its immunity to the timer buys nothing
The narrower claim, and the one that bites: the timer could not grant permission, but it could make the choice. AskUserQuestion doesn’t ask permission, it asks you to decide — “staging or production?”, “which config?” On timeout the model is told to proceed using your best judgment, and the partial-answers path continues “with the answers selected so far”. If permission was already granted by allowlist or bypass, the choice was the only gate left
No timeout parameter exists in the tool schema — the model can neither set nor control it. Verified in the binary (U_f=…H.strictObject({questions:…})), not taken from the issue thread. The input params are only:

questions, answers, annotations, metadata

So the model is truthful when it says it didn’t skip anything — the harness returned the answer, not the model

#The fix

2.1.200 made auto-continue off by default
Idle timeout is now opt-in via /config, not forced on everyone
Note the changelog’s verb: “no longer auto-continue by default”. Nothing was removed — the default flipped.
The /config setting the note points you to did not exist before the fix. Grep 2.1.198 for askUserQuestionTimeout and you get zero hits: when this shipped, the only way to escape it was an env var — and the release notes never named it.
You can confirm the rest in the current binary (2.1.211, eleven releases later). The machinery is entirely intact:
- the setting is askUserQuestionTimeout, surfaced in /config as “Question auto-continue timeout”
- accepted values are 60s, 5m, 10m, never — and unset resolves to never, which is what makes it opt-in
- the hook’s default timeout constant is still 60000; the countdown threshold is 20000
- two env vars still override the setting — CLAUDE_AFK_TIMEOUT_MS and CLAUDE_AFK_COUNTDOWN_MS
So the fix is a one-line change in a gate, not a deletion:

// v2.1.211, verbatim — only whitespace added. `Upf` is the minifier's name for it;
// everything else here is the binary's own, string values included.
function Upf(e){ switch(e){
 case "60s": return 60000; case "5m": return 300000;
 case "10m": return 600000; case "never": case void 0: return null; } }
// ^^^^^^^^^^^^ unset => null => disabled

Fair reading: this is the right fix. Opt-in is what it should have been on day one, and the capability is legitimately useful to someone.
Less comfortable reading: the same code that auto-answered for you is still shipping, one config value away, governed by the same process that turned it on silently the first time.
Pre-fix stopgap (from the thread), for anyone pinned to an affected version:

// settings.json — disable the auto-continue by setting a huge AFK window
"env": {
 "CLAUDE_AFK_TIMEOUT_MS": "<massive number>"
}

Turnaround was fast — roughly two days from report to reversal (credit where due)

#Which release shipped it — and what the notes said

Two places publish release notes: the official changelog and CHANGELOG.md in the repo (same content)
Links below are pinned to commit 1322e9b so they show what the notes said at the time, not as edited later
2.1.197 changelog: one line, Claude Sonnet 5 launch. Nothing about question timeouts.
2.1.198 changelog: ~30 entries. Nothing about AskUserQuestion auto-continuing.
2.1.199 changelog: 24 entries, published while the issue was already open. Still nothing.
The 60s auto-continue was never announced in any release note when it was added
AskUserQuestion is not a stranger to the changelog — it appears 15 times across 13 versions, going back to 2.0.55. It is a tool Anthropic documents changes to, routinely:

git show 1322e9b:CHANGELOG.md | grep -c 'AskUserQuestion'
# 15
git show 1322e9b:CHANGELOG.md | awk '/^## /{v=$2} /AskUserQuestion/{print v}' | sort -u | tr '\n' ' '
# 2.0.55 2.1.136 2.1.141 2.1.144 2.1.147 2.1.181 2.1.200 2.1.47 2.1.69 2.1.70 2.1.83 2.1.85 2.1.9

Which makes the gap the story. Between 2.1.181 and 2.1.200 — the window containing the change — it appears nowhere. The behaviour changed twice, on and then off, and the notes record only the second
The only changelog line that ever mentions the auto-continue is the one that removes it, in 2.1.200:

## 2.1.200
- Changed `AskUserQuestion` dialogs to no longer auto-continue by default;
 opt into an idle timeout via `/config`

The controlling env var CLAUDE_AFK_TIMEOUT_MS appears nowhere in the changelog or README

#The docs caught up. Afterwards.

Today, both env vars are documented, in the environment variables reference. The entry is candid about the episode:

CLAUDE_AFK_TIMEOUT_MS — How many milliseconds of idle time before an unanswered
AskUserQuestion dialog auto-continues without you. Auto-continue is off by
default; opt in with the askUserQuestionTimeout setting. [...] In v2.1.198 and
v2.1.199, auto-continue was on by default with a 60000 (60 seconds) timeout.

But that text cannot be what was there on 1 July, and the binary says so on its own: it points you to askUserQuestionTimeout as the opt-in, and that setting has zero occurrences in the 2.1.198 binary. It also narrates 2.1.198 and 2.1.199 in the past tense, as a closed range
And the Wayback Machine settles it outright. The docs have no public repo, so I assumed their past was unknowable. It isn’t — the page is archived, repeatedly, straight through the window:

# every archived capture of the env var reference, 23 Jun - 11 Jul 2026
curl -s "https://web.archive.org/cdx/search/cdx?url=code.claude.com/docs/en/env-vars\
&output=json&filter=statuscode:200&fl=timestamp&from=20260601&to=20260718"

# fetch each one and count mentions of the feature
# (DISABLE_AUTOUPDATER is the control: it should hit on every capture)
for ts in 20260623083334 20260701121132 20260701213540 20260705135805; do
 curl -s "https://web.archive.org/web/${ts}id_/https://code.claude.com/docs/en/env-vars" \
 | gunzip -c | grep -c -i 'CLAUDE_AFK'
done

capture (UTC)	`CLAUDE_AFK`	`AskUserQuestion`	`DISABLE_AUTOUPDATER` (control)
23 Jun	0	0	2
1 Jul 12:11	0	0	2
1 Jul 21:35	0	0	2
5 Jul	2	2	2

2.1.198 was published to npm at 2026-07-01T16:50:16Z. The 21:35 capture is four hours and forty-five minutes later — and the page does not mention the feature under any name: not afk, not auto-continue, not AskUserQuestion, not COUNTDOWN. (idle appears twice, both unrelated: API_FORCE_IDLE_TIMEOUT and the MCP tool timeout.) The control hits on every capture, so this is absence, not a broken grep
So the two questions collapse into one answer. On the day it shipped, the feature was in neither the release notes nor the docs. There was no channel through which a user could have been told
The documentation appears between 1 July 21:35 and 5 July 13:58 — a window containing the 2.1.200 reversal (2026-07-03T04:33:49Z). And the entry that shows up describes auto-continue as “off by default”, which was only true after the fix. The docs never described the world as it actually was on 1 and 2 July. They arrived with the reversal and documented the reversed behaviour
The tidy phrase for this is that the docs caught up. What they actually did was skip the part where it was on

#So where’s the commit?

The obvious next move: open the commit that introduced it and read the reasoning
There isn’t one. Not “hard to find” — it does not exist publicly
Neither does a revert commit. The reversal in 2.1.200 has no public commit either.
The only git artifacts either release left behind are two automated changelog commits, both titled chore: Update CHANGELOG.md and feed.xml — notes about a release, never the release:
- 75709ea — publishes the 2.1.198 notes (the release that shipped it, unmentioned)
- 1322e9b — publishes the 2.1.200 notes (the reversal)
Fine — then diff the source between releases. There is no source to diff
anthropics/claude-code is not the product. It is the changelog, the docs, plugin examples, a couple of example infra configs, and the bots that triage the issue tracker:

git ls-files | wc -l # 216 tracked files
git ls-files '*.md' | wc -l # 104 of them markdown

git ls-files | cut -d/ -f1 | sort -u | grep -v '^\.'
# CHANGELOG.md demo.gif examples feed.xml LICENSE.md
# plugins README.md Script scripts SECURITY.md

Every executable file in there is an example or a maintenance script. plugins/ holds sample plugins, examples/ holds a GCP gateway Terraform config and an MDM profile, scripts/ is eight files of issue-tracker automation (auto-close-duplicates.ts, sweep.ts, gh.sh). Nothing in it ships to you
The repo does tag releases, so the tags at least look diffable. They aren’t, in the way that matters:

git diff --stat v2.1.197..v2.1.198
# CHANGELOG.md | 35 +++++++++++++++++++++++++++
# feed.xml | 77 +++++++++++++++++---------------------------------
# 2 files changed, 74 insertions(+), 38 deletions(-)

feed.xml is the changelog restated as RSS, so that diff is the changelog twice. Across ten consecutive releases (2.1.196 → 2.1.206), every tag-to-tag diff touches those two files and nothing else
The punchline: a release tag diff is the release notes. These are release-note tags, not source tags — there is no version of the code to check out
So “read the release notes” fails (silent change), “diff the repo” fails (no source), and “diff the tags” fails (the tags are the notes). Three dead ends, one cause: nothing Anthropic publishes to git is the thing they ship you
The authored source is published nowhere; the behaviour ships only inside the compiled binary
So the sum of public evidence that this feature ever existed is:
- the message it printed into people’s terminals
- an env var (CLAUDE_AFK_TIMEOUT_MS) that users found by asking each other, no release note having named it
- one changelog line, three days later, announcing its removal
The feature’s introduction left no trace in the release notes or in git. Its deletion is the first time the notes ever mentioned it.
Worth separating two claims that are easy to conflate:
- there is no public source repository — true, and that’s the governance problem
- there is no way to see what shipped — false, and that turns out to matter enormously (below)
Skip ahead if you like: the shipped binary settles the question that git can’t. The feature is provably absent from 2.1.197 and present in 2.1.198, and you can check that yourself in about five minutes.

#Why was it added? (evidence, not confirmation)

No official rationale was ever published (no design doc, no changelog line, no PR — see below)
Circumstantial evidence of intent, all from naming and the message text:
- Internal name is AFK — “away from keyboard” (CLAUDE_AFK_TIMEOUT_MS)
- The message assumes an absent human: “the user may be away from keyboard”
- Plausible target: unattended / many-parallel-agent runs that would otherwise block forever on an absent human
Users in the thread describe exactly the workflow it breaks: dozens of agents, some parked for days, waiting on a human by design (earlye)
Tension: the same design that unblocks an absent human also lets an agent pick a fork in the road you explicitly reserved for yourself
The strongest evidence is inside the binary, and it’s present in 2.1.198 itself. Two separate things, worth keeping apart:
1. A field on the tool’s own schema — this one stays local. It rides along in the tool result, tells the model the answer was auto-resolved rather than chosen, and picks which component renders the transcript line:

// v2.1.198, verbatim. `H` is the minifier's name for the schema library
// (Zod); the field name and the description text are the binary's own.
afkTimeoutMs: H.number().int().positive().optional().describe("Set when the dialog
auto-resolved after this many milliseconds of idle (user away from keyboard).
Absent on every human-resolved path.")

2. An analytics event — this one leaves your machine. Fired at the moment the dialog auto-advances:

// v2.1.198, verbatim. The mangled names (q, ld, It, R, I, s) are the
// minifier's; the event name and every property key are the binary's own.
q("tengu_ask_user_question_afk_auto_advance",{...i&&{source_hash:ld(i)},
 timeoutMs:It, questionCount:s.length,
 hadPartialAnswers:Object.keys(R).length>0, isInPlanMode:I})

tengu_* is the naming convention for Claude Code’s analytics events throughout the binary. The question text isn’t sent; source_hash is a hash, and the rest is counters
Absent from 2.1.197. It arrived with the feature, in the same release
Read the payload for what it is: an instrument for counting how often the dialog resolved without a human — how many questions were pending, whether it happened mid-plan, and whether you had partially answered
That last one is hadPartialAnswers. The half-answered case wasn’t an oversight that nobody saw coming — it has a code path, and that path is counted separately from the rest
So: this was built, not stumbled into. The behaviour, the countdown, the schema field and the analytics all landed in the same release — that’s a feature with a measurement rig attached, not a stray default
Note what that does not establish. It says nothing about who, or whether a who was involved at all. The questions at the top of this post stay open; all the binary proves is that the work was coherent and deliberate, not who or what did it
Same release, the countdown it printed at you: auto-continue in {n}s · any key to stay
So the capability was designed, instrumented, and given UI — and still never made the notes. That’s the gap the post is about: this wasn’t too small to mention. Someone built a measurement rig for it.
What none of it tells us is who signed it off, or whether anyone weighed the failure mode against the upside. Still inference; still no published rationale.

#Can you even diff it?

Everything above says no. Then you look at what’s actually installed and the answer changes.
It’s a ~250MB native executable — and, crucially, not stripped:

file ~/.local/share/claude/versions/2.1.211
# ELF 64-bit LSB executable, x86-64, version 1 (SYSV), dynamically linked,
# interpreter /lib64/ld-linux-x86-64.so.2, BuildID[sha1]=..., not stripped

It’s a Bun-compiled binary. Bun’s single-file executables append a module graph to the end of the runtime, behind a magic marker — and it’s right there:

grep -abo -- '---- Bun! ----' ~/.local/share/claude/versions/2.1.211 | tail -1
# 261973153 <-- ~50KB from the end of a 262MB file

Bun compiles by embedding the JS bundle inside the executable, so the shipped JavaScript is sitting in the file. strings reads it:

strings -n 3 ~/.local/share/claude/versions/2.1.211 | grep -c 'CLAUDE_AFK_TIMEOUT_MS'
# 4

Every claim in “The fix” above was read straight out of that binary — the setting name, the 60s/5m/10m/never values, the analytics event, the countdown env var
The installer keeps recent versions on disk (ls ~/.local/share/claude/versions/), but only the last few — not enough to reach back to July
Any version you like is on npm, though. The catch: @anthropic-ai/claude-code is a ~152KB installer stub (7 files, dist.unpackedSize 155,204) — no product in it. The binary lives in per-platform packages:

npm view @anthropic-ai/claude-code-linux-x64@2.1.198 dist.unpackedSize
# 248900994 <-- ~249MB, the actual thing

So: closed source, but not a black box. Every release is fetchable and every release is legible. The distinction matters.

#So let’s actually diff it

So let’s stop theorising and actually do it: pull 2.1.197 and 2.1.198 off npm and diff them.
The feature has a distinctive internal name — AFK. Grep both binaries for it:

for v in 2.1.197 2.1.198; do
 echo "=== $v ==="
 for s in "away from keyboard" "CLAUDE_AFK_TIMEOUT_MS" "CLAUDE_AFK_COUNTDOWN_MS"; do
 printf ' %-26s ' "$s"; strings -n 3 "b-$v/package/claude" | grep -c -- "$s"
 done
done

# === 2.1.197 ===
# away from keyboard 0
# CLAUDE_AFK_TIMEOUT_MS 0
# CLAUDE_AFK_COUNTDOWN_MS 0
# === 2.1.198 ===
# away from keyboard 2
# CLAUDE_AFK_TIMEOUT_MS 3
# CLAUDE_AFK_COUNTDOWN_MS 3

Zero to non-zero, across exactly the boundary the reporter named. No commit, no changelog line, no PR — but the artifact is unambiguous about when it landed.
This is the record that doesn’t exist in git. It was always in the thing they shipped you.
And it settles what the release actually did. The gate that decides whether the dialog gets a timer at all, in both versions, side by side:

// Both verbatim, only whitespace added. The mangled names (ke, Ie, li, OOb, Rpf,
// Di, Jyn) are the minifier's; `hasExternalRacer` and the env var are the binary's.
// v2.1.198
ke = !Ie && !n.hasExternalRacer && !li()
// v2.1.211 — same three conditions, plus one
OOb = !Rpf && !Xde.hasExternalRacer && !Di() && (Jyn !== null || ye.CLAUDE_AFK_TIMEOUT_MS !== void 0)
// ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the entire fix

Jyn there is the afkTimeoutMs prop — the /config setting, resolved through the switch above. That’s the whole difference: in 2.1.198 the gate existed, but nothing you could set was allowed to close it. In 2.1.211 it asks your permission first
Worth being precise, because it’s the sort of thing that gets overstated: it isn’t that 2.1.198 had no gate. It had this one, and it turned on whenever the dialog had no external racer. What it lacked was any condition a user could influence
Two days of outcry, and the remedy is one && clause. Which is also the point: it was one && clause away from never having happened.
But notice what that grep needed: the reporter handed us the version, and the feature has a name to grep for. Neither is true on an ordinary Wednesday. So the real question is whether you’d have found this cold, knowing neither
A blind string-level diff of 2.1.197 → 2.1.198:

for v in 2.1.197 2.1.198; do strings -n 8 "b-$v/package/claude" | sort -u > "s-$v.txt"; done
diff s-2.1.197.txt s-2.1.198.txt | grep -c '^[<>]'
# 21903

21,903 changed strings for one release. The minifier renames every identifier on every build, so nearly all of it is churn, not change. CLAUDE_AFK_TIMEOUT_MS is in there — buried in 21,902 lines of noise
One caveat on that number, since it looks more solid than it is: it’s a property of the invocation, not of the release. strings -n 3 gives 81,289; the default -n 4 gives 29,910; -n 8 gives 21,903. The shape of the argument survives any of them — tens of thousands of lines, overwhelmingly noise — but don’t read 21,903 as a constant
Now filter to things that look like English sentences. Keep only added lines, made of letters and ordinary punctuation, starting with a capital, at least five words long. That drops every mangled identifier, path, and code fragment:

# added strings only: present in 198, absent from 197
diff s-2.1.197.txt s-2.1.198.txt | grep '^>' | sed 's/^> //' > added.txt
wc -l < added.txt
# 16255

# ...that read like English sentences
grep -E '^[A-Z][a-zA-Z0-9 ,.:;'"'"'-]+$' added.txt | awk 'NF>=5' > prose.txt
wc -l < prose.txt
# 156

156 lines. That’s the whole surface of new human-readable text in the release — small enough to read over coffee. And the feature is in there, in plain language:

Before going idle the user had selected:

That’s the string injected back into the conversation when the dialog answers for you. Read that line cold, knowing nothing, and you’d stop
It lands at line 11 of the 156, which sounds like a lucky break and isn’t: s-*.txt was sort -u’d, so the list is alphabetical. Ten lines starting with “A” precede it, and it starts with “B”. Position tells you nothing here — the point is that 156 lines is a five-minute read, not that the alphabet was kind

#What it costs to find that

So the diff works. A person doing this ritual on 1 July, with no privileged information, would have caught it on the day it shipped — before the issue was filed.
Tempting conclusion, then: “so just diff every release.”
Which answers one of the questions from the top of this post — did a human release manager diff the release against the previous one before it went out the door?
- Whoever shipped 2.1.198 had every advantage I didn’t: the source, the build, the diff, the review, the authors to ask
- I had a curl and a grep, and it took about five minutes
- So: either nobody looked, or someone looked and shipped it anyway. Both are answers. Neither is good.
- The rest of those questions — who wrote it, who reviewed it, who signed it off — stay unanswerable, because the public record where that would live does not exist. That’s the same absence as the missing commit, wearing a different hat.
Which is the uncomfortable finding, not a reassuring one:
- Can you? Yes. Demonstrably. It took a curl, a strings, and a diff.
- Should you have to? 156 lines per release, forever, across every tool that auto-updates, to learn what a one-line release note would have told you.
- Nobody is going to do this. The people most exposed — the ones running unattended agents at scale — are the least likely to be grepping binaries at 2am.
The capability is a workaround, not a remedy. That it works is what makes its necessity hard to accept.

#Why this is more than burned tokens

Cost angle: an unattended agent auto-answering its own questions can burn tokens on the wrong path
Safety angle is worse than cost:
- AskUserQuestion is used as an explicit safety gate — hooks/rules built on it assume it blocks
- Turning a blocking gate into a 60s countdown silently voids that assumption
- People run Claude Code in genuinely risky contexts — deployments, infra, prod-adjacent scripts
Compounding factor: Claude Code auto-updates by default
- A silent behaviour change + auto-update = the gate can change under you without a single action on your part
- Ties back to On Cooldowns and Dependabot Tuning — why “newest immediately” is a risk posture

#Turning auto-update off

Three env vars. The resolver checks them in this order, first match wins — note it is not the order you’d guess:
- DISABLE_UPDATES=1 — checked first. The strictest: blocks all update paths, including a manual claude update
- DISABLE_AUTOUPDATER=1 — stops the background check only; claude update still works. Takes precedence over the autoUpdates config setting
- CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC=1 — the big hammer: equivalent to DISABLE_AUTOUPDATER + DISABLE_FEEDBACK_COMMAND + DISABLE_ERROR_REPORTING + DISABLE_TELEMETRY (DISABLE_BUG_COMMAND is the older name, still accepted)
All of them freeze your plugins too. That’s documented for exactly one of the three — see below
The “set it everywhere” problem has a fix: don’t export the var from a shell profile — put it in the env block of settings.json, documented as “environment variables that will be applied to every session”. One file, every invocation — CI, cron, systemd, IDE-spawned terminals included.

// ~/.claude/settings.json — user-wide, survives every shell/IDE/CI invocation
{
 "env": {
 "DISABLE_AUTOUPDATER": "1"
 }
}

Scopes, least to most durable:
- shell profile export → per-shell, easy to miss an environment (the trap)
- ~/.claude/settings.json → user-wide, one place
- .claude/settings.json in a repo → team-wide, checked into source control
- managed-settings.json → enterprise policy, highest precedence, centrally enforced:

macOS: /Library/Application Support/ClaudeCode/managed-settings.json
Linux/WSL: /etc/claude-code/managed-settings.json
Windows: C:\Program Files\ClaudeCode\managed-settings.json

(C:\ProgramData\ClaudeCode is the legacy path and is no longer read.)

No CLI flag exists to disable auto-update; claude update is manual, /doctor reports the update channel and install type

#The catch: this also stops updating your plugins

Turn off the auto-updater by any of the means above and plugin auto-updates stop as well
This one is documented — but on the plugin discovery page, under “Configure auto-updates”, which is not where you are standing when you disable auto-updates:

To disable all automatic updates entirely for both Claude Code and all plugins,
set the DISABLE_AUTOUPDATER environment variable.

To keep plugin auto-updates enabled while disabling Claude Code auto-updates,
set FORCE_AUTOUPDATE_PLUGINS=1 along with DISABLE_AUTOUPDATER.

Where it isn’t: /setup → Disable auto-updates, the page that tells you how to do this, mentions neither plugins nor FORCE_AUTOUPDATE_PLUGINS. Nor does the settings env var table. Follow the docs for the task you’re actually doing and you never learn about it
And the docs only ever say DISABLE_AUTOUPDATER. The binary shows four paths freeze plugins — DISABLE_UPDATES, CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC and autoUpdates: false do it too, and that part is undocumented. It’s a single gate on “is the updater off for any reason”:

// v2.1.211, verbatim. The names are meaningless because the minifier ate them —
// the env var and the log string survive, being strings rather than identifiers.
function u_e(){return h$e()!==null}
function blt(){return u_e()&&!ut(process.env.FORCE_AUTOUPDATE_PLUGINS)}
// ...and at the plugin auto-update entry point:
if(blt()){w("Plugin autoupdate: skipped (auto-updater disabled)");return}

Unreadable, so here it is again with the five functions renamed by me — h$e → disabledReason, u_e → updatesAreDisabled, blt → pluginUpdatesBlocked, ut → truthy, w → debugLog. The logic is untouched; the names are my guesses at intent, not the authors':

// NOT the shipped code — function names below are mine, invented for legibility.
// The control flow, the env var and the log string are verbatim from v2.1.211.
function updatesAreDisabled(){ return disabledReason() !== null }
function pluginUpdatesBlocked(){
 return updatesAreDisabled() && !truthy(process.env.FORCE_AUTOUPDATE_PLUGINS)
}
if (pluginUpdatesBlocked()) { debugLog("Plugin autoupdate: skipped (auto-updater disabled)"); return }

At runtime the skip is nearly invisible — it’s a debug log line, not a warning. Documented or not, nothing in the session tells you your plugins have frozen.
The fix is one more env var — the documented, supported one. It restores plugin updates while leaving the CLI pinned:

// ~/.claude/settings.json — pin the CLI, keep plugins current
{
 "env": {
 "DISABLE_AUTOUPDATER": "1",
 "FORCE_AUTOUPDATE_PLUGINS": "1"
 }
}

FORCE_AUTOUPDATE_PLUGINS, DISABLE_AUTOUPDATER and DISABLE_UPDATES are parsed properly: the parser accepts 1, true, yes, or on (case-insensitive), so =1 does what you’d hope and =0 correctly reads as false
CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC is not. It’s presence-detected, so any non-empty value switches it on — =0 included, which means CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC=0 disables your auto-updater and freezes your plugins:

// v2.1.211, verbatim. `Z3t` is the minifier's name; the env var is the binary's.
// Note the bare `process.env.X` — the value is never read, only its presence.
function Z3t(){if(process.env.CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC)return"CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC";return null}

Note the shape of this: a var whose name begins with FORCE_ is the supported way to get the ordinary behaviour of keeping plugins current. It reads like an escape hatch someone added on the way past.

#Sharp edges

Reading the resolver in 2.1.211, four things disable updates — the three env vars above, plus autoUpdates: false in config. All four also stop plugin updates.
CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC is the surprising one: reach for it as a privacy/egress control and you have silently pinned your CLI and frozen your plugins
autoUpdates: false can be ignored outright. The config path is gated on an extra condition:

// v2.1.211, verbatim — `t` is the minified name for the settings object; every
// key on it is real, because property names survive. `!1`/`!0` are false/true.
if(t.autoUpdates===!1&&(t.installMethod!=="native"||t.autoUpdatesProtectedForNative!==!0))return{type:"config"}
// ^ on a native install with autoUpdatesProtectedForNative,
// your `autoUpdates: false` does nothing at all

So the config key is both undocumented — autoUpdates, as distinct from autoUpdatesChannel, appears nowhere in the docs — and conditionally overridden. Prefer the env vars: they’re checked before it, and unconditionally.
2.1.98 fixed DISABLE_AUTOUPDATER not fully suppressing the npm registry version check and symlink modification on npm-based installs — for a long stretch, “disabled” wasn’t entirely disabled
The auto-updater has overwritten a custom launcher/symlink at ~/.local/bin/claude on every release (since fixed; /doctor now flags externally managed launchers)
Which install methods self-update matters: native and npm auto-update by default; Homebrew, WinGet, apt, dnf and apk do not (Homebrew and WinGet can opt in via CLAUDE_CODE_PACKAGE_MANAGER_AUTO_UPDATE=1). If you’re on native or npm, you are on the daily-cadence treadmill unless you say otherwise

// end LLM-generated content

Claude’s research ends here.

#Wrap-up

Even though the source code is not properly public, I was surprised at how much we could learn from it. Having some clues as to what to look for certainly helped, but it’s still not a replacement for a well edited and accurate changelog.

This wasn’t a stray line of code that slipped through. It looks like an actual feature. Why it got shipped completely under the radar remains baffling.

I’m not assuming bad faith on the part of Anthropic. Things happen. Whether or not things like this continue to happen will help us to understand what Anthropic did or did not learn from this misfeature.

Read on website

AI Shoulder Surf V3

olaf@wundersolutions.com (Olaf Alders) — Tue, 09 Jun 2026 00:00:00 +0000

What follows is an AI summary of our meeting. The target audience is mostly the folks who were on the call, but I’ll be happy if anyone else gets something out of it.

"Stop....hammer time?" by troy_williams is licensed under CC BY 2.0 .

Contains LLM-generated content not written by Olaf

On Thursday, May 28, 2026 we had our third AI Shoulder Surf. The first writeup explains the format, but the short version: it’s an informal Zoom call where we share screens, talk about what we’re working on, and admit what we don’t know.

The connective thread this time was Tailscale: everyone at the table had quietly built a private home lab and was reaching it from anywhere without exposing a single port to the public internet.

#Olaf: Coach Claude

I have a triathlon coming up, so I asked Claude to build me a training program. I fed it a GPX file of the bike course so it could analyze the climbs and base the training around the actual route, then gave it my constraints — swim on these days, long run on a Wednesday — and it laid the whole thing out nicely.

As a bonus it generated a little static website for the plan. I spun that up on my Hetzner VM and within about five minutes something had already tried to GET the .env file. It wasn’t being served, so no harm done, but it was a good reminder of what the open internet is like the moment you put anything on it. So I moved the whole thing onto my Tailscale network instead. Now my training plan isn’t getting probed by creeps — it’s just there for me when I want it.

The other nice touch: Claude also produced an iCal subscription and parks it in a GitHub gist. I subscribed to that URL from my phone calendar, and it actually updates when the plan changes. I’m happier with that than I would be wrangling a spreadsheet or paying a monthly fee for an app that doesn’t quite do what I want.

#Aaron: A job-hunt workspace you can reach from anywhere

Aaron has been job hunting, and he hit the familiar problem of bookmarking a posting to “apply later” and then forgetting it. So he built himself a little GitHub project: a spreadsheet of every place he’s thinking about applying to. When he’s in the mood, he kicks off an agent — he’s on Gemini CLI / Antigravity now — to research a company, draft a cover letter, and coach him with questions about the role.

The clever part is where it lives. The whole thing sits in a folder on his VM, so when he’s at a coffee shop and feels like chipping away at it, he connects to his Tailscale network, SSHes into the VM, and it’s right there. No syncing the project onto multiple machines, no “which laptop has the latest version.” One home for the work, reachable from anywhere on the tailnet.

#Aaron: A wildcard tailnet with Homepage

Aaron is also self-hosting a pile of little static reports and dashboards, and he’s wired them together with Homepage — a project that gives you a web front end plus an NGINX reverse proxy on a Docker Compose stack. He spins the stack up on his VM and points the reverse proxy at his various static-page folders.

Then the DNS trick: he created a *.dev.<his-domain> wildcard A record pointing at a Tailscale IP address for his tailnet. So every time he spins up a new static site on the VM, it’s instantly reachable at a something.dev.<his-domain> URL — but only if you’re on his tailnet. Public DNS, private reachability.

Mateu is doing something similar from the other direction: he runs a couple of Pi-hole instances for DNS, and he’s made Tailscale aware of them. Because Tailscale knows about his internal DNS servers, it can resolve his domain names and route to the right instance behind an NGINX reverse proxy — which means he doesn’t need the Tailscale client installed on every machine. The cloud in the home, as he put it.

Claude’s note: three people, three slightly different recipes, one shape. A private overlay network plus your own DNS turns “self-hosting” from a port-forwarding-and-dynamic-DNS chore into something closer to a personal cloud. The work has moved from “how do I expose this safely” to “how do I name this conveniently.”

#A quick note on what Tailscale actually is

A useful clarification came up for anyone who hasn’t set it up. Tailscale isn’t exactly a VPN in the route-all-my-traffic sense. Without an exit node enabled, it behaves more like a VLAN — it just gives the machines on your tailnet a route to each other. It only routes all of your traffic through another node if you explicitly turn on exit-node mode. And because it punches through NAT for you, there’s no opening ports on your router, which is most of the historical pain of self-hosting gone in one step.

The recurring sentiment around the table was simply: Tailscale has been a blessing. I can now mostly just tell Claude to set up the Tailscale piece I need and it works.

#Coding from a phone

Aaron joined part of the call from the road and has been doing real work from his phone over Tailscale. Two things made that bearable. First, Termius, a terminal app with pinch-to-zoom, so bumping up the font size mid-session is trivial. Second, saved macros — he keeps things like docker ps one tap away to check whether anything is still alive. That’s a small feature that turns out to be a lifesaver on a tiny screen.

The pain point we all recognized: tmux on a phone. Trying to fire a Ctrl-A prefix and then a pane-switch key on a touch keyboard is genuinely miserable. Aaron’s suggestion was to record the whole key combination as a macro so you can switch panes with a single tap — a good idea I hadn’t tried.

#Tools roundup

A lap around what people are running:

OpenClaw as the driver. Mateu still uses OpenClaw on his OpenAI subscription as his main controller — mostly conversational, which is where he spends most of his time. After a rough patch the project refocused on stability and it’s noticeably better. A new feature he wants to try lets the agent join a Google Meet as a full participant with a voice. I pointed out that video plus text-to-speech sounds like a fast way to rack up tokens.
Hermes as a backup. Mateu has also picked up Hermes, a Python-flavored cousin of OpenClaw that’s gaining momentum, and likes keeping a second agent around — when an update breaks one, the other keeps working. Many heavy users drive these through Discord for its threaded conversations, though Mateu uses OpenClaw’s built-in Control UI. On memory, he’s been using a notes plugin that searches saved memory, which works well but occasionally forgets to look in all the right places.
Two quotas, not one. Aaron’s find of the day: Gemini on the web and the Gemini CLI draw from separate quotas, even when you’re signed into the same subscription. So he does his planning and architecture conversation in the web app, asks it to emit markdown — a plan, a README, a fresh agent config — then downloads those into his working directory and runs the CLI against them. Two budgets, planning on one and implementation on the other.
Koan and plan review. Koan runs on a subscription rather than API credits, and Mateu confirmed you can have it review its own plan before it acts. I’d found some of its autonomous behavior a bit head-scratching, and reviewing the plan up front is the lever for that.

Claude’s note: the “two separate quotas” thing is the kind of accidental arbitrage that won’t last, but while it does it neatly matches the natural shape of the work — expensive, exploratory thinking in one place, cheaper mechanical execution in another.

#Sandboxing and how much to trust the agent

Everyone has landed somewhere different on the trust-versus-isolation dial.

I’ve been leaning on Nono sandboxes, even inside a VM that exists only for side projects — partly because I once gave Claude broad filesystem permissions and didn’t love what it did with them. Nono lets you define profiles and compose them, so I have a wrapper that detects whether it’s a Go, Perl, or JavaScript project and pulls the right profile automatically. It gets trickier when I want to grant Terraform or SSH, which I’m still working out. It matters most for the CPAN security work: when I’m poking at a proof-of-concept exploit, I want the agent locked down hard — the last thing I want is an over-eager agent opening a public issue about an unpatched problem.

Aaron keeps a dedicated Ubuntu VM that holds nothing but his dev environment, backed by snapshots, so a wiped disk is a non-event. For his own side projects he often doesn’t bother sandboxing further, since the sister directories share the same credentials anyway. When he wants real isolation he used to run Gemini CLI inside its own restricted Docker container; lately he’s been trusting Antigravity’s allow-list controls for system commands, running on the host in its own sandbox mode.

Mateu sits at the trusting end: LXC for some instances, bare metal on macOS for others, and because he enjoys the DevOps side he hands the agent SSH access and passwordless root so it can manage other machines. No incidents so far — knock on wood.

Claude’s note: this is the same axis as the v1 and v2 conversations, but the spread is the interesting part. The right amount of isolation isn’t a constant — it tracks the blast radius of the task. A throwaway side project and a proof-of-concept exploit deserve very different cages.

#Identity, roles, and the tax of least privilege

The richest thread came out of Aaron comparing AWS and Google Cloud. GCP lets you define more granular IAM roles and pin a role to an identity, and it makes it easier to see what permissions you actually hold in a given environment. That got him thinking about agents. Today, an agent usually acts as you — it carries an SSH key that represents you, reused across many projects, which is only ever as secure as you are. His plan is to flip that: generate scoped, role-based keys and hand the agent an identity that says “this is me, but a sub-agent that can only do these specific things,” reusing the same role template across repos so he isn’t minting a fresh identity per project.

Mateu came at the same topic from the scar tissue side. At a former job he spent an entire day — hundreds of messages back and forth — chasing permissions one piece at a time, to the point where he couldn’t even see his own permissions because he lacked permission to view them. His take: least privilege is great in theory, but it falls apart when the people granting access don’t have full knowledge of what’s needed, and it becomes a tax that slowly drains your will to do the actual work.

That tipped us into a broader gripe about process: how a small shop lets you just pick something up and do it, and how every additional reviewer — team, then SRE, then a security gate with nitpicks that aren’t even security-related — adds drag, until a long-lived branch becomes a thing to dread. I admitted that a nitpicky AI review sometimes reminds me of an annoying colleague; the difference is I can turn that one off.

Claude’s note: there’s a real tension here that the agent era sharpens rather than resolves. Aaron wants more granular identities so an agent can be trusted with less; Mateu has lived the version where granularity becomes its own full-time job. Both are right. The thing that makes scoped roles humane is good tooling to see and apply them — which is exactly what Aaron liked about GCP and exactly what was missing in Mateu’s story.

#The Bigger Themes

A few threads ran through the whole session:

Tailscale changed the default. Self-hosting used to mean port forwarding, dynamic DNS, and a low-grade anxiety about what you’d exposed. The whole table has quietly moved to a private overlay network where the hard question is no longer “is this safe to expose” but “what do I want to call it.” That’s a real shift in posture.

The work is portable now. Between Aaron’s coffee-shop SSH sessions and a training plan that follows me to my phone calendar, the pattern is the same: keep the work in one place on a VM, reach it from anywhere on the tailnet. The device you’re holding stops mattering.

Scope the agent’s identity, not just its sandbox. Last time the theme was tighter isolation. This time it extended inward: not only where the agent runs, but who it is when it acts. Role-based identities for agents are the logical next step from role-based containers.

Process is the hidden cost. The flip side of solo speed is that bureaucracy is a tax you feel acutely once you’ve worked without it. The same instinct that makes people scope their agents carefully also makes them allergic to ceremony that doesn’t earn its keep.

Claude’s note: the through-line from v1 to v2 to v3 is consistent — containerize, choose your models deliberately, shrink the blast radius. V3’s contribution is that the boundary people care about is moving from the machine to the identity.

#Cadence

Same as before: we’ll keep doing these on an ad hoc basis. Frequent enough to keep up with what people are building, infrequent enough that it never becomes a standing meeting.

// end LLM-generated content

#Where This Is Going

There will be a V4. If you’d like to join the next one, reach out.

Read on website

The Great Perl Toolchain Summit CLI Throwdown 2026

olaf@wundersolutions.com (Olaf Alders) — Thu, 21 May 2026 00:00:00 +0000

Last year a few of us at the Perl Toolchain Summit got together to trade command-line tips. I wrote up the notes. This year there was some demand for a repeat, so we continued the tradition. Hopefully you find some helpful tips.

Full disclosure: I don’t use AI to write the content of my blog posts, but in this case I did get an assist from Claude, particularly in summarizing notes and adding project links. Since this is meant to be a cheat sheet rather than a piece of creative writing, I’m ok with using AI as a tool to help get the job done.

This year’s participants, in order of appearance, were:

The initial post featured male wrestlers, so I’m hoping this year’s photo provides a much needed counterbalance.

"Jungle Kyona vs Natsumi Maki-japanese female" by sabrebiade is marked with Public Domain Mark 1.0 .

Contains LLM-generated content not written by Olaf

#Leo’s Picks

#superpowers

An agentic skills framework and software-development methodology for coding agents like Claude Code. Rather than diving straight into writing code, it pushes the agent to tease a spec out of the conversation, get your sign-off, and then work through an implementation plan with an emphasis on test-driven development.

Olaf’s note: superpowers deserves its own series of posts. I rely on this quite heavily for all sorts of daily tasks.

#nono

A capability-based sandbox for AI agents and other untrusted processes. It uses kernel-level primitives — Landlock on Linux, Seatbelt on macOS — to enforce a default-deny policy, so a process starts with no file, network, or command access until you explicitly grant it.

Olaf’s note: I use nono every day, thanks to Leo having pointed it out shortly before we got together for the summit. Now I spend a lot less time building Docker containers. 😅

#Shawn’s Picks

#eza

A modern replacement for ls with colourful, human-friendly output and git integration for directories. Claude’s note: eza was also a pick in last year’s throwdown.

#fx

A terminal-based JSON viewer and processor. It offers an interactive mode for exploring large JSON documents as well as a scriptable mode for transforming them, which makes it handy as an alternative to reaching for jq.

#Flox

A package and environment manager built on Nix. Flox installs sandboxed binaries, pins their versions, and lets you reproduce the same development environment across machines and projects.

#zoxide

A smarter cd command. It remembers the directories you visit most and lets you jump straight to them with a few characters instead of typing out full paths.

#fish

A user-friendly shell with syntax highlighting, autosuggestions, and smart tab completion out of the box. Claude’s note: fish made the list in the 2025 throwdown too.

#fastgron

A high-performance implementation of gron, which turns JSON into discrete, greppable assignment statements — one path per line — so you can search structured data with ordinary tools like grep. Running fastgron -u performs the reverse transformation, reassembling the flattened output back into JSON.

#wezterm

A GPU-accelerated, cross-platform terminal emulator and multiplexer written in Rust. Claude’s note: WezTerm was a 2025 pick as well.

#q

A tiny command-line DNS client, positioned as a modern replacement for dig. Alongside the classic UDP and TCP transports it speaks DoT, DoH, DoQ, and ODoH, and can emit results as raw dig-style output, JSON, or YAML.

Olaf’s note: fun fact, dig apparently stands for domain information groper

#Jujutsu

A Git-compatible version control system. Jujutsu (jj) uses a Git repository as its storage layer, so it interoperates with existing Git tooling while offering a different — and arguably simpler — working model on top of it.

#dyff

A diff tool for YAML (and JSON) files. Unlike a plain textual diff, dyff compares documents structurally, so two YAML files that hold the same data in a different key order are correctly reported as equivalent.

#cswap

A switcher for multiple Claude accounts that works with both the Claude Code CLI and the VS Code extension. cswap --list shows each account along with its 5-hour and 7-day usage and reset times, so you can check your quotas before deciding which account to switch to.

#Maccy

A lightweight clipboard-history manager for macOS. It keeps a searchable history of what you have copied and makes earlier entries available again with a keyboard shortcut.

Olaf’s note: I use Alfred as my clipboard history manager, but I should check this out

#gcrane

A command-line tool from Google’s go-containerregistry project for inspecting and manipulating container images directly in a registry — listing tags, copying images, and examining metadata without a full docker pull.

#Paul’s Picks

#AeroSpace

An i3-inspired tiling window manager for macOS. It arranges windows automatically, manages workspaces, and is driven entirely from the keyboard. Claude’s note: AeroSpace was Shawn’s pick last year — this year it changed hands.

#Ghostty

A fast, native, GPU-accelerated terminal emulator. Paul has switched to Ghostty from WezTerm, which was his terminal of choice in last year’s throwdown.

#zsh

An extended shell with powerful completion, scripting capabilities, and a deep plugin ecosystem. Claude’s note: zsh also featured in the 2025 throwdown.

#Mickey’s One Weird Trick — Shell Wizards HATE Him

#Process substitution with `<()`

Mickey’s contribution wasn’t a tool to install but a shell feature worth knowing: process substitution. The <(...) syntax runs a command and presents its output as if it were a file, which lets you feed command output to programs that expect a filename.

A couple of examples of where this comes in handy.

Compare the output of two commands without creating temporary files:

# See how the contents of two directories differ
diff <(ls dir-one) <(ls dir-two)

# Compare the installed packages on two hosts
diff <(ssh host1 'dpkg --get-selections') <(ssh host2 'dpkg --get-selections')

Feed remote or generated content to a tool that expects a file on disk:

# grep a remote file without downloading it first
grep 'TODO' <(curl -s https://example.com/notes.txt)

# Find the lines common to two sorted lists
comm -12 <(sort a.txt) <(sort b.txt)

There is also a companion form, >(...), which provides a filename that pipes into a command — useful when a tool insists on writing to an output file but you would rather stream the result somewhere else.

// end LLM-generated content

One caveat, via David Cantrell on Mastodon: <(...) doesn’t give you a real file, it gives you a pipe. Most tools don’t care, but some will fail in confusing ways — for instance, a script that checks whether its input is a readable file before doing anything will refuse to proceed.

#Olaf Should Not Have Chosen to Go Last

I didn’t have a lot to contribute this year since I haven’t written much code in the past year, having foisted most of that responsibility onto Claude. Having said that, Leo’s picks of superpowers and nono are game changers for me and I’m still in love with WezTerm. I also did share my talk about us AI skill, which is helpful in auditing everything from blog posts, to resumes. I believe that qualifies as a CLI tool, even if it also works in browsers.

Read on website

AI Shoulder Surf V2

olaf@wundersolutions.com (Olaf Alders) — Wed, 20 May 2026 00:00:00 +0000

Back on April 1, 2026 we had our second AI Shoulder Surf. I wrote up the first of these sessions last time around. It’s basically an informal Zoom call where we share screens, talk about what we’re working on, and admit what we don’t know. No video recording, to keep the stress and performative aspect of video calls out of it, and to leave space for asking questions without posturing. Admitting to knowledge gaps is not a problem for me personally, because knowledge gaps are basically all I have, but I want other people to have a safe space too.

What follows is again a combination of a factual AI summary and my own commentary. I had an assist but it’s not slop. The target audience is mostly the folks who were on the call, but I’ll be happy if anyone else gets something out of it.

"Cardiff Kook, December 8 2013" by Tim Buss is licensed under CC BY 2.0 .

Contains LLM-generated content not written by Olaf

#Daniel: Incus/LXD Coding Sandbox

First off Daniel demoed coding-sandbox, which he had been building for several weeks around an Incus/LXD sandbox. He landed on LXD over QEMU/KVM and VirtualBox because the CLI is faster, mounting directories is more Docker-like, and the whole setup leans well into the ephemeral-container model.

There are two execution modes:

Ephemeral container (the default): built from scratch on top of Debian and Bash, with a unique directory per session. Cheap to spin up, cheap to throw away.
VM: persistent storage, but expect roughly ten minutes the first time to build images and install tooling.

To avoid hitting the public internet every rebuild, Daniel runs an APT cache on his local network. The package of interest is apt-cacher-ng — multiple machines on the LAN pull from a central cache, which is handy both for testing new images without re-downloading the world and for keeping packages in sync across machines.

He demoed two variants: a standard coding sandbox and a “quick” coding sandbox on top of an Ubuntu image with Node.js as a baseline dependency. Inside the sandbox he’s tested several coding tools so far — Claude Code, Qwen Code, and OpenCode.

There’s still some polishing to do on the setup script for general usability, and he’s eyeing automation around the Chrome connection.

#Ingy: Sandboxing via KVM

Ingy talked about a how he keeps Claude in a sandbox using KVM, motivated by the realization that the AI agents he was running had access to a lot more of his machine than he was really comfortable with. Once you start thinking about API keys, credentials, and what a misbehaving agent could touch, the appeal of a heavier isolation boundary goes up quickly. He also brought up the importance of limited-access roles and proper backups.

Daniel chimed in to suggest Incus as worth trying for development use — similar reasoning, lighter footprint than full VMs.

Claude’s note: this thread tracked closely with the “containerization for safety” theme from the v1 writeup. The trend line in this group is unambiguous: people are tightening up the blast radius of their agents, not loosening it.

#Claude: Performance and Pricing

There was a long, slightly grumpy thread about Claude performance. People reported high load averages and slow processing, which led Ingy to wonder out loud whether KVM was making things worse and to float external VMs at Hetzner as an option. Daniel made the counter-case that containers might actually be better here, since they use system resources directly rather than virtualizing them.

On pricing: Ingy is on the $100/month tier and says he never hits limits. I’m also on $100/month and hit them regularly. Same plan, very different experience. That gap is interesting in its own right — it depends a lot on what you ask Claude to do, how much you let it run, and whether you’re running things overnight.

There was also a passing mention of a known bug in the Claude CLI where processing can get stuck and the fix is to kill and restart. Nothing ground-breaking, but worth knowing when you’re staring at a frozen prompt at midnight.

We also chatted about using the CLAUDE_CODE_DISABLE_1M_CONTEXT=1 env var to keep Claude at the 200k token ceiling. I have almost never used 1 million tokens and I don’t feel like I’m missing out.

#Tools Roundup

A quick lap around what people were trying:

Eugen: positive experience with Cursor
Mateu: using OpenCode with GPT-5.4. He noted improved security features as a reason for sticking with that combination.
Daniel: pointed out that AI recommendations can be inconsistent between sessions and tools — likely because of the different “bubbles” or contexts the model is operating in. The same question can get a different answer depending on what else is loaded into the context window.

Claude’s note: the “bubbles” framing stuck with me. It’s a useful way to explain why two people can ask the same model the same question and walk away with different answers. The model didn’t change — the surrounding context did.

#Mateu: Tuning Bert’s Personality

Mateu walked through some work on tuning his bot Bert’s personality — mostly in the direction of talking less.

#The Bigger Themes

A few threads ran through the whole session:

Tighter isolation, not looser. Between Daniel’s Incus/LXD work and Ingy’s use of KVM, the direction of travel is clear: as agents do more, people want them to be able to touch less. Containers and VMs aren’t just for production anymore — they’re a development-environment hygiene question.

Same plan, different mileage. Two people on the same $100/month Claude plan can have wildly different experiences with rate limits and performance. That makes blanket statements about value-for-money basically useless. What actually matters is your workload pattern.

Context bubbles. Daniel’s “bubbles” observation — that AI recommendations shift based on the surrounding context — explains a lot of disagreements that look like disagreements about the model but are really about what’s been loaded into the conversation. Worth keeping in mind the next time someone tells you “Claude said X.” Claude said X given everything else in the session.

Less talkative is better. Mateu’s work on Bert and the general drift of the conversation pointed at the same thing: agents that respond with less, more carefully, are easier to live with than agents that fill the screen.

Claude’s note: this is roughly the same shape of theme list as last time (containerization, model choice, image input, --chrome). I’d take that as a sign that these are durable things to think about, not just first-session novelty.

#Cadence

We’re planning to keep doing these on an ad hoc basis. Frequent enough to actually keep up with what people are working on, infrequent enough that nobody feels like it’s a standing meeting.

// end LLM-generated content

#Where This Is Going

V3 will happen soon. Sign up now.

Read on website

AI Shoulder Surf V1

olaf@wundersolutions.com (Olaf Alders) — Mon, 16 Mar 2026 00:00:00 +0000

A while back I thought of having some regular office hours so that I could share my screen with some friends and we could just talk about what we are learning and working on. I think office hours are hard to sell unless you’re some kind of expert or thought leader. I am neither of those things, but I do enjoy showing what I’m working on. So, I proposed a “shoulder surf” session where people could share screens and gab. No video recording was made, in order to remove the stress and the performative aspect of video calls. It also leaves space for asking questions and admitting you have knowledge gaps. Admitting to not having answers is not a problem for me personally, because knowledge gaps are basically all that I have, but I want other people to have a safe space.

I posted something on LinkedIn, texted some former colleagues whom I have been keeping in touch with and we set up a meeting. I thought we’d have a handful of folks, but we had a dozen and I learned a lot. This was the first session of at least two. (I’m not making big plans).

What follows is a combination of a factual AI summary of the call and some of my comments. So, I did have an assist, but it’s also not slop. The target audience of this post is the folks who were on the call, but maybe some others will find the digest version useful.

"Peaking over @brad_frost's shoulder at An Event Apart" by Jeremy Keith is licensed under CC BY 2.0 .

Contains LLM-generated content not written by Olaf

#Mateu: OpenClaw and AI-Generated Video

Mateu kicked things off by demonstrating how he used AI to produce OpenClaw: Introduction & Memory Search Overview, a YouTube video explaining OpenClaw — a project he’s been experimenting with. He runs it inside a Linux container on Proxmox and used Manus to generate the video.

On the cost side, Mateu has been happy with the Codex model at $20/month and finds it genuinely useful for day-to-day work.

#Ingy: Headless Claude in a Makefile

Ingy talked about makes, and an automation that he put together just a few minutes before the call. It centres on a version-update skill that runs Claude in headless mode. The skill instructs Claude to:

Run make version-check and capture the output
Find all lines indicating an outdated version (<file> <old-version> -> <new-version>)
Update the version string in each corresponding .mk file
Re-run make version-check to confirm everything is current
Commit the changes with a descriptive message

This is then wired up as a GitHub Actions workflow that runs on a daily schedule. It checks out the repo, passes the ANTHROPIC_API_KEY, runs make version-update, and pushes any commits if versions changed.

Ingy described this as a shift toward building agent-friendly tooling rather than just human-centric tools. The skill file is the spec; Claude is the executor.

#Olaf: The “Talk About Us” Skill

I presented the talk-about-us skill, which I wrote about at length in an earlier post. The short version: it’s derived from Anil Dash’s framework for writing copy that other people can repeat accurately without you in the room.

The skill audits text for jargon, distinctiveness, emotional resonance, and value-first messaging. It gives frank feedback and rewrite suggestions while preserving the author’s voice. Friends have found it useful for blog posts, sponsor emails, resumes, and grant proposals. It gives you the honest outside perspective that’s hard to get when you’re too close to your own work.

The skill itself was written using superpowers’ skill-writing skill — a nice example of using the tools to build the tools.

#Nico: The Bot That Works While You Sleep

Nico showed off the most ambitious automation of the afternoon: koan, a bot system designed to maximize Claude quota usage during off-hours. While he’s asleep, the bot:

Processes a queue of GitHub issues
Implements fixes and creates pull requests
Responds to PR comments
Runs multiple refinement passes: implementation, refactor, security audit

The queue is accessible via Telegram, which means Nico can add tasks to the pipeline from his phone before bed and wake up to completed pull requests. It’s queue-based, runs unattended, and uses iterative passes to improve code quality rather than trying to get everything right in one shot. The combination of multiple refinement stages and overnight execution is clever — the quota limits that would be annoying during the day become a non-issue when you have eight hours.

#The Bigger Themes

A few threads ran through the whole session:

Specification over code. Todd made the case that the future of development is writing detailed specifications rather than code. The measure of success isn’t whether the code is correct — it’s whether the tests validate the expected behavior. He argued this requires roughly 10x more tests than traditional development. The Agent Skills specification is worth reading if this resonates with you.

Model selection matters. Most people in the group have settled on Claude Opus for serious development work. The $100/month cost is real, but the quality difference justifies it when you’re using AI as a core part of your workflow rather than an occasional helper.

Editor’s note: there was some discussion about using the Haiku model and having issues getting quality code back out of it. I do think it’s going to be an uphill battle to get great results out of Haiku for everything. There are, however, some things it does very well. I use it to extract event and organization details out of web pages for My Mind is Racing. I would not use it to produce code, but for less complex tasks it can be a significant money saver.

Containerization for safety. There was broad agreement that running AI agents in isolated environments — Docker, KVM, Incus — is important for anything that touches real systems. You want controlled, auditable access, not a process that can reach anywhere it wants. See also this walkthrough on Claude on Incus if you want a practical starting point.

Editor’s note: I’ve spent a fair amount of time getting custom Docker containers set up so that I can let Claude essentially run hog wild while I sleep. While this is a good fit for my particular use case right now, I’m looking forward to trying out more lightweight solutions.

Image input is underused. Several people mentioned that feeding screenshots and photos to Claude for debugging is surprisingly effective. When you’re staring at a visual bug or a confusing terminal output, sometimes the fastest path is just to take a screenshot and ask.

--chrome is worth knowing about. Claude’s --chrome flag enables browser control, which opens up front-end testing automation that would otherwise require a separate framework. A few people hadn’t heard of it and were immediately interested.

Editor’s note: Playwright MCP Server can be very handy for inspecting web content as well as the network requests involved.

// end LLM-generated content

#Addendum

I’m not sure if this actually, came up but I’ve been using claude-pulse status line for Claude Code that gives you some visibility into what the agent is doing right now, especially around token usage. I get a lot out of that.

#Where This Is Going

We’ll do this again at least one more time. If you want to join the next session, reach out.

Read on website

The Great PTS CLI Throwdown

olaf@wundersolutions.com (Olaf Alders) — Tue, 03 Jun 2025 00:00:00 +0000

I have this kind of annual tradition at the Perl Toolchain Summit where, at some point in the weekend, I look over Paul Johnson’s shoulder and admire his terminal setup. He knows his way around tmux, Neovim and lots of other tools. I make it a point to check in with him again before the weekend is over so that I can steal everything. By the time the weekend is over, we’ve both left and I haven’t had a chance to poach his setup. At some point afterwards I’ll share some tool in the Fediverse that I think is cool and Paul will inevitably point me at something newer, shinier and cooler.

This year the tables were turned and Paul came to me on the first day of PTS to chat about CLI. We decided that we’d get a few of us together on the following morning and we’d trade secrets. What follows are the notes that I took.

Full disclosure: I don’t use AI to write the content of my blog posts, but in this case I did run my notes through claude.ai to add some summaries and links. Claude didn’t get everything, but it was very helpful and it sped things along. Since this is meant to be a cheat sheet rather than a piece of creative writing, I’m OK with using AI as a tool to help get the job done.

This year’s participants in our first (annual?) CLI throwdown were, in order of appearance:

"File:Roppongi 3K 3K (Professional wrestling moves).jpg" by ゾーヒョー is licensed under CC BY-SA 4.0 .

Contains LLM-generated content not written by Olaf

#Paul’s Picks

#WezTerm

A GPU-accelerated cross-platform terminal emulator and multiplexer implemented in Rust. Features include native mouse support, scrollback, ligatures, and color emoji.

#yazi

A blazingly fast terminal file manager written in Rust, based on asynchronous I/O. Features include full asynchronous support, built-in image viewing capabilities, code highlighting, and git integration.

#tmux powerline

A tmux plugin giving you a hackable status bar with beautiful powerline segments. Implemented in bash, it provides customizable segments for displaying information like session details, music player status, battery, and more.

#Tailscale

A zero-configuration VPN built on WireGuard protocol that creates a secure network between your devices. It simplifies secure connections by handling NAT traversal and provides easy access control.

#Neovim plugins

#git-signs

A Neovim plugin that shows Git changes directly in the buffer signcolumn. Features include per-line git blame, stage/unstage changes, and navigation between hunks of modifications.

#SmoothCursor

A Neovim plugin that adds a sub-cursor to show scroll direction, making it easier to track cursor position when using commands like % or <c-f> and <c-b>.

#which-key

A Neovim plugin that displays a popup showing keybindings as you type, helping users remember complex key combinations and commands. Works across various modes, including normal, insert, and visual.

#nvim-cmp

A completion plugin for Neovim written in Lua. It provides a powerful and extensible completion experience with support for LSP, snippets, and custom sources.

#magazine.nvim

An nvim-cmp beta fork.

#PerlNavigator

A language server for Perl, providing features like code navigation, completion, and diagnostics.

#treesitter

A Neovim plugin providing an interface for Tree-sitter, a parser generator tool that provides incremental parsing capabilities, enabling better syntax highlighting and text-objects.

#avante

A Neovim plugin designed to emulate the behaviour of the Cursor AI IDE.

#mcp hub

A Neovim plugin that integrates MCP (Model Context Protocol) servers into your workflow.

#markview

A Neovim plugin for viewing and editing markdown files.

#nvim-scrollbar

A customizable scrollbar for Neovim that can be integrated with other plugins to display git changes or diagnostics in the scrollbar.

#zsh

An extended shell with improved completion, scripting capabilities, and plugins. It’s highly customizable and offers numerous features beyond the standard bash.

#eza

A modern replacement for the ls command with more colorful and human-friendly output, including git integration for directories.

#Raycast

A productivity tool for macOS that provides a quick launcher, extensible commands, and scriptable automation capabilities.

#stats

A macOS system monitor in your menu bar that shows detailed system statistics like CPU usage, memory, network, and more.

#Shawn’s Picks

#aerospace

A tiled window manager for macOS that arranges windows automatically and provides keyboard shortcuts for window management.

#git restore

A Git command to restore working tree files, allowing you to discard changes or restore files from a specific commit.

#lazyvim

A Neovim configuration framework that provides a pre-configured and opinionated setup with various plugins and sensible defaults.

#ctrl-a

A Vim/Neovim feature that allows auto-incrementing numbers in text.

#tmux keybindings in WezTerm

Using tmux-like key mappings within the WezTerm terminal emulator for consistent workflow.

#caps-lock ctrl + escape

A keyboard remapping that makes Caps Lock act as Control when held and Escape when tapped.

#karabiner

A powerful keyboard customizer for macOS that allows complex remappings and custom modifications.

#bat

A cat clone with syntax highlighting, git integration, and line numbers, making it easier to view file contents.

#fish

A user-friendly command line shell with syntax highlighting, autosuggestions, and smart tab completions.

#delta

A syntax-highlighting pager for git, diff, and grep output that improves readability of diffs.

#spacer

A utility for adding visual separation or spacing in user interfaces.

#atuin

A tool that provides a searchable history with context for your shell, syncing across multiple machines.

#devbox

A command-line tool for creating isolated, reproducible development environments.

#direnv

An environment switcher that automatically loads and unloads environment variables depending on the current directory.

#WezTerm quick select

A feature in WezTerm that allows quick selection and copying of text patterns like URLs, paths, or IPs.

#chezmoi

A dotfile manager that helps keep track and synchronize your dotfiles across multiple machines.

#asciinema

A tool for recording and sharing terminal sessions with playback capabilities.

#Mickey’s Picks

#terminator

A terminal emulator that allows you to arrange multiple terminals in a grid-like structure, each with configurable options.

#ctrl-s stop streaming output

A terminal shortcut that freezes the terminal output, which can be resumed with ctrl-q (software flow control). This feature can be disabled in the shell using stty -ixon.

#tmux-resurrect

A tmux plugin that allows saving and restoring tmux sessions across system restarts.

#cd is an alias to pushd

A shell configuration where the cd command is aliased to pushd, maintaining a directory stack for easy navigation. Complemented with cd- aliased to popd.

#zmv for mass renaming via regex

A (zsh) tool for batch renaming files using regular expressions.

#pdftk

A command-line tool for manipulating PDF documents, including merging, splitting, and form filling.

#fpp

Facebook Path Picker, a tool that helps you select files from command output for further operations.

#highlight

A simple tool that adds colors to matched text input.

#Some favorite git commands

#git checkout -p

A Git command that allows interactive selection of hunks to check out, similar to git add -p but for discarding changes.

#git rebase -i

Interactively manipulate (reword comments, reorder or squash) commits (that are ahead of upstream).

#git grep -W

Match showing the function context (e.g. Perl sub).

#git push origin HEAD

Push current local branch to remote.

#git branch –merged | grep -v master | xargs –no-run-if-empty git branch -d

Remove merged branches from local directory (use an alias).

#git clean -dfx

Clean working tree from all untracked files (I have it aliased to distclean in .gitconfig).

#Julien’s Picks

#tig

A text-mode interface for git that provides a visual interface for navigating commits, diffs, and branches.

Editor’s note: I have previously written about tig.

#shutter

A feature-rich screenshot tool with editing capabilities, annotations, and various capture modes.

#peek

#Olaf’s Picks

#Sketchybar

A highly customizable macOS status bar replacement that can display system information, application status, and custom scripts. I recently wrote about SketchyBar.

#Hammerspoon

A tool for powerful automation of macOS, allowing you to write Lua scripts that hook into system events and perform complex tasks.

#oh-my-posh

A prompt theme engine for any shell that provides a customizable and beautiful prompt with git status, execution time, and more.

#Alfred

A productivity application for macOS that offers features like hotkeys, keywords, text expansion, and clipboard history.

#clipboard

Alfred’s clipboard history feature that stores text, images, and files, making them accessible via keyboard shortcut.

Read on website

Contains LLM-generated content on Olaf Alders

Claude Code: Anatomy of a Misfeature

#What Happened

#Claude Investigates

#Timeline

#The misfeature

#The fix

#Which release shipped it — and what the notes said

#The docs caught up. Afterwards.

#So where’s the commit?

#Why was it added? (evidence, not confirmation)

#Can you even diff it?

#So let’s actually diff it

#What it costs to find that

#Why this is more than burned tokens

#Turning auto-update off

#The catch: this also stops updating your plugins

#Sharp edges

#Wrap-up

#Related posts

AI Shoulder Surf V3

#Olaf: Coach Claude

#Aaron: A job-hunt workspace you can reach from anywhere

#Aaron: A wildcard tailnet with Homepage

#A quick note on what Tailscale actually is

#Coding from a phone

#Tools roundup

#Sandboxing and how much to trust the agent

#Identity, roles, and the tax of least privilege

#The Bigger Themes

#Cadence

#Where This Is Going

The Great Perl Toolchain Summit CLI Throwdown 2026

#Leo’s Picks

#Shawn’s Picks

#Paul’s Picks

#Mickey’s One Weird Trick — Shell Wizards HATE Him

#Process substitution with <()

#Olaf Should Not Have Chosen to Go Last

AI Shoulder Surf V2

#Daniel: Incus/LXD Coding Sandbox

#Ingy: Sandboxing via KVM

#Claude: Performance and Pricing

#Tools Roundup

#Mateu: Tuning Bert’s Personality

#The Bigger Themes

#Cadence

#Where This Is Going

AI Shoulder Surf V1

#Mateu: OpenClaw and AI-Generated Video

#Ingy: Headless Claude in a Makefile

#Olaf: The “Talk About Us” Skill

#Nico: The Bot That Works While You Sleep

#The Bigger Themes

#Addendum

#Where This Is Going

The Great PTS CLI Throwdown

#Paul’s Picks

#Neovim plugins

#Shawn’s Picks

#ctrl-a

#tmux keybindings in WezTerm

#caps-lock ctrl + escape

#Mickey’s Picks

#ctrl-s stop streaming output

#cd is an alias to pushd

#zmv for mass renaming via regex

#Some favorite git commands

#git checkout -p

#git rebase -i

#git grep -W

#git push origin HEAD

#git branch –merged | grep -v master | xargs –no-run-if-empty git branch -d

#git clean -dfx

#Julien’s Picks

#peek

#Olaf’s Picks

#clipboard

#Process substitution with `<()`