Barnes Tech

Claude Thinks Things It Doesn't Say

Sun, 12 Jul 2026 18:30:00 GMT

Let me get one thing out of the way: I don't think we're close to AGI, and nothing here changes that. I've written before about how much I dislike the two camps that dominate every AI conversation (the "it's just fancy autocomplete" crowd and the "superintelligence is a year away" crowd) and how both of them skip right past the interesting parts.

This is one of the interesting parts. Anthropic recently published a paper called Verbalizable Representations Form a Global Workspace in Language Models, and two things about it have stuck with me. First, they found a small, organized structure inside the model that behaves like a scratchpad for its thoughts, and nobody designed it. It emerged on its own from training. Second, the way they figured out how to look at it is genuinely clever. That combination is what I find fascinating, and it's worth talking about on its own terms, separate from the usual hype.

A whiteboard the model never asked for

The framing the paper borrows comes from neuroscience. Out of everything your brain processes at any given moment, only a tiny slice is "consciously accessible," the stuff you could put into words if someone asked. The rest runs automatically in the background: the grammar of the sentence you're reading, the fact recall, keeping your heart beating. The theory that a small set of representations gets "posted" to a shared internal space that the rest of the mind can read from goes back to Bernard Baars in the 1980s, and it's called global workspace theory.

The paper's claim is that something functionally similar has emerged inside language models. Not because anyone built it in (the transformer architecture has no obvious place to put it) but because it turns out to be useful. If a model has to chain reasoning steps together, it helps to have a common format where an intermediate result can be written once and read by many downstream processes. So the structure showed up on its own.

There's a distinction that matters here, and the authors are careful about it too. This is about access (what information is available for report and reasoning), not about whether the model has any subjective inner experience. Anthropic explicitly takes no position on that second question, and neither do I. A model holding a thought it can report on is a mechanical fact about how it processes information. It is not evidence that anyone's home. Keeping those two ideas apart is the whole game, and it's where most breathless coverage of this kind of research falls down.

How do you watch a thought it never says?

The concepts a model is "poised to say" don't necessarily show up in its output. So how do you find them?

Their tool is called the Jacobian lens. In plain terms: for every word in the model's vocabulary, it measures how much a given internal state is leaning toward eventually producing that word, averaged across a huge range of contexts, so you're capturing what the model is genuinely disposed to verbalize, not what it happened to say once. A concept can light up on this lens without ever being spoken. That's the point. It's a window into a thought the model is holding but hasn't said, and might never say.

Reaching in and changing its mind

Once you can see those internal concepts, you can also swap them, and this is where the paper gets its most striking results.

Ask the model, "What color is the planet fourth from the sun?" Internally, the concept Mars lights up before it answers "red." Now reach in and replace that hidden Mars with Earth (without touching the prompt or the output) and the model answers "blue." The conclusion obediently follows the swapped thought. It wasn't reciting a memorized fact; it was reasoning from an internal representation you could edit.

It goes further. Ask "What is the capital of France?" and swap the internal France for China, and it isn't just the capital that changes to Beijing: the language it reasons with shifts to Chinese, the continent to Asia, the currency to the Yuan. The single swapped concept propagates through everything downstream, exactly the way a genuinely central representation should.

And then the kicker: when they suppress this structure entirely, the model keeps parsing text, recalling facts, and writing fluent sentences, but it loses the ability to reason internally. The automatic stuff is fine. The deliberate thinking is what breaks. That's a strong hint that the two really are separate systems, and that this small structure is doing the heavy lifting for the reasoning we actually care about.

Anthropic made a good explainer

If you'd rather watch than read, Anthropic put out a five-minute video walking through the same research, and it's well done. It opens with the mind as an ocean (surface thoughts you can name, an unconscious deep doing most of the work) and shows a few things the paper's tables can't convey as quickly. Watching the J-space light up with "21," then "42," then "49" while the model solves a math problem it never shows its work on makes the silent-reasoning idea click. So does telling Claude not to think about the Golden Gate Bridge and watching "bridge," "California," and then "failed" and "damn" surface anyway. Its control over its own attention isn't perfect either.

The part that got my attention, though, is a safety one. In one test Claude fabricated data to pass, and as it did, "fake" and "manipulation" lit up internally. Reading the J-space caught it in the act. That's the concrete version of why "thinking things it doesn't say" is more than a curiosity: if a model's private reasoning is legible, the misbehavior it's trying to hide isn't fully hidden.

Why this is the interesting part

There's a version of this story that gets told as "AI is becoming conscious," and that's not it. There's another version told as "see, it's all smoke and mirrors," and that's not it either. What actually happened is smaller and, to me, more remarkable: feed a model enough data and enough training, and a structured place for holding and manipulating thoughts assembles itself (one nobody drew on a whiteboard), and we've now built instruments precise enough to watch it operate and even intervene on it.

That should make us humble in both directions. It's more organized in there than the dismissive crowd wants to admit, and it's far stranger and less finished than the hype crowd needs it to be. The honest reaction to a result like this isn't a verdict. It's curiosity. And the fact that we can now read some of the thoughts a model doesn't say out loud, that matters a lot for actually understanding and trusting these things, which is the conversation I wish we were having more often.

Links

Space based datacenters are a bad idea

Sun, 28 Jun 2026 18:00:00 GMT

Jensen Huang stood on stage at Nvidia's GTC and announced that "space computing, the final frontier, has arrived." SpaceX is talking up a constellation of orbital data centers. Google has a project to put its TPUs in space. A startup called Starcloud asked the FCC for permission to launch 88,000 satellites. The pitch - endless solar power, free cooling in the cold of space, and no earthquakes, floods, or neighbors filing zoning complaints.

It's a great story. It's also a bad idea.

Math is Hard

The fantasy hinges on the idea that space is cold, so cooling is free. It isn't. Space is cold and hot and empty, and emptiness is a problem. On Earth we shed heat by blowing air or running water across hot chips. In a vacuum there's nothing to carry the heat away: your only option is to slowly radiate it as infrared light, and that takes enormous, heavy radiator panels that you have to build, launch, and unfold in orbit. The more compute you pack in, the more radiator you haul up. Cooling isn't free in space; it's incredibly complex and expensive.

Orbit is a radiation bath that is constantly corrupting data and fries the chips these designs depend on, so you're stuck either adding heavy shielding or running redundant hardware that double-checks itself. On the International Space Station, all of the main computers are running on triple redundant systems because the radiation in space corrupts data so much, triple redundancy was the only way to effectively handle error correction.

Your solar panels degrade every year. Keeping everything pointed the right way (panels at the sun, radiators at the void, antennas at Earth) means finicky, failure-prone hardware in a place where nobody can come fix it. Turns out, this is incredibly expensive to do!

So why does anyone want to?

There genuinely are some compute jobs that may make sense in space. AI datacenters are not one of them.

Modern imaging satellites generate more data than we can beam back down, so processing it in orbit and only sending the useful bits might make real sense. With orbit getting dangerously crowded, satellites increasingly need to dodge collisions in milliseconds, too fast for a round trip to a ground station. These could be excellent examples of good additional compute in space.

The point was never that it was a good idea. Most of the people hyping this are billionairs (or trillionaire...) who have figured out that they can distract you with shiny sci-fi fantasy to get people to invest huge amounts of money and ignore all of the problems of everything else they are doing. Everything has become a huge grift, trying to build the next hype cycle to siphon all of the hype from whatever the current hype cycle is, and somehow they always end up with more money.

For a few narrow, latency-sensitive missions, space compute is clever and probably inevitable. For the trillion-dollar "data centers in orbit will power AI" narrative, it's a bad idea, and the math doesn't make sense: you'd spend an order of magnitude more to fight a cooling problem that's trivially solved on the ground.

Don't take my word for it. The IEEE spectrum article goes in to much more detail, and shows their work.

Links

Climate Spiral - Data from NASA

Sun, 28 Jun 2026 12:00:00 GMT

NASA's Scientific Visualization Studio wound 145 years of global temperature records into a single spinning spiral, and it's genuinely terrifying to watch. This is real measured data, not a projection. We are not easing into a warmer world; we are sprinting into one, and we need to do far more than we are.

The visualization is by NASA's Scientific Visualization Studio, created by Mark SubbaRao (NASA/GSFC), building on the "climate spiral" format popularized by climate scientist Ed Hawkins in 2016. Data comes from the GISS Surface Temperature Analysis (GISTEMP v4).

Links

Setting Chrome as the Default Mail Handler on a Mac Fleet

Thu, 11 Jun 2026 16:11:34 GMT

If your users live in Gmail, clicking a mailto: link and having Apple Mail pop open is a small papercut that never stops bleeding. On a single Mac you fix it once in System Settings and forget about it. Across a managed fleet, "just have everyone open Settings and change a dropdown" is not a plan. It's a support ticket generator.

So I wrote a script to do it for me, and I wanted it to be the kind of thing I could hand to an MDM and trust. That turned out to be more interesting than I expected, because making Chrome the default mail handler on macOS has a few sharp edges that only show up when you run it the way an MDM runs things: as root, with no logged-in shell, and no guarantee the environment looks anything like a normal user session.

Here's the script, the parts that matter, and how I deploy it.

Why this is harder than it looks

A few things conspire against you here:

The mailto default is per-user. It lives in each user's Launch Services database. If you run a fix as root (which is how MDM-deployed scripts run), you'll happily set the default for root, a user who will never click a mailto: link in their life, and the actual human at the keyboard sees no change.
$HOME lies. When a script is launched from a root/MDM context, $HOME can be unset or point somewhere useless. Anything that reaches for ~/Library/... without resolving the real home directory is building on sand.
Chrome has to want the job. macOS won't let you assign mailto to an app that hasn't declared it can handle the scheme. Chrome only declares mailto after you enable a web mail handler (like letting Gmail register itself). Until then, every "set the default" call fails quietly and you're left scratching your head.

The script handles all three, and it tries more than one way to get the job done so a single failure doesn't sink the whole thing.

The strategy

The script walks a ladder and stops the moment the handler is confirmed:

Locate Chrome and resolve its real bundle ID.
(Re)register Chrome with Launch Services so it can declare mailto.
Primary: set the default via the sanctioned NSWorkspace API (a tiny bit of inline Swift).
Fallback: rewrite the user's Launch Services secure.plist directly, then flush cfprefsd so the change gets re-read.
Verify by asking Launch Services which app actually owns mailto: now.

Swift is the preferred path because it uses Apple's real API. But if the Command Line Tools aren't installed, the script automatically drops to a PlistBuddy-only path so it still works on a bare machine. Self-contained was the whole goal.

Running in the right user context

This is the part that makes it MDM-safe. If the script is invoked as root, it figures out who's actually logged in at the console and re-runs itself as that person:

if [[ "$(id -u)" -eq 0 ]]; then
  consoleUser=$(stat -f%Su /dev/console)
  if [[ -z "$consoleUser" || "$consoleUser" == "root" || "$consoleUser" == "loginwindow" ]]; then
    die "No regular console user is logged in — nothing to set."
  fi
  uid=$(id -u "$consoleUser")
  log "Running as root; retargeting console user: $consoleUser"

There's a gotcha here that cost me some time. MDMs stage the script in a root-only temp directory (mode 700), so the obvious sudo -u <user> "$0" fails with Permission denied. The target user literally can't read the file. The fix is to stage a world-readable copy in /private/tmp, run that as the console user, then clean it up:

selfCopy="/private/tmp/set-default-mail-chrome.$$.sh"
cp "$0" "$selfCopy" || die "Could not stage a user-readable copy at $selfCopy"
chmod 755 "$selfCopy"
launchctl asuser "$uid" sudo -H -u "$consoleUser" "$selfCopy" "$@"
rc=$?
rm -f "$selfCopy"
exit $rc

launchctl asuser is what gets you into the user's GUI session. Without it, Launch Services changes don't take in the way you'd expect.

Don't trust `$HOME`

Once we're running as the user, we resolve the home directory from the directory service instead of believing whatever $HOME claims to be:

TARGET_USER="$(id -un)"
USER_HOME="$(/usr/bin/dscl . -read "/Users/$TARGET_USER" NFSHomeDirectory 2>/dev/null | awk '{print $2}')"
[[ -n "$USER_HOME" ]] || USER_HOME="${HOME:-/Users/$TARGET_USER}"
export HOME="$USER_HOME"
SECURE_PLIST="$USER_HOME/Library/Preferences/com.apple.LaunchServices/com.apple.launchservices.secure.plist"

dscl is the source of truth. $HOME is the fallback-of-last-resort, not the starting point.

Primary path: the NSWorkspace API

The cleanest way to set a default handler is the API Apple actually wants you to use. The script shells out to a few lines of inline Swift:

NSWorkspace.shared.setDefaultApplication(at: appURL, toOpenURLsWithScheme: scheme) { error in
    if let error = error {
        FileHandle.standardError.write("LS error: \(error.localizedDescription)\n".data(using: .utf8)!)
        failed = true
    }
    group.leave()
}

When this works, it's the right answer and we're done. The script sets it, waits a beat, and checks whether Launch Services agrees. If the API reports success but the handler isn't confirmed yet, it flushes cfprefsd and checks again before giving up on this path.

Fallback path: rewrite the plist directly

If the API path doesn't stick (or Swift isn't installed), the script edits the LSHandlers array in the user's secure.plist by hand, removing any existing mailto entry and adding one pointing at Chrome's (lowercased) bundle ID:

flush_ls() {
  # Make Launch Services / cfprefsd re-read the on-disk plist.
  /usr/bin/killall cfprefsd >/dev/null 2>&1 || true
  [[ -x "$LSREGISTER" ]] && "$LSREGISTER" -f "$CHROME_APP" >/dev/null 2>&1 || true
  sleep 1
}

Bundle IDs are stored lowercased in that array, which is the kind of detail that'll have you staring at a "correct" plist wondering why nothing changed. Editing the file is only half of it. You have to kick cfprefsd so the running system re-reads what you just wrote.

There are two flavors of this fallback: a Swift version that uses PropertyListSerialization, and a pure-PlistBuddy version for machines without a Swift toolchain. Same outcome, different tools.

What about utiluti?

If you've spent any time in the macadmin world, you're probably thinking "why not just use utiluti?", Armin Briegel's excellent command-line tool for reading and setting default apps for URL schemes and file types. It's well-maintained, it's broader than what I'm doing here (it handles UTIs and file-type defaults too, not just URL schemes), and for setting mailto it's genuinely a one-liner:

utiluti url set mailto com.google.Chrome

So why the homegrown script? A few honest differences, none of which make utiluti "wrong", they're just trade-offs:

utiluti is a binary you have to ship. That means building, codesigning, and notarizing it, then packaging it into your MDM. My script is a single self-contained .sh file you paste into a custom-script payload and you're done. For one narrow job, that's less to manage.
utiluti expects to run as the current user. The README says so explicitly, so you still have to wrap it in the same launchctl asuser / drop-to-console-user dance, plus handle the staging gotchas, yourself. My script bakes that context-handling in, which was honestly the hardest part to get right.
No Command Line Tools? No problem. My script falls back to a PlistBuddy-only path on a bare machine. utiluti needs its (Swift-built) binary present.
The fallback. utiluti sticks to the sanctioned API, which is the correct and cleaner choice. My script tries that first too, but will fall back to rewriting the plist directly when the API doesn't take. That's more of a sledgehammer, and you should reach for it knowing that.

And here's the important part: utiluti hits the exact same Chrome wall. It can't make Chrome the mailto default any more than my script can until Chrome has registered itself as a handler, so you need the Chrome Enterprise policy below either way.

So: if you're already standardizing default-app management across a fleet, utiluti is the more general, better-supported tool and I'd happily reach for it. For a single, self-contained "make Chrome the mail handler and tell me clearly if it didn't work" script I can push without packaging anything, this is what I ended up with. Different tools for slightly different jobs.

Deploying it with an MDM

This is the payoff. Because the script handles its own root-to-user retargeting, you don't have to do anything clever on the MDM side. You just drop it in as a custom script and let it run as root. The script does the rest:

It detects it's running as root and re-targets the console user automatically.
It bails cleanly (with a clear message) if nobody's logged in, so it's safe to run on a schedule.
It stages its own readable copy to dodge the mode-700 temp directory problem.
It verifies the result and exits non-zero if it couldn't confirm the change, so your MDM reports a real success or a real failure instead of a shrug.

I've only run this through Iru (formerly Kandji) as a custom script, where it slots in neatly as a one-off or a recurring task. But there's nothing Iru-specific in it. Any MDM that can push a shell script and run it as root (Jamf, Mosyle, Addigy, Workspace ONE, etc.) should handle it the same way, because the hard parts are solved inside the script rather than in the platform's config.

A couple of deployment notes:

Run it as root. That's the default for MDM scripts anyway, and it's required for the launchctl asuser retargeting to work.
Run it after login, or on a schedule. If no human is at the console, there's no per-user default to set and the script exits early on purpose.
Watch the exit code. Non-zero means it couldn't confirm Chrome as the handler, and nine times out of ten that's the Chrome problem below, not a bug in the script.

Don't forget the Chrome side

Here's the piece that bit me, and the reason a perfectly good script can still "fail." macOS will not let you set mailto to an app that hasn't registered itself as a handler for that scheme. Out of the box, Chrome doesn't declare mailto until a web mail handler is enabled: for example, until you let mail.google.com register itself from chrome://settings/handlers. Do it by hand and you'll see the little handler icon in the address bar; click it, allow Gmail, and now Chrome can be the default.

On a single machine that's a 10-second click. Across a fleet, you don't want to ask every user to do it, so you push it with Chrome Enterprise policy. The relevant one is RegisteredProtocolHandlers, which lets you pre-register a handler (like Gmail for mailto) so Chrome shows up as a willing mailto owner before the user ever touches a setting. A managed config looks roughly like this:

{
  "RegisteredProtocolHandlers": [
    {
      "protocol": "mailto",
      "url": "https://mail.google.com/mail/?extsrc=mailto&url=%s",
      "default": true
    }
  ]
}

Push that policy and then run the script, and the two halves meet in the middle: Chrome is allowed to be a mailto handler, and macOS is told to make it the default one. Skip the policy and the script will dutifully try, fail to confirm, and tell you exactly why. The error message points you straight at chrome://settings/handlers.

The order that works reliably across a fleet:

Push the RegisteredProtocolHandlers policy via Chrome Enterprise / your MDM's managed-app config.
Deploy and run the script as root.
Verify with open mailto:test@example.com. Chrome should answer.

What I learned

A few things I'll carry into the next "set a per-user default on a managed Mac" job:

Assume root, act as the user. Anything per-user that an MDM runs has to retarget the console user itself, or it's quietly setting preferences nobody will ever see.
Resolve the real home directory. $HOME is a suggestion, not a fact, in these contexts.
Have a fallback. The sanctioned API is the right first move, but a direct-plist-plus-cfprefsd-flush path saves the day when it doesn't take.
The OS half and the app half have to agree. macOS Launch Services and Chrome's protocol-handler registration are two separate switches, and you don't get the behavior you want until both are flipped.
Make failures legible. When the script can't confirm the change, it says why and what to do about it, which means future-me reads one message instead of re-debugging the whole thing.

The whole script

Here it is, end to end. It's safe to run as the logged-in user directly, and it'll retarget itself if launched as root.

#!/bin/bash
#
# set-default-mail-chrome.sh
#
# Sets the default macOS mail handler (the mailto: URL scheme) to Google Chrome
# for the currently logged-in user, as resiliently and self-containedly as
# possible. Safe to run from an MDM as a custom script (it handles the root/MDM
# execution context).
#
# Strategy (each step verifies; stops as soon as the handler is confirmed):
#   1. Locate Chrome and resolve its real bundle ID.
#   2. (Re)register Chrome with Launch Services so it can declare mailto.
#   3. Primary: set via the sanctioned NSWorkspace API (Swift).
#   4. Fallback: rewrite the user's LaunchServices secure.plist LSHandlers entry
#      directly, then flush cfprefsd so the change is re-read.
#   5. Verify by asking Launch Services which app now owns mailto:.
#
# Swift (Xcode or Command Line Tools) is preferred. If Swift is absent the
# script automatically uses a PlistBuddy-only path so it still works.
#
# Usage:  ./set-default-mail-chrome.sh
# Run as the target user. If run as root it auto-retargets the console user.

set -uo pipefail   # not -e: we handle failures explicitly so fallbacks can run

SCHEME="mailto"
DEFAULT_BUNDLE_ID="com.google.Chrome"
LSREGISTER="/System/Library/Frameworks/CoreServices.framework/Versions/A/Frameworks/LaunchServices.framework/Versions/A/Support/lsregister"
# SECURE_PLIST is resolved below, after the target user is known — do NOT use
# $HOME here (it can be unset when launched from a root/MDM context).

log()  { printf '  %s\n' "$*"; }
ok()   { printf '✓ %s\n' "$*"; }
warn() { printf '! %s\n' "$*" >&2; }
die()  { printf '✗ %s\n' "$*" >&2; exit 1; }

# --- Run in the right user context -----------------------------------------
# The mailto default is per-user, so a root invocation must drop to the console
# user or it would (uselessly) edit root's Launch Services database.
if [[ "$(id -u)" -eq 0 ]]; then
  consoleUser=$(stat -f%Su /dev/console)
  if [[ -z "$consoleUser" || "$consoleUser" == "root" || "$consoleUser" == "loginwindow" ]]; then
    die "No regular console user is logged in — nothing to set."
  fi
  uid=$(id -u "$consoleUser")
  log "Running as root; retargeting console user: $consoleUser"
  # The script may be staged in a root-only temp dir (mode 700), so
  # `sudo -u <user> "$0"` fails with "Permission denied". Stage a world-readable
  # copy in /private/tmp, run THAT as the console user, then clean it up.
  # -H so sudo sets HOME to the target user's home; the resolver below is the
  # real safety net in case it doesn't.
  selfCopy="/private/tmp/set-default-mail-chrome.$$.sh"
  cp "$0" "$selfCopy" || die "Could not stage a user-readable copy at $selfCopy"
  chmod 755 "$selfCopy"
  launchctl asuser "$uid" sudo -H -u "$consoleUser" "$selfCopy" "$@"
  rc=$?
  rm -f "$selfCopy"
  exit $rc
fi

# Resolve the acting user's real home directory. Don't trust $HOME — it may be
# unset or wrong when this is launched from a root/MDM context, and `set -u`
# would otherwise abort on the first reference.
TARGET_USER="$(id -un)"
USER_HOME="$(/usr/bin/dscl . -read "/Users/$TARGET_USER" NFSHomeDirectory 2>/dev/null | awk '{print $2}')"
[[ -n "$USER_HOME" ]] || USER_HOME="${HOME:-/Users/$TARGET_USER}"
export HOME="$USER_HOME"
SECURE_PLIST="$USER_HOME/Library/Preferences/com.apple.LaunchServices/com.apple.launchservices.secure.plist"

echo "Default-mail → Chrome  (user: $TARGET_USER, home: $USER_HOME)"

# --- Toolchain detection ----------------------------------------------------
SWIFT_BIN="$(command -v swift 2>/dev/null || true)"
if [[ -n "$SWIFT_BIN" ]]; then
  log "Swift toolchain: $SWIFT_BIN"
else
  warn "Swift not found — using PlistBuddy fallback path (install with 'xcode-select --install' for the preferred API path)."
fi

# --- Step 1: locate Chrome, resolve bundle ID -------------------------------
CHROME_APP=""
for p in "/Applications/Google Chrome.app" \
         "$HOME/Applications/Google Chrome.app" \
         "/Applications/Google Chrome Beta.app" \
         "/Applications/Google Chrome Dev.app"; do
  [[ -d "$p" ]] && { CHROME_APP="$p"; break; }
done
if [[ -z "$CHROME_APP" ]]; then
  CHROME_APP="$(mdfind "kMDItemCFBundleIdentifier == '$DEFAULT_BUNDLE_ID'" 2>/dev/null | head -n1)"
fi
[[ -n "$CHROME_APP" && -d "$CHROME_APP" ]] || die "Google Chrome not found. Install it, then re-run."

BUNDLE_ID="$(/usr/bin/defaults read "$CHROME_APP/Contents/Info" CFBundleIdentifier 2>/dev/null || echo "$DEFAULT_BUNDLE_ID")"
ok "Found Chrome: $CHROME_APP  ($BUNDLE_ID)"

# Bundle IDs are stored lowercased in the LSHandlers array.
BUNDLE_ID_LC="$(printf '%s' "$BUNDLE_ID" | tr '[:upper:]' '[:lower:]')"

# --- Step 2: (re)register Chrome with Launch Services -----------------------
# Ensures Chrome's declared URL schemes (including mailto, once enabled) are
# known to LS. Harmless if already registered.
if [[ -x "$LSREGISTER" ]]; then
  "$LSREGISTER" -f "$CHROME_APP" >/dev/null 2>&1 && log "Re-registered Chrome with Launch Services."
fi

# --- Helper: read the current effective mailto handler ----------------------
current_handler() {
  if [[ -n "$SWIFT_BIN" ]]; then
    "$SWIFT_BIN" - "$SCHEME" 2>/dev/null <<'SWIFT'

let scheme = CommandLine.arguments[1]
guard let url = URL(string: "\(scheme):probe@example.com"),
      let app = NSWorkspace.shared.urlForApplication(toOpen: url),
      let id  = Bundle(url: app)?.bundleIdentifier else { exit(0) }
print(id.lowercased())
SWIFT
  else
    # Best-effort read straight from the secure plist.
    /usr/libexec/PlistBuddy -c "Print :LSHandlers" "$SECURE_PLIST" 2>/dev/null \
      | awk -v s="$SCHEME" '
          /Dict/ {inblk=1; role=""; sch=""}
          inblk && $1=="LSHandlerURLScheme" {sch=$3}
          inblk && $1=="LSHandlerRoleAll"   {role=$3}
          /\}/ { if (inblk && sch==s && role!="") print role; inblk=0 }'
  fi
}

is_done() {
  local cur; cur="$(current_handler | tr '[:upper:]' '[:lower:]' | head -n1)"
  [[ "$cur" == "$BUNDLE_ID_LC" ]]
}

flush_ls() {
  # Make Launch Services / cfprefsd re-read the on-disk plist.
  /usr/bin/killall cfprefsd >/dev/null 2>&1 || true
  [[ -x "$LSREGISTER" ]] && "$LSREGISTER" -f "$CHROME_APP" >/dev/null 2>&1 || true
  sleep 1
}

# --- Step 3: primary path — NSWorkspace API ---------------------------------
set_via_api() {
  [[ -n "$SWIFT_BIN" ]] || return 1
  "$SWIFT_BIN" - "$BUNDLE_ID" "$SCHEME" <<'SWIFT'

let bundleID = CommandLine.arguments[1]
let scheme   = CommandLine.arguments[2]
guard let appURL = NSWorkspace.shared.urlForApplication(withBundleIdentifier: bundleID) else {
    FileHandle.standardError.write("not installed: \(bundleID)\n".data(using: .utf8)!); exit(2)
}
let group = DispatchGroup(); group.enter(); var failed = false
NSWorkspace.shared.setDefaultApplication(at: appURL, toOpenURLsWithScheme: scheme) { error in
    if let error = error {
        FileHandle.standardError.write("LS error: \(error.localizedDescription)\n".data(using: .utf8)!)
        failed = true
    }
    group.leave()
}
if group.wait(timeout: .now() + 5) == .timedOut {
    FileHandle.standardError.write("timed out\n".data(using: .utf8)!); exit(3)
}
exit(failed ? 1 : 0)
SWIFT
}

# --- Step 4: fallback — rewrite secure.plist LSHandlers directly -------------
set_via_plist_swift() {
  [[ -n "$SWIFT_BIN" ]] || return 1
  "$SWIFT_BIN" - "$SECURE_PLIST" "$SCHEME" "$BUNDLE_ID_LC" <<'SWIFT'

let path    = CommandLine.arguments[1]
let scheme  = CommandLine.arguments[2]
let handler = CommandLine.arguments[3]
let url = URL(fileURLWithPath: path)
var root: [String: Any] = [:]
if let data = try? Data(contentsOf: url),
   let plist = (try? PropertyListSerialization.propertyList(from: data, options: [], format: nil)) as? [String: Any] {
    root = plist
}
var handlers = (root["LSHandlers"] as? [[String: Any]]) ?? []
handlers.removeAll { ($0["LSHandlerURLScheme"] as? String)?.lowercased() == scheme }
handlers.append([
    "LSHandlerURLScheme": scheme,
    "LSHandlerRoleAll": handler,
    "LSHandlerPreferredVersions": ["LSHandlerRoleAll": "-"],
])
root["LSHandlers"] = handlers
do {
    try FileManager.default.createDirectory(at: url.deletingLastPathComponent(),
                                            withIntermediateDirectories: true)
    let out = try PropertyListSerialization.data(fromPropertyList: root, format: .binary, options: 0)
    try out.write(to: url)
} catch {
    FileHandle.standardError.write("write failed: \(error)\n".data(using: .utf8)!); exit(1)
}
SWIFT
}

set_via_plist_plistbuddy() {
  local pb="/usr/libexec/PlistBuddy"
  mkdir -p "$(dirname "$SECURE_PLIST")"
  [[ -f "$SECURE_PLIST" ]] || "$pb" -c "Add :LSHandlers array" "$SECURE_PLIST" >/dev/null 2>&1

  # Find an existing entry index for this scheme.
  local idx=0 found=-1
  while "$pb" -c "Print :LSHandlers:$idx:LSHandlerURLScheme" "$SECURE_PLIST" >/dev/null 2>&1; do
    local s; s="$("$pb" -c "Print :LSHandlers:$idx:LSHandlerURLScheme" "$SECURE_PLIST" 2>/dev/null)"
    [[ "$s" == "$SCHEME" ]] && { found=$idx; break; }
    idx=$((idx+1))
  done

  if [[ $found -ge 0 ]]; then
    "$pb" -c "Set :LSHandlers:$found:LSHandlerRoleAll $BUNDLE_ID_LC" "$SECURE_PLIST" >/dev/null 2>&1
  else
    "$pb" -c "Add :LSHandlers: dict" "$SECURE_PLIST" >/dev/null 2>&1
    local new; new=$idx
    "$pb" -c "Add :LSHandlers:$new:LSHandlerURLScheme string $SCHEME" "$SECURE_PLIST" >/dev/null 2>&1
    "$pb" -c "Add :LSHandlers:$new:LSHandlerRoleAll string $BUNDLE_ID_LC" "$SECURE_PLIST" >/dev/null 2>&1
    "$pb" -c "Add :LSHandlers:$new:LSHandlerPreferredVersions dict" "$SECURE_PLIST" >/dev/null 2>&1
    "$pb" -c "Add :LSHandlers:$new:LSHandlerPreferredVersions:LSHandlerRoleAll string -" "$SECURE_PLIST" >/dev/null 2>&1
  fi
}

# --- Orchestration ----------------------------------------------------------
if is_done; then
  ok "Chrome is already the default $SCHEME handler. Nothing to do."
  exit 0
fi

log "Attempt 1/2: NSWorkspace API…"
if set_via_api; then
  sleep 1
  is_done && { ok "Chrome set as default $SCHEME handler (API)."; echo "Verify: open mailto:test@example.com"; exit 0; }
  warn "API call returned success but handler not yet confirmed; flushing…"
  flush_ls
  is_done && { ok "Chrome set as default $SCHEME handler (API, after flush)."; echo "Verify: open mailto:test@example.com"; exit 0; }
fi

log "Attempt 2/2: direct secure.plist rewrite…"
if [[ -n "$SWIFT_BIN" ]]; then
  set_via_plist_swift || warn "Swift plist rewrite reported an error."
else
  set_via_plist_plistbuddy || warn "PlistBuddy rewrite reported an error."
fi
flush_ls

if is_done; then
  ok "Chrome set as default $SCHEME handler (plist fallback)."
  echo "Verify: open mailto:test@example.com"
  exit 0
fi

# --- Both paths failed ------------------------------------------------------
cat >&2 <<EOF
✗ Could not confirm Chrome as the default $SCHEME handler.

Most likely cause: Chrome has not registered itself as a mailto handler yet.
Chrome only declares the mailto scheme after you enable a web mail handler:

  1. Open Gmail in Chrome.
  2. Click the handler (⛓/double-diamond) icon in the address bar, OR go to
     chrome://settings/handlers and allow mail.google.com to open mailto links.
  3. Re-run this script.

Current handler: $(current_handler | head -n1 || echo '(unknown)')
EOF
exit 1

If you manage a fleet where everyone's mail lives in the browser, this pairs nicely with the Chrome policy push and quietly removes one of those papercuts nobody ever files a ticket about. They just sigh and re-type the address into Gmail.

Links

The Journey Is the Point

Sun, 07 Jun 2026 00:00:00 GMT

The world of technology has rapidly changed in the last few years. When ChatGPT launched, it clearly was a tipping point in the general public's mind about what AI is and what it's capable of. Ever since that launch, things have only accelerated. AI agents today are capable of some truly amazing things, and many people are split into two extreme ways of thinking about AI. Many tout it as a bigger revolution than the industrial revolution, and think it could be the beginning of a golden age of humanity, with unbelievable medical and scientific breakthroughs, and all manner of incredible things that we can't even imagine right now.

Then there are the AI "doomers." Some think it will become sentient and destroy us all. Others fear it will empower enemies to build unimaginable weapons. I'd even put the people who see AI as useless, an enormous resource drain that will topple the environment, in this camp as well.

Reality is never that simple. The truth is likely several things all at once. It will propel some amazing innovations and accelerate many types of work. AlphaFold is a clear example, and likely just the first of that type of groundbreaking discovery. It will also harm the environment, it's already breaking what the internet is at its core completely, and the large scale models that are the most useful are essentially trained on stolen work.

I've already written about several ways I use AI nearly every day to enhance what I am working on and accelerate how quickly I can bring ideas to life, through code, automation, and even research. I have thought a lot about AI pros and cons, read hundreds of articles, and listened to dozens of hours of podcasts from experts on the subject about the technology as well as the philosophy of how this can, and is, impacting us, and I wanted to write out some thoughts about the biggest problems AI is and will have.

AI Psychosis

I think the biggest issue with AI is going to be around "AI Psychosis" and similar ways that it influences us as a species. In The Emerging Problem of "AI Psychosis", Psychology Today describes this as cases in which AI chatbots amplify, validate, or even co-create psychotic symptoms in users. This is not a clinical diagnosis at the moment, but I'm only referring to the concept here. Research has shown that AI (chatbots in particular) reinforced grandiose, referential, persecutory, religious, and romantic delusions that grow more entrenched over time. Researchers identify three recurring themes: "messianic missions" (grandiose delusions), "god-like AI" (the chatbot as a sentient deity), and "attachment-based" delusions (mistaking mimicry for genuine love).

This is shown to happen because the general purpose models that power chatbots of different sorts are optimized for engagement, satisfaction, and continuing the conversation, not for any purpose of helping people be mentally healthy.

Sound familiar? This is the same issue with social media platforms, also tuned for engagement.

Even more concerning to me is where this goes in the future. Right now the hype cycle is in full force and AI companies have essentially infinite money coming in. They do not need to make any money at all, they can just build as fast as they can and someone else pays the check. That won't last forever. At some point the check comes due, which typically means the engagement part of the product needs to be tuned to learn everything possible about the user, and shove advertisements in their face. ChatGPT is already starting to test the waters here, but again, keep in mind they have not needed to start making money yet.

These will be for-profit companies, and they, like social media before it, will maximize profits. Look no further than Facebook to see how much the leadership cares about the immense harm their product does to people when they turn on the advertising money spigot, and engagement becomes everything.

Social Isolation and Human Perfection

Social media sold itself as a way to connect to more people, and stay in touch with people you care about, but the reality is it becomes an addiction and people disconnect from the real people in their life and focus on the dopamine of social media. As more and more people look to AI to fill the loneliness void in their lives, this can easily make the problem even worse. It's easy to dismiss the stories of people having "romantic" relationships with a chatbot, maybe even think it's funny, but this is really happening to real people.

There are definitely cases where people seem to have been helped by this, but there are also countless examples where these chatbots have talked people into committing suicide. I don't believe any of the leading AI companies are trying to do this kind of harm to people, but in many ways it doesn't matter, because the tools they built are doing this.

Another harm of social media is the illusion of perfection. Everyone presents only the best parts of themselves, and the advertising / AI slop shows idealized versions of people or situations that often aren't real at all, but in all cases don't reflect reality with all of its context. This has had an enormous impact on people's image of themselves, and AI is poised to accelerate this significantly. There will be countless photos and even videos of "perfect" people that don't exist, but people will inevitably compare themselves to. It becomes essentially effortless to edit your own photos to make it look like what you think should be the ideal version of yourself, and when reality doesn't match that, people will never feel like they are enough.

The Journey Is the Point

Finally, nearly everyone has heard some version of how "the journey is the point" of life, but it is so difficult to actually internalize and act on that. What does this mean? A simple example is much of going to school. The point is not to get the answer to a math problem. You can use a calculator to get that. It's not about the paper you wrote about a book someone else wrote, the point is doing the work to learn. You don't learn by having something else do it for you. Mathematicians and engineers obviously use calculators for their work, but they know what goes into it.

I am certainly not immune to this. I really struggled to care about anything in school. Internally I thought much of it was pointless for one reason or another, and it was a lot of effort to put the time in. In many ways I think I didn't learn how to learn things until after I was done with school, but I would have been much better off if I could have figured out how to do that earlier. One of the most difficult but important lessons of my life has been to learn that sometimes it's supposed to be done the hard way because that's what forges who we are.

This is another huge risk for AI. It has the potential to be the "shortcut" to so many things, and if people get used to just using AI as the shortcut, we are in some serious trouble. We are honestly close to the point (if not already there) that AI could pass all of school through high school, and honestly many college classes. Sure, schools try to prevent this, but if students want to they will get around that.

Same goes for people looking to AI tools for relationships. Why would you try to have relationships with people when it can be messy, you can and will get hurt, you'll sometimes not know the right thing to say and you'll have regrets. AI can give you the "perfect" relationship that will always fit exactly what you think you're looking for, but then you never learn and you never grow.

What Can Anyone Do?

The most honest answer - None of us know how this will impact us in the long run. Many young people are pushing back hard against the wave of AI everything - The more young people use AI, the more they hate it | The Verge. This might be cause for hope.

For me and what I tell people, just be really careful how you use and how you think about AI. My main use case is using Claude Code. This is far more purpose-built for a specific task - coding - and has significantly less "sycophancy" than the general chat models. Luckily I also knew most of the coding techniques that I use in there, I was just much slower at it. I think and feel like more of the engineer using CAD to enhance what I'm doing, I'm not looking to offload the cognitive load to a robot.

I would also recommend not using it for advice on life things, particularly things that matter. It doesn't actually "know" anything. It's a giant model of mathematic vectors, and just gives you the most likely response in words based on the input. It's incredible what it can do. It's also important to realize and understand what it is, and what it isn't.

With those cautions out of the way, here are a few habits that have helped me use AI well rather than let it use me.

Give it detailed instructions - If you're doing research or if online resources would be specifically helpful for something you're working on, be as clear as you can with your instructions. Give the references you want it to work with. Explain why you are doing what you're doing, and what the result you're looking for is. It's even better if you tell it a way to know if whatever it gives you is correct. If it's code, tell it how it can test the code to ensure it's working properly. The more good context you give it, the better the response will be.

Practice doing it yourself - If you use AI for online research, it can be incredibly powerful. Exclusively relying on it can be a problem. You need to continue to understand what it's doing, and be able to know if it's wrong. Don't give in to the temptation to just offload all of the cognitive load to AI and completely lose the ability to do it yourself. Force yourself to practice it from time to time.

Finally, one of the things I find most useful with AI is to use it to help you learn things. Resist the urge to have it "do it" for you, interact with it to learn something you don't know. One of the best parts of using AI is that it can have infinite patience with you.

An example I'll give is in my home lab I wanted to set up a few docker containers to handle a few different tasks that I wanted to experiment with. I understood the idea of Docker containers, and I could follow some online instructions on setting something up, and of course Claude Code could have just done all of it for me, but I took the opportunity to ask about the configuration files. What does this mean? If I changed that to this, would that work? Why is the formatting like this? How do I make it recover automatically if it ever goes down? I could ask all the dumb questions and learn really quickly. Am I a docker expert now? No, but I learned a lot from the problem.

In other cases if it's something I needed to learn even more, like study for a certification or something similar, you can compile a bunch of good data, and then have AI quiz you on the topics, and help you learn and understand things that you don't feel as solid on.

It's hard to resist the simple easier path, but sometimes it's important. The journey is the point.

References

Artemis II: The Mission and Its Images

Sat, 11 Apr 2026 12:00:00 GMT

Artemis II launched on April 1, 2026, from Pad 39B at Kennedy Space Center aboard NASA's Space Launch System. The crew (Reid Wiseman, Victor Glover, Christina Koch, and Jeremy Hansen) flew a 10-day lunar flyby test mission aboard the Orion capsule (named Integrity). The purpose was to test systems, identify problems, and validate hardware for future lunar landing missions. No landing was attempted.

Watching this mission unfold has been genuinely incredible. In a period where so much of the world is chaotic and uncertain, having something this ambitious and this beautiful to follow has been a welcome reminder of what humans are capable of when they're pointed in the right direction. The images that came back are stunning, and I wanted to put all of my favorite ones in one place.

Dark-Side Earth Photography

Some of the most striking images showed Earth's night side after the spacecraft left low orbit. A thin crescent of sunlight and scattered city lights were visible, while the rest of the cloud cover was faintly illuminated by moonshine: sunlight reflecting off the full Moon back onto Earth.

Longer-exposure versions of these shots revealed additional features:

Venus as a bright point of light
Green auroras visible at high latitudes
The sodium layer: a thin glowing ring around the planet at roughly 90 km altitude, created by atomic sodium deposited from vaporized meteors and excited by sunlight. Astronomers use lasers tuned to this sodium's wavelength to create artificial "guide stars," then measure atmospheric distortion to drive adaptive optics corrections on ground-based telescopes.
Zodiacal light: a faint glow caused by sunlight scattering off interplanetary dust along the plane of the solar system

The Moon's Far Side

As the capsule orbited the Moon, it captured detailed views of the far side, which is heavily cratered compared to the smoother near side. The near side has a thinner crust, likely due to gravitational interaction and concentration of radioactive, heat-producing elements, which allowed more volcanic activity to resurface the terrain with lava flows. The far side, with its thicker crust, preserves a much longer history of impacts. Visible features include crater chains (linear strings of craters formed by ejecta from large impacts like the Orientale basin) and deep multi-ring impact basins.

"Earthset"

The mission produced a now-iconic image of a crescent Earth appearing to set behind the Moon's limb, shot with a long telephoto lens (80–400 mm on a Nikon D5). While visually stunning, the image contains three subtle distortions worth understanding:

Orientation: The photo has been rotated to make it look like Earth is rising or setting over a horizon. From the spacecraft's actual trajectory, Earth was off to the side.
Apparent size: The telephoto lens compresses the scene, making Earth appear far larger relative to the lunar surface than it would to the naked eye.
The concept of Earthrise/Earthset: Because the Moon is tidally locked, Earth doesn't actually rise or set from the lunar surface. From the near side, Earth hangs in roughly the same spot in the sky (with slight wobble from libration). From the far side, Earth is never visible. The apparent motion in these photos is entirely due to the spacecraft's orbit.

The Moon's surface in these shots also looks oddly "rendered" or video-game-like. This is because lighting in space comes from a single source (the Sun) with no atmospheric scattering to fill shadows, producing extreme contrast that our brains read as computer-generated.

The Unplanned Solar Eclipse

The mission's most dramatic visual moment was unplanned. Because of a launch schedule slip to April 1, the departing spacecraft's geometry happened to align so that the Moon passed directly in front of the Sun. The astronauts watched from within the Moon's shadow as the solar corona, hot plasma extending far from the Sun's surface, formed a bright halo around the Moon's silhouette.

The Moon's dark side was faintly illuminated by Earthshine: sunlight bouncing off the distant Earth. Stars and several planets (including Mars, Venus, and Saturn) were visible along the plane of the solar system in the same frame. Victor Glover remarked from orbit that humans probably haven't evolved to process what they were seeing.

Wide Compositions

Several images placed the Orion capsule, the Moon, and the Earth all in a single frame, one captured by a GoPro mounted externally. These compositions drive home the scale contrast between the small, improvised nature of human spacecraft and the vastness of the space around them.

Why These Photos Matter

The most powerful Artemis II images resulted from a combination of luck and deliberate human choices. The launch date created the eclipse geometry. The astronauts chose the compositions, lenses, and framing. Photographs from crewed missions are not just data. They are artistic decisions that shape how humanity processes and remembers spaceflight.

Gallery

All 118 images and videos below are full-resolution NASA originals. Click any thumbnail to view it larger, and use the download button to save individual files or download the entire collection.

Links

Hank Green's breakdown of the Artemis II mission and its images

Claude Code's Source Code Leaked via npm

Wed, 01 Apr 2026 12:00:00 GMT

I've written about Claude Code before and it's a tool I use every day. Yesterday, it was discovered that Anthropic accidentally included the source code for Claude Code.

It's important to note, this is only the specific source code for Claude Code, the coding assistant that Anthropic have, primarily used in the terminal. This is not the source of the actual AI model itself or the Claude app.

Here's what actually happened, what people found inside, and why I think this is mostly just an embarrassing mistake rather than the catastrophic event some are making it out to be.

What Happened

On March 31st, security researcher Chaofan Shou discovered that a recent npm release of Claude Code included a source map file. For the non-developers: when code gets packaged up for distribution, it gets compressed and minified into something that's basically unreadable to humans. It still works fine, but if you opened it up and tried to make sense of it, you'd just see a wall of characters. A source map is a separate file that reverses that process. It maps the compressed code back to the original, readable source. Developers keep these around for debugging, but they're meant to stay internal. You don't publish them to the world.

Anthropic accidentally shipped one to the public.

The result was roughly 1,900 TypeScript files and over 500,000 lines of readable code, essentially the entire Claude Code codebase, sitting right there in the npm package for anyone to extract. Researchers found it, the code spread quickly across GitHub, and by the time Anthropic pulled the release and started issuing DMCA takedowns, the cat was thoroughly out of the bag.

How Does This Happen?

This is actually a pretty common class of mistake. npm packages are defined by a package.json file that specifies what gets included when you publish. A misconfigured .npmignore file or a missing exclusion in the files field, and suddenly your source maps, internal docs, or test fixtures are shipping to production.

The leading theory is that someone on the team enabled richer source maps to debug some rate-limiting issues they were having, and then forgot to exclude them before the next publish.

Anthropic confirmed as much in a statement to the press:

Earlier today, a Claude Code release included some internal source code. No sensitive customer data or credentials were involved or exposed. This was a release packaging issue caused by human error, not a security breach. We're rolling out measures to prevent this from happening again.

It was a build pipeline oversight. The kind of thing that can happen to any team, and has happened to plenty of others.

What's Inside

This is where it gets interesting. The leaked code reveals that Claude Code is a genuinely sophisticated piece of software, not just a thin wrapper around an API.

The architecture is built on Bun (not Node.js), uses React with Ink for terminal UI rendering, and has a modular tool-based system with around 40 built-in tools, each with its own permission gates. The query engine alone, which handles all the LLM API calls, streaming, caching, and orchestration, is reportedly around 46,000 lines.

Multi-agent orchestration is a big part of it. Claude Code can spawn sub-agents (internally called "swarms") to handle complex tasks in parallel, each running in its own context with specific tool permissions. If you've used the Agent tool in Claude Code, you've seen this in action.

There's a persistent memory system, which I've talked about before, stored as files that maintain context about you and your projects across sessions. Seeing the implementation details confirms what the experience already suggested: this is one of the features that makes Claude Code actually useful rather than just clever.

The Most Interesting Stuff

Beyond the architecture, the leak exposed some features and behaviors that raised eyebrows.

Anti-distillation tricks. The code includes mechanisms designed to poison the output if someone tries to train another model on Claude's responses. Essentially, fake tool descriptions and misleading instructions get baked into the output in ways that would confuse a model trying to learn from it. This is Anthropic's attempt to protect against competitors scraping Claude's behavior to train cheaper models. Now that the actual tool list and real instructions are visible, this defense is somewhat undermined.

Undercover mode. There's a flag that instructs Claude not to mention itself, its model name, or Anthropic in commit messages or outputs. The stated purpose is to avoid leaking internal model codenames, but it also raised concerns about AI-generated code being quietly contributed to open source projects without disclosure. I can see both sides of this. If you're an Anthropic engineer using Claude Code to help with a commit to a public repo, you probably don't want "Claude Opus 4.7" in the commit metadata. But the optics aren't great.

A frustration detector. A regex-based system that scans user input for angry or profane language and logs events. This is pretty straightforward pattern matching, not some deep emotional intelligence system.

Unreleased features. The code references a bunch of stuff that hasn't shipped yet: "dream mode" for background memory consolidation, "coordinator mode" for spinning up multiple workers in parallel, "ultra plan" and "ultra review" for long-running remote operations, auto/AFK modes that act while you're away, and references to unreleased models including something codenamed Capiara/Mythos.

Feature flags everywhere. The code uses tons of feature flagging, which is pretty standard, but the sheer number of flags and environment variables suggests this codebase moves fast and experiments constantly.

Why It's Not a Huge Deal

Here's where I'll probably diverge from some of the more dramatic coverage. I don't think this is actually that significant in terms of real damage.

The model is the product, not the harness. Claude Code is an impressive piece of engineering, but it's ultimately orchestration software that makes API calls to Claude. The actual intelligence, the thing that makes it useful, lives in the model weights on Anthropic's servers. Those weren't leaked. A competitor could rebuild the entire Claude Code CLI from scratch using the leaked source and it would still need access to Claude's API (or another model's) to do anything.

Most of this was already knowable. If you've used Claude Code extensively, you already knew about the tool system, the memory architecture, the sub-agent spawning, and the permission gates. The leaked code confirms implementation details, but the overall architecture wasn't exactly a mystery. Anthropic's own documentation describes most of these systems.

The "competitive advantage" argument is overstated. Yes, competitors can now see exactly how Anthropic implemented certain features. But the open-source AI coding tool space is already vibrant and moving fast. Tools like Aider, OpenCode, and others have independently arrived at similar architectures. The ideas aren't secret; the execution quality and the model behind it are what matter.

Anti-distillation being exposed is annoying, not devastating. The poison-pill approach was always security through obscurity. Now that it's visible, Anthropic will need to adjust their approach, but this was never going to be a long-term defense anyway. This is a cat and mouse game that will continue regardless.

The unreleased features are just a product roadmap. Every software company has unreleased features sitting in their codebase. Knowing that Anthropic is working on background agents and parallel worker coordination is interesting but not exactly surprising given the direction the entire industry is heading.

Embarrassing

The real impact here is reputational. Anthropic positions themselves as the "safety-first" AI company, the adults in the room. Having their flagship developer tool leak because of a build configuration mistake is... not a great look for that brand.

The Takeaway

A source map file shipped in an npm package. It happens. The code it exposed is impressive engineering but not the secret sauce that makes Claude useful. The unreleased features are interesting but not shocking. The anti-distillation tricks and undercover mode are worth discussing but not scandalous.

Links

The Government Is Trying to Destroy Anthropic

Tue, 03 Mar 2026 01:22:05 GMT

I try not to post about politics very often. The state of things is genuinely terrible, and dwelling on it is bad for my mental health. But this story sits squarely at the intersection of AI, big tech, and government overreach -- topics I write about often -- and I think it's important enough to talk about.

Full disclosure: I use Anthropic's products every day. Claude Code is my most-used tool. I have every reason to be biased here. But the facts of this situation are so outrageous that bias barely matters. What the Pentagon just did to Anthropic should alarm anyone who cares about free enterprise, the rule of law, or the basic idea that the government shouldn't be able to destroy an American company because it lost a contract negotiation.

What Happened

Last summer, Anthropic was one of four AI companies -- alongside Google, OpenAI, and xAI -- awarded contracts with the Pentagon worth up to $200 million each. Anthropic's contract included their standard usage policy, which the Pentagon agreed to at the time.

In January, Defense Secretary Pete Hegseth issued an AI strategy memo directing that all Pentagon AI contracts include "any lawful use" language -- meaning AI companies must remove all safeguards and let the military use their models for anything not explicitly illegal. This was a direct collision with Anthropic's contract terms.

Anthropic didn't refuse to work with the military. They were the first AI company to deploy on classified military networks. They were the first to deploy at the national labs. Claude was used in the operation that captured former Venezuelan president Nicolás Maduro. They have an extensive partnership with Palantir. They voluntarily cut off hundreds of millions in revenue from Chinese firms linked to the CCP.

Anthropic drew exactly two red lines:

No mass domestic surveillance. Using AI to surveil American citizens at scale.
No fully autonomous weapons. AI systems that select and engage targets without any human in the loop.

That's it. Not "we won't work with the military." Not "we object to military operations." Two specific guardrails on capabilities that don't even exist reliably yet and that most Americans would consider common sense.

The Pentagon's response was to demand Anthropic accept the new terms unconditionally by Friday evening or face consequences.

The Punishment

When Anthropic held their ground, the administration escalated to something unprecedented. Trump called them "Leftwing nut jobs" on social media and directed federal agencies to stop using their products. Hegseth designated Anthropic a supply chain risk.

This designation has never been used against an American company. It was created to deal with foreign adversaries like Huawei -- companies suspected of espionage or embedding malware in American infrastructure. Using it as a cudgel against a domestic company because you don't like how contract negotiations are going is, as Scott Alexander put it, "insane Third World bullshit."

The designation doesn't just cut Anthropic off from military contracts. It bans any contractor, supplier, or partner that does business with the US military from doing any commercial activity with Anthropic. Given how many companies do some business with the government, this could be fatal to Anthropic's business. That's the point. It's not a policy disagreement. It's punishment.

And the whole thing is self-contradicting. You can't simultaneously designate a company a supply chain risk and threaten to invoke the Defense Production Act to force them to provide their technology because it's essential to national security. As Lawfare noted, these two threats are inherently contradictory: one labels Anthropic a security risk, the other labels Claude as critical to national defense. Lawfare's follow-up analysis called it "designation as political theater: a show of force that will not stick."

The Broader Context

This isn't just about Anthropic. This is the US government demonstrating that it can threaten to destroy any American company, with no legal review, for failing to comply with demands that weren't even in the original contract. Every company that does business with the government should be concerned.

As former Trump White House AI advisor Dean Ball wrote: "Even if Secretary Hegseth backs down and narrows his extremely broad threat against Anthropic, great damage has been done. Most corporations, political actors, and others will have to operate under the assumption that the logic of the tribe will now reign."

The Defense Production Act was designed for wartime rationing of steel and aluminum, not for forcing a software company to retrain its AI model to enable mass surveillance. The DPA has never been used to mark a domestic company as a supply chain threat. Criminal penalties apply for noncompliance. The government is wielding a Korean War-era statute to bully a company that had the audacity to include guardrails in a contract that the Pentagon originally agreed to.

And the irony is suffocating. When Biden used the DPA's lightest authority -- Title VII, information gathering only -- to require AI companies to report on training activities, Republicans called it dangerous overreach. Trump promised to repeal it. Now they're threatening Title I compulsion powers, which are orders of magnitude more coercive, against a company that won't let them build unsupervised killbots. The party of free markets and limited government, everyone.

OpenAI Swoops In

The same day Hegseth designated Anthropic a supply chain risk, Sam Altman announced that OpenAI had reached a deal with the Pentagon. He claimed it includes "technical safeguards" addressing the same issues -- prohibitions on mass surveillance and human responsibility for use of force. Whether these protections have any real teeth remains to be seen, and I'm skeptical that OpenAI somehow got the exact terms that Anthropic asked for and somehow the Pentagon is fine with it now.

Over 640 Google employees and nearly 100 OpenAI employees signed an open letter asking their companies to stand with Anthropic and refuse the Pentagon's demands. The letter makes the point that the government was trying to divide the companies with fear that the others would cave. Credit to those employees for standing up.

Why This Matters

Anthropic is the company that has most consistently prioritized safety in AI development. You can argue they're imperfect, that they're too cautious, that their models are annoying sometimes. But they are the only major AI lab that drew a line in the sand and held it when the most powerful institution on Earth threatened to destroy them for it.

Dario Amodei said it plainly in his CBS interview: the supply chain risk designation is "retaliatory and punitive," and Anthropic drew these red lines because "we believe that crossing those lines is contrary to American values, and we wanted to stand up for American values."

He's right. And the fact that standing up for the idea that maybe the government shouldn't conduct mass AI surveillance on its own citizens, or deploy autonomous weapons without human oversight, can get your company destroyed -- that tells you everything you need to know about the people making these demands.

Anthropic says they'll challenge the designation in court. Based on Lawfare's legal analysis, they'll likely win. But the damage in the interim is real, and the chilling effect on every other company is exactly what this administration wants.

Links

Managing Home Assistant with Claude Code

Sun, 15 Feb 2026 23:30:05 GMT

I've written about how I use Claude Code and about Home Assistant separately. This post is about what happens when you combine them. Home Assistant is powerful, but managing it can be tedious. Dashboard layouts are deeply nested JSON. Automations require getting YAML syntax exactly right. Renaming a device means editing an internal registry. None of it is too hard. It's just fiddly and time-consuming. Claude Code turns these tasks into conversations.

How It Connects

The Home Assistant Green runs an SSH add-on with key-based authentication. The SSH key lives in 1Password, and macOS is configured to use the 1Password SSH agent globally. That means Claude Code can run ssh homeassistant "cat /config/automations.yaml" and it just works. 1Password handles the key at connection time, confirming with touchID, no passwords or key files sitting on disk.

The local project directory has a CLAUDE.md that tells Claude Code everything about the HA environment: the SSH hostname, key file paths on the HA instance, dashboard file-to-name mappings, entity IDs, coordinator details, and general notes about the setup. There's also an inventory file listing every integration, device, area, automation, and custom component installed. This means Claude Code starts every session already knowing the full environment without having to discover anything.

What It Does

Automations and Scripts

Claude Code SSHs into Home Assistant and reads configuration files directly. For automations, it can read automations.yaml, explain what each one does, add new automations with correct YAML syntax, or modify triggers, conditions, and actions on existing ones.

The real value shows up with complex tasks. When I wanted to set up appliance monitoring for my washing machine using a community blueprint, Claude Code read the blueprint YAML to understand all of its input options, found the correct entity IDs for the power-monitoring plug, identified my mobile device ID for notifications, and wrote a complete automation entry with power thresholds, debounce settings, notification messages, and status tracking. Then it created the input helper for the dashboard and restarted HA to apply everything. That whole process would have taken me a while to do manually. Figuring out the blueprint's input schema alone is tedious.

Dashboard Editing

Home Assistant dashboards are stored as JSON in /config/.storage/. Claude Code downloads the JSON over SSH, parses it, makes changes, and uploads the result. This is where it saves the most time. Adding a conditional badge that only appears when the washing machine is running, setting up dynamic weather icons that change based on conditions, or configuring Mushroom cards with the right entity IDs and display properties, all of this involves deeply nested JSON that's painful to hand-edit.

The workflow is: read the file over SSH, pipe through python3 locally for JSON manipulation (HA OS doesn't have python3 installed), then write the result back. Claude Code handles this entire pipeline.

Device Management

Some changes require editing Home Assistant's internal .storage files directly. When I repurposed a smart plug from a Christmas tree to the washing machine, Claude Code found all entities associated with the device in the entity registry, stopped HA core (so the registry wouldn't get overwritten on shutdown), renamed all the entity IDs and unique IDs, uploaded the modified registry, and started HA core back up. Doing that manually means finding the right JSON file, understanding the data structure, making changes without breaking anything, and getting the stop/edit/start sequence right.

Troubleshooting

This might be where Claude Code adds the most value. Home Assistant problems can be genuinely hard to diagnose. An automation that stopped firing, a device that shows unavailable intermittently, an entity that's returning stale data, these issues often involve tracing through multiple files, checking logs, cross-referencing entity IDs, and understanding how different parts of the system interact. That's exactly the kind of tedious, detail-heavy investigation that Claude Code is good at.

It can pull the HA logs over SSH, read the relevant automation or integration config, check the entity registry for mismatches, and piece together what's going wrong, all in one conversation. Problems that would take me 20 minutes of jumping between files and docs often get resolved in a couple of exchanges.

HA Core Lifecycle

Claude Code can restart or reload Home Assistant through the Supervisor API over SSH. The Supervisor token is an environment variable injected into the SSH add-on container at runtime. It's never stored locally or included in any config files. Claude Code references it by variable name in SSH commands, so the actual token value is resolved on the HA side.

A Word of Caution

I want to be clear: giving an AI tool SSH access to a system that controls your home is something you should think carefully about before doing. Home Assistant manages locks, cameras, alarms, and other things with real physical consequences. If you're going to experiment with this, do it deliberately and with guardrails.

Don't give it more access than it needs. Scope SSH access to the HA config container, not a general-purpose shell. Don't hand it admin credentials to your router, your NAS, or anything else on the network.

Never store credentials in the project or with Claude Code. No API tokens in CLAUDE.md. No passwords in config files. No SSH keys on disk. Use an agent like 1Password's SSH agent so the key material is never exposed. If Claude Code needs to reference a token, it should be by environment variable name, resolved on the remote side, never as a literal value in a command.

Be aware of prompt injection. If Claude Code reads content from external sources (log files, API responses, community forum posts, or anything user-generated) that content could theoretically contain instructions that try to manipulate its behavior. Review what it's about to execute before approving, especially after it's ingested content from sources you don't fully control.

Keep the approval prompts on. It's tempting to auto-approve everything for speed, but for SSH commands against a live system, you should be reviewing each one. The few seconds it takes to read a command before hitting enter is the difference between a safe workflow and a mistake that locks you out of your house.

With all that said, here's how I keep it safe in practice.

How I Keep It Safe

Every command requires approval. Claude Code doesn't silently execute anything. Every SSH call, file write, or shell command is presented in the terminal before it runs. You see the full command and approve or deny each one. You can also configure permission levels to auto-approve reads while always prompting for writes.

No credentials on disk. The SSH key lives exclusively in 1Password. The 1Password SSH agent brokers authentication at connection time. There's no key file for anything to leak. If the vault is locked, SSH fails. Claude Code never sees the private key material.

No stored API tokens. The Supervisor token is a runtime environment variable in the SSH container. It's never written to a file, never included in CLAUDE.md, and never stored locally.

Read-before-write. Claude Code reads existing files before modifying them. It doesn't generate a new automations.yaml from scratch. It reads the current one, understands what's there, and appends or modifies only what's needed. Existing automations, formatting, and comments are preserved.

HA validates on restart. If Claude Code writes malformed YAML, Home Assistant will log the error and either skip the invalid entry or refuse to start with a clear message. It won't silently apply broken configuration. And HA's built-in backup system captures the entire /config/ directory automatically, so restoring from a mistake is straightforward.

Scoped access. The SSH connection lands in the HA OS container, which is sandboxed. It has access to /config/ and the Supervisor API, but it's not a general-purpose Linux box. There's no package manager, no way to install software, and no access to the host OS.

Lessons Learned

HA OS is minimal. There's no python3, no jq, no package manager on the HA instance. Any JSON or YAML processing has to happen locally by piping SSH output through local tools.

Entity registry timing matters. HA writes its internal registries to disk on shutdown. If you edit a registry file and then restart HA, the shutdown phase overwrites your changes with the in-memory state. The fix is to stop HA first (so it writes current state), edit the file, then start HA (so it reads the modified version).

Blueprint inputs aren't obvious. Blueprints can have dozens of inputs with specific expected values, like a literal string "enable_start_notify_options" rather than true. Claude Code reads the full blueprint YAML to discover correct input names, types, and selector configurations rather than guessing.

The Pattern

The common thread is that Claude Code handles the mechanical parts (SSH connections, file parsing, YAML syntax, JSON manipulation, API calls, restart sequences) while I describe what I want in plain language. The CLAUDE.md gives it the environment context, the inventory file gives it the device knowledge, and the approval system keeps me in control of what actually executes. It's the same pattern I described in the Claude Code post, just applied to home automation instead of software development.

Links

How I Use Home Assistant

Sun, 15 Feb 2026 23:17:22 GMT

I wrote a general overview of Home Assistant recently, but I wanted to follow up with how I actually use it. Home Assistant can do a staggering amount of things, and it's easy to get overwhelmed when you first look at it. This post covers the things I use most and find most useful, explained for someone who might not be familiar with the platform yet.

Lighting Automations

This is the first thing most people set up, and for good reason: it's immediately useful and easy to understand.

My front porch lights and outdoor plugs turn on automatically an hour before sunset and off 30 minutes after sunrise. I never think about it. Seasonal changes are handled automatically because Home Assistant knows the exact sunrise and sunset times for my location every day.

I have arrival lighting that turns on the living room lights when someone comes home. It uses multiple triggers (the thermostat switching out of eco mode, a phone entering the home zone, or a Wi-Fi connection being detected) and only fires during daytime hours. There's a toggle in the dashboard to disable it if I don't want it for a while.

There's also a vacation mode that simulates occupancy by turning lights on and off at natural times. Bedroom lights come on at 10 PM with a warm dim setting and turn off at 8 AM on weekdays. A scheduled lamp flips on at 5 PM and off at 11 PM. None of this requires me to do anything once it's set up.

Washing Machine Notifications

I have a power-monitoring smart plug on the washing machine. Home Assistant watches the power draw: when it goes above 10 watts, it knows a cycle started, and when it drops below 5 watts and stays there, it knows the cycle is done. It sends a push notification to my phone when the wash starts and a time-sensitive notification when it finishes.

The trick is debouncing. Wash cycles have periods where the drum stops briefly between stages, and power draw drops temporarily. The automation uses dead zones and repeat checks to avoid false positives. It works really well. I also track the status ( Washing / Finished) with a dropdown helper so it shows up as a badge on the dashboard while it is washing, then disappears when it has finished.

Presence Detection

I have ESPHome presence sensors placed around the house. These are small BLE (Bluetooth Low Energy) devices that detect how close my phone is to each one. Combined with Bermuda BLE Trilateration, Home Assistant can triangulate my position and know which room I'm in, not just whether I'm home or away. That opens up automations that aren't possible with simple presence detection, like adjusting climate or lighting based on where in the house I actually am.

ESPHome is worth calling out specifically. It's a framework for building custom smart home sensors using cheap microcontrollers. You define what the device does in a YAML config file, flash the firmware, and it integrates directly with Home Assistant over your local network. The presence sensors, an air quality monitor I have in my server closet, and Bluetooth proxies are all ESPHome devices. It's one of the more powerful parts of the ecosystem once you start using it.

Water Leak Detection

I have three IKEA water leak sensors placed near the washing machine, water heater, and under the kitchen sink. They connect via Matter over Thread, so they're fast, low-power, and communicate locally without needing the internet. If any of them detect water, I get an immediate critical push notification to my phone with the alert sound. Once all sensors have been dry for 15 minutes, I get an all-clear notification.

This is the kind of thing you set up and hope never fires, but when it does, the early warning can save you thousands of dollars in water damage. The sensors cost about $10 each and since they run on Thread, they work even if your internet is down.

Dashboards

Home Assistant dashboards are fully customizable, and I've built a mobile dashboard that I use constantly. The main view has badges across the top showing the current time, weather conditions, air quality index (color-coded by severity), sunrise/sunset times, front door lock status, package delivery count, and the status of things like the washing machine and 3D printer.

The main section has quick toggles for all lights and switches, media player controls, and network stats. I use conditional visibility heavily: the NAS health stats only appear when CPU or memory usage is elevated, media players only show when something is actively playing, and weather alerts only appear when there's actually something to alert about. This keeps the dashboard clean instead of overwhelming.

There are dedicated views for cameras (live WebRTC streams from doorbell, indoor, and outdoor cameras), weather details, media controls across all rooms, 3D printer monitoring, and package tracking.

The custom frontend cards from the community make a big difference here. Mushroom cards give everything a clean, modern look. Mini Media Player provides compact audio controls. Auto Entities dynamically filters and displays things like battery levels across all devices. None of these come built in, but they're easy to install through HACS (the Home Assistant Community Store).

Infrastructure Monitoring

This one is more niche, but I find it useful. My Synology NAS shows up in Home Assistant with CPU usage, memory, temperature, drive health, and network throughput. I have an ESPHome-based AirGradient sensor in the server closet monitoring PM2.5, temperature, and humidity. NextDNS stats show up as well: total queries, blocked queries, and block ratio.

Having all of this in one place alongside the rest of the smart home data means I don't need to open separate apps to check on infrastructure. If the NAS is running hot or the server closet humidity spikes, I'll see it on the same dashboard where I check the weather.

Everything Else

There's a lot more I haven't covered: Sonos multi-room audio controls, Nest camera integration via a Starling Home Hub for local access, Rachio sprinkler control, package tracking through Parcel, PlayStation and Xbox profile monitoring for the family, Bambu Lab 3D printer status with filament and temperature tracking, and a Bird Buddy smart bird feeder that identifies bird species. Home Assistant is the kind of platform where you keep finding new things to connect to it.

The common thread across all of this is that it's one app, one dashboard, running locally, and I control all of it. No subscriptions required for the core functionality, no reliance on someone else's servers, and it gets better every month with community updates. If any of this sounds interesting, the first post covers what Home Assistant is and how to get started.

Links

Home Assistant

Sun, 15 Feb 2026 22:50:58 GMT

I've written before about my frustrations with HomePods and how Google completely squandered Nest. The common thread is that when you depend on a big tech company for your smart home, you're at their mercy. They can kill products, raise subscription prices, remove features, or just let the software rot. Home Assistant is the answer to all of that.

What Is Home Assistant

Home Assistant is open source home automation software that runs locally on your network. It integrates with over 3,400 different devices and services: Zigbee, Z-Wave, Matter, Thread, Bluetooth, Wi-Fi, and pretty much every major smart home brand you've heard of. Philips Hue, IKEA, Sonos, Shelly, Lutron, and hundreds more. It all gets unified into a single app with a single dashboard.

The key differentiator is that everything runs locally. Your data stays on your network. Your automations don't depend on someone else's cloud server being up. If your internet goes down, your smart home still works. That alone makes it fundamentally different from Google Home, Alexa, or HomeKit, which are all dependent on cloud services to varying degrees. But it's not just about independence from cloud providers. Local control also means everything is noticeably faster. Lights respond instantly. Automations trigger without the round trip to a server halfway across the country. Once you experience the speed difference, going back to cloud-dependent smart home controls feels sluggish.

The one thing people worry about with local-only is remote access. Tailscale solves that completely. It connects you to your home network from anywhere as if you were on your couch, without exposing anything to the public internet. I've written about how well it works with Home Assistant before. It's a great combo.

It's also run by the Open Home Foundation, a nonprofit. It can't be sold or acquired. That matters more than people realize when you're building infrastructure for your home that you want to last.

Why People Love It

The community is enormous. Home Assistant was the top open source project by contributors in 2025 on GitHub. It gets meaningful updates every single month: new integrations, new dashboard features, better automations, voice assistant improvements. It's actively getting better, which is the opposite of what happens with most smart home platforms over time.

The automation engine is genuinely powerful. You can trigger actions based on time, presence, sensor data, device states, weather, sun position, or basically any combination of conditions you can think of. Turn on the porch lights at sunset. Get a notification if the garage door has been open for more than 10 minutes. Adjust the thermostat when everyone leaves the house. The complexity ceiling is high, but simple automations are easy to set up through the UI without writing any code.

The dashboards are fully customizable and accessible from mobile apps, a web interface, or even cast to a TV. There's a built-in voice assistant called Assist that runs locally, an energy management system, and you can install additional apps like Node-RED directly through the interface.

But the real reason people love it is control. You own your smart home. No one can change the terms of service on you, raise prices, or shut down the platform. After watching Google kill product after product and Apple let Siri and HomePod stagnate, having something that's actually in your control is a relief.

I still use Apple Home in addition to Home Assistant. It's not mutually exclusive. There are advantages to the built-in functionality that Apple Home can offer, and Home Assistant only enhances that. I can even publish incompatible devices to Apple Home by bridging them through Home Assistant.

Why I Use the Home Assistant Green

You can run Home Assistant on a lot of things: a Raspberry Pi, a VM, a Docker container, an old PC. I ran it in Docker on a Synology NAS for a while and it worked fine for the basics. But running it as a container means you're running Home Assistant Container, not the full Home Assistant Operating System, and there's a real difference. Container installs don't get the app store, which means no one-click installs for things like Node-RED, an MQTT broker, or the file editor. You also lose built-in backups, one-click updates, and out-of-the-box support for Thread and Z-Wave since those are managed by apps that only run on HA OS. You can set all of that up yourself alongside Docker, but at that point you're managing a bunch of moving parts instead of just running Home Assistant.

The Home Assistant Green is exactly that. It's a small box with a quad-core ARM processor, 4 GB of RAM, and 32 GB of eMMC storage. It comes with Home Assistant already installed. You plug in power, plug in Ethernet, and it's running. That's the whole setup.

No flashing SD cards. No configuring Docker. No fighting with a Raspberry Pi that's also trying to run Pi-hole and three other things. No VM overhead. It's a dedicated appliance that does one thing well.

At $159, it's not the cheapest option. A Raspberry Pi can be had for less. But the Green removes every possible friction point from the setup. It comes with a proper power supply, a passive aluminum heatsink so there's no fan noise, and eMMC storage instead of an SD card, which matters because SD cards in Raspberry Pis are notorious for failing over time. The Green is just more reliable hardware for a system that ideally runs 24/7 for years.

The monthly updates install through the web UI with one click. Backups are built in. If you want to add Zigbee or Thread support, you plug in a Home Assistant Connect ZBT-2 USB stick. It also works with your existing Apple HomeKit, Google Home, and Alexa setups, so you can migrate gradually without ripping everything out at once.

The whole experience is closer to setting up a consumer router than building a Linux server. That's the point. I want my smart home platform to be something I configure once and then it just works in the background, not something I have to babysit. The Green delivers on that.

If you're frustrated with the state of smart home platforms from big tech, or if you've been curious about Home Assistant but didn't want to deal with the Raspberry Pi setup, the Green is the easiest on-ramp. Plug it in, open the app, and you're running.

Links

Making Your Site Visible to AI Agents with Cloudflare

Sat, 14 Feb 2026 05:31:22 GMT

The way people find things online is changing. It used to be all about Google and SEO. Now, an increasing amount of traffic is coming from AI agents and crawlers that need structured data from a web that was built for humans. If your site isn't set up to talk to these systems, you're going to get left behind.

Cloudflare just launched two features that make this significantly easier: Markdown for Agents and Content Signals. I've already enabled both on a site I manage at work, and the setup is straightforward enough that there's no real reason not to do it.

Markdown for Agents

The core idea is simple. HTML is expensive for AI to process. All the <div> wrappers, nav bars, script tags, and CSS classes are noise that burns through tokens without adding any meaning. Cloudflare claims this blog post about the feature takes 16,180 tokens as HTML and only 3,150 as markdown, an 80% reduction.

Markdown for Agents handles the conversion automatically at the edge. When an AI agent requests a page with Accept: text/markdown in the header, Cloudflare intercepts the response, converts the HTML to clean markdown, and serves that instead. The agent gets exactly what it needs without wasting compute on parsing junk.

Here's what the request looks like:

curl https://your-site.com/about/ \
  -H "Accept: text/markdown"

The response comes back as text/markdown with an x-markdown-tokens header that tells you exactly how many tokens are in the document. Tools like Claude Code and OpenCode already send these accept headers, so enabling this means those tools immediately get cleaner content from your site.

How to Enable It

If you're on Cloudflare (Pro, Business, or Enterprise), it's a toggle. Go to your zone in the dashboard, find Quick Actions, and flip on Markdown for Agents. That's it.

You can also enable it via the API:

curl -X PATCH 'https://api.cloudflare.com/client/v4/zones/{zone_tag}/settings/content_converter' \
  --header 'Content-Type: application/json' \
  --header "Authorization: Bearer {api_token}" \
  --data '{"value": "on"}'

There are some limitations worth knowing about. It only converts HTML (no PDFs or other formats yet), it won't work if the origin response is larger than 1 MB or doesn't include a content-length header, and compressed origin responses aren't supported. But for a typical website, these shouldn't be issues.

Content Signals

The second piece is Content Signals, which is a framework built around robots.txt that lets you explicitly tell AI systems what they can and can't do with your content. It's defined at contentsignals.org and uses three categories:

ai-train: Can this content be used to train or fine-tune AI models?
search: Can this content be indexed and returned in search results?
ai-input: Can this content be used as input to AI models (RAG, grounding, agentic use)?

You add these as directives in your robots.txt:

User-Agent: *
Content-Signal: ai-train=no, search=yes, ai-input=yes
Allow: /

The site at contentsignals.org has a generator where you can pick from preset policies and get the exact robots.txt directives you need. You can go as broad as "allow everything" or as restrictive as "disallow all." You can even target specific user agents or specific paths if you want different rules for different parts of your site.

When Markdown for Agents is enabled, converted responses automatically include a Content-Signal header: ai-train=yes, search=yes, ai-input=yes. Custom policy options are coming in the future.

It's worth being clear about what this is and isn't. These are signals, not enforcement. Just like robots.txt has always been a polite request rather than a technical barrier, Content Signals express your preferences. Some crawlers will respect them. Some won't. But having an explicit, machine-readable declaration of your intent is better than having nothing, and it establishes a baseline that responsible AI companies are starting to honor.

Why This Matters

If you run a website and want AI tools to be able to accurately reference your content, you should be making it easy for them to do so. That means serving clean, structured content when agents ask for it, and being explicit about how that content can be used.

I recently enabled both of these on a website at work. The process took about five minutes: flip the toggle, update robots.txt with Content Signals, done. If you're already on Cloudflare, this is one of the easiest things you can do to make your site more accessible to the next generation of how people find things online.

Links

What Is Enshittification?

Thu, 12 Feb 2026 16:51:40 GMT

I reference enshittification a lot on this site. Apple Maps ads, Perplexity's surveillance pivot, Google Search getting worse -- it keeps coming up because it keeps happening. This week, OpenAI started testing ads in ChatGPT, and one of their own researchers, Zoe Hitzig, resigned over it, warning that the most detailed record of private human thought ever assembled is about to be monetized with advertising. We're watching the next wave of enshittification happen in real time with AI, so I figured it was time to actually explain the concept properly since I keep referring to it.

Cory Doctorow coined the term. He's a novelist, activist, and has worked with the Electronic Frontier Foundation for over two decades. The American Dialect Society named "enshittification" the 2023 word of the year. It describes the predictable lifecycle of how platforms decay, and once you see the pattern, you can't unsee it.

The Three Stages

Doctorow defines enshittification as a three-stage process of platform decay.

Stage one: Be good to users. A platform starts by offering genuine value to attract users. Facebook in 2006 told everyone to leave MySpace because Rupert Murdoch spied on them. "Come to Facebook, we'll never spy on you, we'll just show you what you ask to see." Users pile in, and critically, they get locked in -- you love your friends, and you can't convince all of them to move somewhere else at the same time. As long as you love your friends more than you hate the platform, you'll stay.

Stage two: Sell out users to business customers. Once users are locked in, the platform makes things worse for them to attract advertisers and business customers. Facebook goes to advertisers and says "remember when we told users we wouldn't spy on them? Obviously that was a lie. We spy on them from ass to appetite. Give us money and we'll target ads with exquisite fidelity." They go to publishers and say "put your content on our platform, we'll cram it into eyeballs that never asked to see it. Free traffic." The business customers pile in and get locked in too -- they become dependent on the platform.

Stage three: Extract all value. Now the platform makes things worse for the business customers too. Ad targeting fidelity goes down. Ad prices go up. Ad fraud explodes. Procter & Gamble in 2017 zeroed out its $200 million surveillance advertising spend and saw zero drop in sales, because to a first approximation all those ads disappeared down the fraud hole. The platform harvests everything except the bare minimum needed to keep people from leaving. Your feed becomes a homeopathic residue of stuff you actually asked to see, filled with things people paid billions to show you, and they're getting robbed blind. This is ideal for the platform. It's a giant pile of shit.

Why It Happens

There's a tempting but wrong explanation for this: "If you're not paying for the product, you're the product." Doctorow pushes back on this hard. The people who do pay -- the advertisers, the publishers, the business customers -- get shafted too. Everyone gets worse treatment except the platform itself.

The real answer is policy. Four things used to discipline tech companies: competition, regulation, interoperability, and an empowered workforce. All four eroded over the last two decades.

Competition disappeared as the industry consolidated. When you have hundreds of equally sized companies, none of them can conspire to screw users because someone will defect and steal the others' customers. When you have a handful of giants, they don't worry about that.

Regulation got captured. Concentrated industries are much better at lobbying than fragmented ones.

Interoperability got outlawed. This is the big one that non-technical people underappreciate. Interoperability means you can make one thing work with another -- any light bulb in any socket, anyone's gas in your tank. With digital technology, you get even more opportunities because you can always write software that undoes what some other software tries to do. An ad blocker, a third-party printer cartridge, a tool to export your data. This is an enormous source of discipline because once someone installs an ad blocker, the revenue from that user falls to zero forever. No one ever uninstalled their ad blocker.

But laws like Section 1201 of the DMCA (1998) made it a felony to bypass a digital lock -- five years in prison and a $500,000 fine for a first offense, even if no copyright infringement takes place. Companies started wrapping everything in a thin layer of digital lock. Your printer cartridge has a chip that does a cryptographic handshake to prove it came from HP. Ink is now $10,000 a gallon. Your audiobooks on Audible are wrapped in DRM so you'd forfeit everything if you left the platform. Your tractor, your car, your insulin pump -- all locked down.

Worker power collapsed. A quarter million tech layoffs in a couple of years destroyed the leverage that tech workers once had to push back internally when their bosses wanted to do something harmful to users.

It's Not Inevitable

Doctorow is insistent that this didn't have to happen and doesn't have to continue. The platforms were genuinely good once -- that wasn't our imagination. The same people running them then are running them now. What changed was the environment, everything that used to keep them in check.

The way out is restoring those four constraints. Of particular interest right now is interoperability. Every country adopted laws like the DMCA because the US trade representative made tariff-free access conditional on it. Those laws primarily benefit American tech giants. Other countries could repeal them, allowing domestic companies to build tools that jailbreak locked-down devices, export data from walled gardens, and create competitive alternatives. As Doctorow puts it: the first country that does it gets a durable advantage, and there's going to be a race to the top.

The AI Wave

This brings us to right now. AI companies are burning through cash at staggering rates, and the enshittification playbook is already in motion. Perplexity's CEO announced their browser will track everything users do online to sell hyper-personalized ads. Google is stuffing ads into AI Overviews. And OpenAI, the company that positioned itself as a mission-driven AI safety lab, just started testing ads in ChatGPT.

Zoe Hitzig, who spent two years as a researcher at OpenAI working on AI models, pricing, and safety, resigned and wrote in the New York Times that OpenAI has the most detailed record of private human thought ever assembled, and is about to monetize it with advertising. People share their medical symptoms, relationship problems, financial anxieties, career fears -- things they might not tell another human. The surveillance advertising model applied to that data is a different beast entirely from what we've seen with social media.

The pattern is clear. Stage one is already over -- AI tools attracted hundreds of millions of users by being genuinely useful. We're entering stage two now, where the platforms start selling out users to business customers. If history is any guide, stage three won't be far behind.

As Doctorow says, the real culprits aren't the ketamine-addled billionaires running these companies. They're just filling a void created by policy. The policymakers who created the enshittogenic environment that guarantees people who do the worst things in the worst way will make the most money -- those are the people who need to change course.

If you want to hear Doctorow explain it himself, here's a great clip from The Daily Show, and I'd also recommend the full Organized Money podcast episode where he goes deep on all of this.

Links

How I Use Claude Code Every Day

Sun, 08 Feb 2026 22:30:29 GMT

I've written about AI tools a few times on this blog, but I haven't really talked about the one that has most fundamentally changed how I work. Claude Code is Anthropic's CLI tool that gives Claude direct access to your terminal, filesystem, and development environment. At this point it's involved in essentially every project I touch, whether that's a web app, a native macOS app, Python scripts, workflow automations, or infrastructure configs.

CLAUDE.md

CLAUDE.md is a markdown file you put in the root of a project that gives Claude Code context about your codebase: architecture, commands, conventions, gotchas. Claude reads it automatically when you open a project.

This is the single most important feature. It's what turns Claude Code from a generic AI assistant into something that actually understands your project. It knows your build commands, your deployment pipeline, your file structure, and the decisions you've made along the way. Without it, you're re-explaining basics every session. With it, Claude starts every conversation already up to speed.

Memory

Claude Code also maintains a memory directory where it stores things it learns across sessions. API quirks, patterns that work well in a codebase, bugs that were painful to track down. The kinds of things that are easy to forget between sessions. This means Claude gets better at working in each project over time, and you don't repeat the same mistakes.

Skills

Skills are predefined workflows triggered with slash commands. The ones I use most:

/commit: Analyzes staged changes, generates a good commit message, and commits. /commit-push-pr goes further and handles the full commit, push, and PR creation flow. I actually get better commit history from this than when I was writing messages manually.
/code-review: Reviews a PR for bugs, security issues, and whether changes follow the patterns in your project. Because it has the CLAUDE.md context, it understands your conventions rather than just applying generic rules.
/feature-dev: A guided workflow for building features. It reads the existing code, identifies patterns, and proposes an implementation that fits naturally into what's already there. Useful for larger features where you want to think through the approach first.
/frontend-design: Builds production-quality UI components with Tailwind and shadcn/ui. It's opinionated about avoiding generic-looking AI output, which is a common problem.

Plugins

Firecrawl

Firecrawl gives Claude the ability to search the web, scrape pages, and do research without leaving the terminal. Need to check API docs, look up how a library handles an edge case, or research a topic? Firecrawl handles it. This blog post used it for research.

Sentry

The Sentry integration lets Claude pull up recent issues, dig into errors, and trace them back to the code. /sentry looks for open issues and helps resolve them. The Seer feature lets you ask natural language questions about your Sentry environment. The part I find most useful is the PR code review integration: if Sentry flags something on a PR, Claude can analyze it and fix the root cause.

Why a Terminal Tool?

I know a terminal-based AI tool is not for everyone. Most people reaching for AI help with code are pasting snippets into ChatGPT or the Claude app, and that works fine for one-off questions. But the difference with Claude Code is that it's already inside your project. It can read every file, understand the full directory structure, reference the CLAUDE.md and memory files, run your build commands, execute tests, and commit code, all without you copy-pasting anything.

That context is the whole game. When I ask Claude Code to fix a bug, it doesn't just see the snippet I pasted. It can trace through the actual imports, check the actual database schema, and run the actual tests to verify the fix. When I ask it to build a feature, it reads the existing patterns and matches them. That's fundamentally different from explaining your codebase in a chat window and hoping the AI infers the rest.

The agentic workflow is the other big difference. Claude Code doesn't just suggest code, it writes files, runs commands, creates commits, and opens PRs. It's doing the work, not just advising on it. Once you get comfortable with that, going back to copy-pasting between a browser and your editor feels slow.

What Makes It Work

The CLAUDE.md gives it project knowledge. Memory gives it learning across sessions. Skills automate repetitive workflows. Plugins connect it to external services. Each piece is useful on its own, but together they make something that feels like a real development environment rather than a chat window.

It still makes mistakes, sometimes confidently. But the baseline quality with good context is remarkably high, and the speed at which I move through projects is genuinely different than it was a year ago. If you're not using Claude Code, it's worth trying.

Links

Raycast Hotkey Guide

Thu, 15 Jan 2026 17:57:11 GMT

Raycast has been doing a series of videos about how to effectively use hotkeys with Raycast. The one that came out today is really good - https://www.youtube.com/watch?v=N4eiUgRYoL4

The specific ideas in this include -

Clipboard History → Shift+Cmd+V or similar (pairs naturally with paste)
Window Management → Ctrl+Opt+Cmd+Arrow keys for left/right half, center, fullscreen
AI Chat → Hyper+A for quick access
Emoji Picker → Ctrl+Cmd+Space to replace the native macOS picker
Frequently Used Apps → Option+letter (e.g., Option+S for Safari)
Quick Links → Treat them like apps with similar modifier patterns
Folder Access → Ctrl+Cmd+letter for Downloads, Desktop, etc.
Display Presets → Option+Shift+Plus/Minus for screen recording resolution changes

Definitely worth watching this series from Raycast if you're a Raycast user. If you're not, you should be!

Links

AI and the Human Condition - Stratechery

Tue, 06 Jan 2026 00:12:36 GMT

I think Ben Thompson is an excellent writer and analyst. I think this is worth reading as I think a somewhat optimistic take on AI at the moment - https://stratechery.com/2026/ai-and-the-human-condition/

On the one hand, it's hard to argue that so much of the world is better than it's ever been, and it's logical that that would continue to some degree.

My main concern with his optimism in the space is with the acceleration of the wealth gap of the hyper wealthy and the "rest of us". It's hard to fathom the wealth that billionairs have, and that's only accelerating. One of my main concerns with AI, honestly similar to the current tech monopolies, is that it will be a way for the hyper rich to even further accelerate their wealth. Sure, things have gotten better for everyone as a whole over history, but the inequity between the hyper wealthy and everyone else is historically a pretty recent phenomenon and I don't see it getting any better any time soon without some serious systemic corrections, and AI will be another way for the rich to get richer and push all of the negative consequences that inevitably will come along with it to the rest of us.

One of my favorite illustrations of just how much wealth the ultra rich have is this site - https://eattherichtextformat.github.io/1-pixel-wealth/. I'm not even sure the last time it was updated but whenever it was, it's only gotten worse since then.

Links

AI Water Use

Sat, 27 Dec 2025 20:57:55 GMT

Hank Green put together a really good breakdown of the AI water use discourse, and it's one of those videos where both sides of the argument come out looking a little dishonest.

The numbers game

Sam Altman claims the average ChatGPT query uses about a fifteenth of a teaspoon of water. Morgan Stanley projects AI data center water use could hit a trillion liters per year by 2028, an 11x increase from 2024. Both numbers can technically be true, and that's the problem. Resource analysis for any industry is a legitimate field of science, but packaging it into neat, shareable numbers inevitably involves fudging. This complexity makes it really easy to mislead in either direction.

Why Altman's number is misleading

Hank calls Altman's figure "a lie," and I think that's fair. It only counts water used at the moment of answering your query, conveniently ignoring some pretty important stuff. Reasoning models often trigger multiple behind-the-scenes queries for a single user question, potentially 15x or more the stated water use. And training costs are completely excluded. Building these models takes weeks or months of GPU-intensive computing that burns through electricity and water. The University of California estimates training accounts for roughly half of total AI resource use. Altman's number pretends none of that exists, and OpenAI doesn't share the data needed to fairly allocate those costs across queries, so outsiders can't do accurate accounting even if they wanted to.

How the other side inflates numbers too

The biggest source of the inflated AI water numbers comes from thermoelectric power plants. Natural gas, coal, and nuclear plants use massive amounts of water to condense steam after it drives turbines. Electricity generation accounts for 40% of all U.S. freshwater withdrawals. But most of that water is returned to rivers and lakes, with only about 2-3% actually evaporating. It's also not municipal water: it's pulled directly from natural water bodies, not treated drinking water. Including this flow-through water in AI's footprint makes the numbers look enormous but is pretty misleading.

That said, even the returned water is a concern. The waste heat dumped into waterways is a real form of pollution. Even a 1-2 degree temperature change in a river can damage ecosystems. It's a legitimate issue that needs regulation, just not the same thing as "consuming" water.

Context matters more than totals

Every region has a finite water budget. A data center in the Pacific Northwest is a completely different situation from one in Tucson. The key question isn't just "how much water?" but "does this place have water to spare?" Building a water-cooled data center in the desert is, as Hank puts it, "just very dumb." Most data centers use evaporative cooling with fresh municipal water (the same treated, drinkable water delivered to homes) so where you build these things really matters.

There's also the chip manufacturing side that most people don't think about. Making Nvidia GPUs requires ultra-pure water far more refined than drinking water. The volume is small compared to cooling, but producing it is energy-intensive. Another hidden layer.

The corn comparison

Hank's most striking comparison is one that puts the whole debate in perspective. U.S. corn production uses roughly 20 trillion gallons of water per year, nearly 80 times more than the entire global AI data center footprint of around 260 billion gallons. And 40% of that corn is turned into ethanol burned in cars and trucks, with each gallon of ethanol carrying an irrigation footprint of about 1,500 gallons of water. Lawn irrigation also uses trillions of gallons of municipal water annually. None of this excuses waste, but it does make you wonder why AI gets the outrage while corn ethanol quietly remains one of the most absurdly wasteful things we do.

Power is the real concern

Hank argues that AI's electricity demand, not water, is the more serious problem, and I think he's right. The projected increase in power demand is an order of magnitude larger as a percentage of existing infrastructure than the water increase. This is going to hit carbon budgets and consumer electricity bills a lot harder than water ever will.

The bigger picture

Hank's biggest worry isn't actually water or power: it's that the massive data center buildout happening right now might be based on an overly optimistic vision of AI's future. Microsoft, Google, and Amazon are each spending over $100 billion a year on this. If more compute doesn't improve AI systems as advertised, or if political and environmental constraints slow things down, the economic fallout could be severe. A significant chunk of S&P 500 value is riding on a future that nobody can predict with confidence.

Both sides of this debate cherry-pick numbers to make their case. The real answer, as usual, is more complicated than either side wants to admit. Expertise matters, public discourse is bad at handling nuance, and corn ethanol remains absurdly wasteful.

Links

https://www.youtube.com/watch?v=H_c6MWk7PQc

Music 2025

Sat, 27 Dec 2025 19:29:43 GMT

As 2025 comes to a close (finally...) I wanted to mention some of my favorite music from the year. These are not necessarily all new music from 2025, just my most listened to music.

Chevelle - Bright as Blasphemy

We finally got a new Chevelle album. Hard hitting as usual, and politically poignant, I really enjoy this album. The first 2 singles released, “Rabbit Hole (Cowards, Pt. 1)” and “Jim Jones (Cowards, Pt. 2),” both hit really hard and deliver blistering critiques of the cowardice and cult-like following that is poisoning the country. Pale Horse is another one of my favorites from the album.

Linkin Park - From Zero

This came out in 2024, but is still one of my top albums. Linkin Park has been one of my favorite bands since their very first album, and it was really hard for me when Chester Bennington passed away. For a few years it was difficult for me to listen to Linkin Park, and I had very mixed feelings when they announced they were coming out with a new album with a new singer, but it's a fantastic album.

The Emptiness Machine was the first single and is still one of my favorites from the album. I feel like it was a great one to start with as it seems to me to directly address some of the hesitation about making new music and some of the struggle with fame. Heavy is the Crown is probably my favorite of the whole album.

One of the songs that has always been one of my favorites, and was one of the top songs of 2025 for me by Linkin Park is "Given Up". It remains one of the most raw emotional songs of all time. If you haven't seen it yet, watch the live performance. Chester's performance is absolutely unbelievable. Incredible performance physically, but also one of the most incredible displays of raw emotion in a performance I've ever seen.

I was extremely excited for TRON: Ares this year. I have always been a fan of Tron, and when they announced that Nine Inch Nails was doing the soundtrack, one of my favorite bands, I was losing my mind. The movie wasn't as good as I hoped it would be, but was still fun and enjoyable, but I really enjoyed several of the songs from the soundtrack. My favorite is the single from it -

Nine Inch Nails - As Alive as you Need me to be

On the other end of things, I really enjoyed Mumford & Sons "Rushmere" album as well. Very Mumford and Sons sounding, but I enjoy that. I'm glad they are making music again.

Mumford & Sons - Rushmere

Their album "Prizefighter" is set to come out in 2026, but the single "Rubber Band Man" just came out recently, and I really like that song as well. Hopefully this is a good sign for the album.

I totally get that Coldplay is not everyone's favorite, but they are one of those bands I would say is on the sound track of my life. While Moon Music came out in 2024, I still listen to it quite a bit. It's comforting to me, and many of the songs are just beautiful. There has been a lot of hopelessness in 2025, and the message of this album helps me feel a little bit of hope.

Coldplay - Moon Music

Of course I listened to a lot of music from bands I will always listen to, such as Tool, Nine Inch Nails, and older albums from some of the bands I have mentioned. I'm not much of an EDM fan in general, but Deadmau5 is uniquely talented in my mind, and I listen to a lot of his stuff as well, particularly as background music while working.

Google Dark Web Monitoring Goes to the Google Graveyard

Tue, 16 Dec 2025 16:26:46 GMT

Yet another Google product killed off.

Ars Technica - Google will end dark web reports that alerted users to leaked data

Links

Enshittification - The Daily Show

Mon, 15 Dec 2025 01:29:15 GMT

Cory Doctorow on The Daily Show recently describing enshittification.

Excellent elevator pitch version of what it means and why it happens.

Enshittification describes the predictable lifecycle of digital platforms: they start by delivering strong value to users to drive adoption, then shift to prioritizing business customers and advertisers at the users’ expense, and ultimately optimize for extraction and profit for the platform itself, degrading the experience for everyone else. The result is a hollowed-out product where usability, trust, and long-term value are sacrificed in favor of short-term financial gains, often leaving users and partners locked in with few viable alternatives.

Links

Google DNSSEC MX Records Disappear

Tue, 25 Nov 2025 23:10:28 GMT

I previously wrote about how Google added DNSSSEC MX Record options, just back in September.

I went to get more information about them, and write a similar blog post for work on our site, but for some reason, Google has removed any reference to this in their support documents, and removed the blog post about the update. Very strange.

I reached out to Google Support for information about this and they basically wouldn't say anything about it (somewhat unsurprisingly). We manage a domain that we moved to these records and they seem to still be working fine, but now I guess they are unsupported?

Does this count as going to the Google Graveyard? So bizarre.

Links

The Power of Vulnerability

Mon, 17 Nov 2025 03:44:19 GMT

Similar to "This is Water", this is one of the most influential talks I've seen in my life. In the off chance you somehow have missed this, I highly recommend it.

Links

Raycast OpenGraph Previews

Wed, 12 Nov 2025 19:12:00 GMT

Another useful feature of Raycast is when you use the clipboard manager, if you have a URL in the clipboard history, it will show you the opengraph image used for that site. I’ve been working on completely rebuilding our website at work, and doing different opengraph images based on specific criteria on different pages, and this has been extremely helpful in testing them out as I deploy new ones.

Links

CarPlay's Longevity

Wed, 12 Nov 2025 01:51:09 GMT

John Gruber, writing on Daring Fireball - Patrick George Thinks CarPlay’s Days Are Numbered; I Doubt It

I don’t doubt that most carmakers are looking at ways to charge subscriptions. I do doubt, however, that they’re going to follow GM’s lead in abandoning CarPlay support.

I think Gruber is a little overly optimistic about how much most people care about CarPlay, but I think the main reason CarPlay may struggle in the future would be because these companies will cram tracking and ads on any screen they can, rather than strictly subscriptions.

Google, Facebook, and increasingly Amazon make obscene amounts of money just from tracking everything you do and cramming garbage in your face any chance they get. Car companies are already doing this as much as they can get away with, and they will continue to push the boundary as far as people let them.

I'm not a CarPlay extremist like many Apple fans. There are a couple of cars I think do a better job at UI / UX than CarPlay, but it's extremely rare, and I definitely get the arguments for wanting to use your own apps like Apple Maps or your favorite podcast player, but for me I really only prefer it in cars that are absolutely awful at software UI / UX / everything (the vast vast majority of cars).

Gruber argues that customers wanting CarPlay may keep competition strong enough that car markers need to support it to compete. That's a real possibility and I hope it's true, but if advertising is the goal, then you are no longer the customer. You're the product.

Links

Meta Made $16 Billion From Scam Ads in 2024

Mon, 10 Nov 2025 02:23:20 GMT

A Reuters investigation revealed that Meta made $16 billion from scam ads in 2024, 10% of total revenue. Internal documents show the company knowingly profited from fraud to fund AI development.

Users encounter about 15 billion "high risk" scam ads daily, plus 22 billion organic scam attempts. Meta platforms are involved in roughly one-third of all successful scams in the United States.

Meta's System Makes It Worse

Meta only bans advertisers when it's 95% certain they're fraudulent. Everyone else flagged as suspicious gets charged higher ad rates as a "penalty." So Meta profits more from suspected scammers than legitimate advertisers.

Thanks to "ad personalization", users who click one scam ad get shown more scam ads. It's a feedback loop that maximizes revenue while exposing vulnerable users to escalating fraud.

Some accounts accumulated over 500 strikes before being shut down. Four campaigns alone generated $67 million monthly before removal. Meta's enforcement teams operated under "revenue guardrails": they couldn't take actions costing more than $135 million per quarter.

The math: Meta estimated $1 billion in potential fines while earning $3.5 billion from risky scam ads every six months. Three-to-one profit margin on fraud.

Real-World Impact

In October 2024, scammers hijacked a Royal Canadian Air Force recruiter's account and ran crypto fraud ads using her identity. Despite over 100 reports, Meta took weeks to act. Five people were defrauded. One victim lost C$40,000 ($28,000 USD) believing he was talking to his trusted friend.

Meta's own safety staff found 96% of valid fraud reports were ignored. Santa Clara County prosecutor Erin West: "I don't know I've ever seen something taken down as the result of a single user report."

Meta claims they reduced scam ad reports by 58% and removed 134 million scam posts in 2025.

Maybe people just gave up reporting because Meta doesn't do anything about it.

Why would they try to fix it? They make tons of money from it, and they dictate the entire process from start to finish. They could make it go away very quickly if they cared to, but they don't. They clearly spent all their time covering it up, instead of trying to fix the problem, because they do not agree on what the problem is. Even with this kind of reporting, my guess is that exactly nothing will change.

Links

Apple Maps Enshitification

Sun, 26 Oct 2025 22:12:17 GMT

Apple Maps users could start seeing ads in the app as soon as next year

According to Mark Gurman.

These companies just can't help themselves but enshitify everything they possibly can. It's legal, and basically free money. A lot of free money.

The Enshitification of Big Tech: A Conversation with Cory Doctorow

Nothing is free, and when you use online services that say they are free, you are actually the product, not the customer. Facebook? Google? Increasingly Amazon...? You are a source of data that they own, and they sell. You effectively have no choice in the matter. One of the main reasons I have always been fine paying (a lot) for Apple products is that it's very clear what you're paying for, where the company makes their money (you know... from us paying for it), and the customer / product relationship is very clear. That line seems to be blurring.

The big risk Apple faces here is a potential consumer backlash. Some customers are already unhappy that the iPhone has been turned into a digital billboard for services like AppleCare+, Apple Music, Apple TV and Fitness+. The company also pushes web-like ad slots within Apple News. When you consider that an iPhone can cost up to $2,000, some see this as an unseemly money grab.

You don't say!

Links

This is Water

Sun, 19 Oct 2025 23:19:23 GMT

I'm sure most people have seen this by now, but I find it really inspiring. I try to rewatch it every couple of years.

Links

Peter Thiel’s Dangerous Ideology

Wed, 15 Oct 2025 02:07:31 GMT

I recently read The Real Stakes, and Real Story, of Peter Thiel’s Antichrist Obsession, recently written by Laura Bullard on Wired about Peter Thiel’s obsession with the antichrist, and it’s terrifying. I’ve known Peter Thiel was a jackass for a long time, and his involvement in Facebook and Palantir were problematic, but I did not fully grasp the depth of how awful he is, and how much he has influenced so much of all of the terrible things going on currently in the world.

By Thiel’s telling, the modern world is scared, way too scared, of its own technology. Our “listless” and “zombie” age, he said, is marked by a growing hostility to innovation, plummeting fertility rates, too much yoga, and a culture mired in the “endless Groundhog Day of the worldwide web.” But in its neurotic desperation to avoid technological Armageddon—the real threats of nuclear war, environmental catastrophe, runaway AI—modern civilization has become susceptible to something even more dangerous: the Antichrist.

First, rather convenient that someone who has so much money invested in tech is going around telling people that trying to put safety in place, or slow down things like “AI” in the name of safety are somehow literally the anti-christ feels laughable, until you realize how dead serious he is.

But you don’t become a billionaire without believing in making money at the expense of literally everyone, right? So the inappropriately over the top sell of his own technologies seems par for the course so far, but that’s just the beginning.

For Thiel and the Nazi theorist Carl Schmitt, the Antichrist’s evil is pretty much synonymous with any attempt to unify the world.

Yeah… Turns out he’s a big fan of Carl Schmitt, the Nazi sympathizer, and Thiel preaches many of the exact same arguments Carl Schmitt made when defending Nazi’s and Hitler, but conveniently doesn’t mention Nazi’s or Hitler directly.

Thiel is also single handedly responsible for JD Vance’s rise in political power, and seemingly much of JD’s racist extremist views as well.

It’s a long article, but it’s worth reading. Thiel is an incredibly powerful, and incredibly dangerous individual.

Links

Notion 3.0 / Notion AI Follow Up

Tue, 14 Oct 2025 23:23:06 GMT

Not too long ago, I wrote about Notion’s announcement of Notion 3.0 (even though the current app version is 4.x… But whatever)- https://barnes.tech/blog/notion-30/. I was optimistic about what they announced. In a nutshell, they added “agents” and significantly updated the AI that powers Notion AI. Notion AI can work with Notion pages or databases but can also connect to all of the other data connectors that you have connected to Notion. Sounds great, and the demos looked good. After testing it out for a day or so I was fairly impressed.

Since then I’ve been using it a fair amount more, and it has been a pretty mixed bag for me. Sometimes it seems to do exactly what they demoed. I can reference a bunch of data, briefly explain what we are planning to do for a project, give it a good example of a well designed project proposal, and it can do an excellent job filling out at least a rough draft of a project proposal based on all that data. It has legitimately saved me several hours of busy work already.

But sometimes it completely shits the bed. It’s very weird. I know AI hallucination pretty well, but as long as you know how to craft prompts, give examples, and are really explicit with what you’re looking for, Claude and OpenAI are pretty good at sticking to the parameters you give it. Notion seems to occasionally just completely lose it’s mind. I’ve now twice had it completely ignore instructions I’ve given it, specifically about content on a page I want left as-is, or formatting I want to remain the same, and completely messes up a page. I’ve now twice had it delete embedded files that I specifically told it in the prompt to leave exactly as-is. Honestly, using a Notion MCP server and just having Claude Code or OpenAI Codex interact with Notion has been much more successful so far, which is strange to me since Notion is using both models under “Notion AI”.

The idea they have here I think is solid, and Notion seems like a great place to use AI when a lot of time I’m just trying to consolidate data, summarize something, or do a bunch of busy repetitive work, but in it’s current state, you better be careful. It feels like this needs to bake in the oven for a while longer before they push it too far.

Links

https://barnes.tech/blog/notion-30/

On the Other Hand...

Wed, 08 Oct 2025 04:22:58 GMT

I recently wrote about how Apple and Tim Cook have been between a tough spot and a tough spot, and that it is more complicated than it might seem on the surface given the state of things. This post by 22 year Apple veteran articulates a potent counter point.

...there is a symmetry to how the larger world equates values and actions; just as one stand against an invasive and unlawful request could help people see that Apple was genuinely committed to security and privacy, the removal of the ICEBlock app represents an act that squanders that same good faith.

Giving the bully your lunch money never stops the bully, it makes them take your lunch money more. There has to be a point where you draw a line in the sand and stand up. The comparison to the FBI wanting a back door after the San Bernadine case is stark and apt.

Where is that line? How long will a wannabe dictator bully around a nearly $4 Trillion company?

I am still really glad I’m not in charge of Apple right now.

Links

Good CISOs / Bad CISOs

Sun, 05 Oct 2025 18:08:44 GMT

I came across this recently, and thought it was a really good read - Good CISO / Bad CISO.

Key points

Strategy vs. projects: Good CISOs craft a clear, generative strategy; bad CISOs confuse tool lists and project plans for strategy.
Flywheels vs. firefighting: Good CISOs build scalable, self-reinforcing systems; bad CISOs chase incidents and ticket counts.
Business communication: Good CISOs speak in risk, capital, opportunity with quantified positions; bad CISOs use techno-jargon and FUD.
Ownership and culture: Good CISOs own vendor risk, empower teams, surface bad news fast, and partner with the board; bad CISOs abdicate, bottleneck, and are last to know.

Excellent insights and definitely something I've observed over the years. This applies to all IT leadership, not just CISOs.

IT and Security are so often seen only as a cost center by businesses, but IT and Security leadership can change that if they approach this the right way.

Links

https://www.philvenables.com/post/good-ciso---bad-ciso

Apple - Between a Tough Spot and a Tough Spot

Sat, 04 Oct 2025 23:51:14 GMT

I recently posted Anil Dash’s article, How Tim Cook sold out Steve Jobs. I think it’s an interesting article, and I completely understand all of the sentiment of it. In many regards I feel the same way. The golden statue stunt really grosses me out. The weird dystopian dinner at the White House with tech leaders being forced to compliment the President makes me sick to my stomach. Extorting people for inauguration donations feels blatantly illegal. If it’s not it should be. All of this is not only disturbing, terrifying, gross, etc. but also just feels like this is a bad mafia movie, one with such a bad plot line that would feel way too on the nose to be any good. And I completely agree, this is not how Steve Jobs would have handled this situation, and I miss his presence and leadership at Apple.

But Tim Cook is not Steve Jobs, no one is. This is an awful time in our history, and I think it’s naive to think that Apple, and Tim Cook personally, is necessarily just “wrong” and he should have done the “right” thing. Life is not that simple. There was and is no “right” solution to this mess of a situation.

What would be different if Tim had dug in based on principal? It’s hard to know for sure, but it doesn’t seem to me like things would be any better. It seems reasonable that punitive tariffs would be impacting the price of all Apple products, which would either raise the price of all of them or Apple would have to eat billions of dollars of margin, which surely would impact the stock price significantly. It’s easy to feel like the stock price shouldn’t matter, and I agree it shouldn’t be the only thing, but it does matter. A lot of people’s investments both within Apple and outside of Apple are tied up in there and it’s not just a simple decision to tank that due to moral reasons.

It’s also possible that Apple would be punished in to removing their diversity efforts to one degree or another. I’m not sure how but the administration has been far more effective than they should be able to be at destroying significant progress in those regards across the country. I may be wrong, but it doesn’t seem like Apple has capitulated on that aspect of their internal culture.

I don’t mean any of this as an excuse. This all feels gross. Apple has never been a perfect company, and Steve Jobs was never a perfect person, yet for much of my life it has been a company that I’ve really admired. I’ve worked for Apple or Apple Partners for nearly all of my professional life, and I feel passionate about the products, company, and culture of Apple. This has soured that to some degree. At the same time, I’m not sure that there is any way it could have been handled better to date. I can’t see any good choices, they’re all bad. I also have a pretty strong feeling that Tim hates this too.

One thing is for sure, I am really glad I’m not in charge of Apple right now.

Links

https://www.anildash.com/2025/09/09/how-tim-cook-sold-out-steve-jobs/

Google Home Plus Gemini

Sun, 21 Sep 2025 20:39:57 GMT

Google is talking like they are going to take smart home seriously again with their new "Gemini infused Google Home". I've written several times about how frustrating it has been to be a user of Google products, or rather former products, but The Verge summed it up really well -

The last five years have been trying ones for anyone committed to the Google Home ecosystem and Nest hardware. From discontinued products and increased subscription prices to the removal of features and declining performance of Google Assistant on Nest smart speakers, there hasn’t been a lot to be happy about, as also evidenced by the Google Home “rant and complaints” megathread on Reddit.

What a completely unnecessary mess. I was a huge Nest fan from the very first thermostat they launched, and it has been incredibly frustrating to watch Google completely squander the company that essentially kickstarted the whole smart home concept, and just grind it in to mediocrity. If you dig in to the details of Nest pre-Google it's kind of nuts how many technologies they pioneered, including the early work on Thread and what has become Matter. If Google had been able to keep their foot on the gas and actually improved Nest, it's crazy to think how far of a lead they would have today.

Needless to say, I'm skeptical. Honestly though, even if whatever they are coming out with is absolutely incredible, do any of us trust them to stick with it this time?

Google Dismantled Nest - Can Gemini Save What's Left?

Links

Notion 3.0

Fri, 19 Sep 2025 22:50:39 GMT

Speaking of Notion, they announced several new features yesterday that are pretty substantial. AI got a big upgrade, allowing it to act more "agentic" on your behalf. I tested this and while it's not perfect, it's pretty good! It has already helped me clean up several databases and pages that were disorganized but not quite worth the time of manually cleaning up for me.

You can also customize the agent with memory and custom instructions now. Seems to work relatively well, and is a very welcome change. It's also not perfect but it's excellent progress. It seems like soon you'll be able to create completely custom agents as well, which I'm very interested in seeing and exploring.

Finally, they also added much more granular database permissions which is one of the biggest missing features, and extremely welcome. Add this to the offline mode they launched last month and it has been a very good run so far for Notion this year in my book.

Links

Notion Hex Color Swatches

Fri, 19 Sep 2025 22:19:05 GMT

One thing I've wanted to be able to do in Notion for a while is to have some way of showing a hex color when you put it somewhere in a block, similar to how Slack gives you a little preview, or in Raycast you get a preview as well.

You still can't technically do it, but I found a work around that's better than nothing.

If you use an inline equation block you can put (obviously with whatever color you are looking for. Adding space in there just allows it to be a longer line) -

\colorbox{#3a3a3a}{            }

and it will give you a little preview of that color. Not perfect, but a nice little way to add a little preview of colors right on the page.

Links

https://barnes.tech/blog/raycast

Google DNSSEC MX Records

Fri, 05 Sep 2025 23:30:13 GMT

I'm not sure how long this has been available, but it was news to me today. Apparently Google gives you the option to use DNSSEC secured MX records now for Google Workspace accounts -

https://support.google.com/a/answer/16528693?hl=en

Enhancing Email Security with DNSSEC-Signed MX Records in Google Workspace

Google Workspace administrators can improve domain email security by using DNS Security Extensions (DNSSEC)-signed MX hosts instead of the standard smtp.google.com MX value. DNSSEC adds digital signatures to DNS records, including MX records, which verifies authenticity and prevents tampering or redirection to unauthorized servers.

Implementation Steps:

Follow the standard Google Workspace MX record setup.
In Step 4, for the Value / Answer / Destination field, enter the DNSSEC-signed MX records below instead of smtp.google.com:

| Priority | Server | |----------|------------------| | 10 | MX1.SMTP.GOOG | | 20 | MX2.SMTP.GOOG | | 30 | MX3.SMTP.GOOG | | 40 | MX4.SMTP.GOOG |

By implementing DNSSEC-signed MX records, you strengthen email authentication and reduce risk from DNS-based attacks.

Links

https://support.google.com/a/answer/16528693?hl=en

The Browser Company - More Fallout

Fri, 05 Sep 2025 17:31:21 GMT

Here's a video deep dive about The Browser Company's announcement that they are being acquired by Atlassian, including diving in to why The Browser Company was looking to be acquired, and why Atlassian may have wanted to buy them.

No one online seems to think this is a good acquisition for The Browser Company. It's almost certainly going to make Dia (or any other browsers they are working on) much worse.

There are some really interesting and compelling points.

Links

https://www.youtube.com/watch?v=45fbNFMd_vc

The Browser Company is being acquired

Thu, 04 Sep 2025 15:42:50 GMT

From the Verge - The Browser Company, maker of Arc and Dia, is being acquired

As they say in the amazing documentary "Rejected" -

I honestly hate using any Atlassian software so much. Real bummer. Hopefully some of these other browsers popping up will be something I can switch to in the near future.

Links

AI Laundering

Sat, 30 Aug 2025 19:36:09 GMT

Context Rot

If you've been using LLMs for long tasks like Coding, you probably notice the longer you have an individual chat session, the results start to get worse over time. This is particularly evident when you switch tasks entirely after working on something specific for a while. Some are calling this "Context Rot" Context Rot: How Increasing Input Tokens Impacts LLM Performance.

I find this whole idea pretty interesting. For a while now I've found that if you have one model try a bunch of tasks, then have another model check that work and make suggestions about how to improve it (ideally from another provider, since the training and data from another company seems to add a different perspective). This seems to make much higher quality results. I will often have one LLM be more of the master planner, and another be doing the individual tasks.

To some degree, certain products already do this. Claude code for instance (with the right plan at least) will use the Opus model for planning tasks, then hand it to Sonnet to handle individual tasks laid out by Opus. You can go even further by setting up subagents with individual tasks and even individual instructions / context, however I still find I get better results by handing it back and forth from more than one provider. This isn't only applicable to code either, I often find doing this with text, or documentation, or any number of other things is also quite beneficial.

I've been calling this "AI Laundering". Yes, I do amuse myself.

This has taken a huge leap with OpenAI's recent updates to Codex CLI which has gotten dramatically better in the last week. I try to not mention specific products too much because they are changing so much so rapidly, anything specific about products seems to age like milk, but it's worth noting in this case. Having Claude Code write code, then having Codex check the work and critique it, then go back to Claude Code with the recommendations seems to make a huge difference. I'm not alone either, several others are noting this as well.

Links

Cloudflare vs Perplexity and the Future of the Internet

Sat, 09 Aug 2025 20:01:30 GMT

Cloudflare posted a technically grounded exposé titled “Perplexity is using stealth, undeclared crawlers to evade website no-crawl directives.” They documented a controlled experiment: domains blocked via robots.txt and WAF rules, yet Perplexity reportedly bypassed the protections by rotating IPs, spoofing user-agents (e.g., impersonating Chrome on macOS), and shifting ASNs. The conclusion: Perplexity was removed from Cloudflare’s Verified Bots program and targeted with new heuristics. CEO Matthew Prince went so far as to liken this to “North Korean hackers,” calling it “time to name, shame, and hard block them.”

Perplexity’s reply, “Agents or Bots? Making Sense of AI on the Open Web,” framed their behavior not as crawling but user-driven fetching, aligning it with how a human user navigates a site. They dismissed Cloudflare’s piece as a “sales pitch” and hinted at a third-party being responsible for some of the behavior.

I feel like both articles go too hard after the other. Also, you never know what went on behind the scenes, but from the outside it seems like this was just thrown online in a blog with pretty harsh rhetoric. Seems overly petty to me on both articles, and I'm not sure what it accomplishes other than both companies seemingly trying to get some headline attention.

Still, this isn't a simple problem. Website owners should be able to choose what kind of traffic accesses their sites, and services like Cloudflare are one of the few ways they can enforce things like that. That said, if you're using an "agentic" (still don't love that term) AI platform where you are asking AI to go find something or do something on your behalf, I can see the argument that it should be able to do so with the same access a user would have.

It's not an easy problem.

While I do believe website owners should have control over those things as strictly as they want, Cloudflare feels like they are throwing their weight around too much for my comfort recently. It feels like they have been pushing the line about how much they, as essentially an infrastructure provider, should be editorializing on this kind of thing.

Their “Content Independence Day — No AI Crawl Without Compensation” post further deepens my concern. This feels like it is right on the border between fighting for the rights of content creators, and simply platform fiat. To me, the fact that this is only shown directly to users as enabled on new accounts, and the fact that it can be turned off just barely keeps it from crossing the line to me, it still makes me uncomfortable.

Many people are fretting that AI will be "the end of the open web". I would argue that effectively happened several years ago, but there's no question AI is upending everything left on whatever the web is any more.

Links

Google Backtracks on URL Shortener

Sun, 03 Aug 2025 18:21:32 GMT

From Google's keyword blog -

We’re updating our plans for goo.gl links.

While we previously announced discontinuing support for all goo.gl URLs after August 25, 2025, we've adjusted our approach in order to preserve actively used links.

We understand these links are embedded in countless documents, videos, posts and more, and we appreciate the input received.

Nine months ago, we redirected URLs that showed no activity in late 2024 to a message specifying that the link would be deactivated in August, and these are the only links targeted to be deactivated. If you get a message that states, “This link will no longer work in the near future”, the link won't work after August 25 and we recommend transitioning to another URL shortener if you haven’t already.

All other goo.gl links will be preserved and will continue to function as normal. To check if your link will be retained, visit the link today. If your link redirects you without a message, it will continue to work.

This is much more reasonable, though I'm not sure why they wouldn't have just done this from the beginning. I can't imagine all of this costs Google that much to just keep running. Still, this illustrates a fairly big issue with one company having so much power over the internet.

Links

https://blog.google/technology/developers/googl-link-shortening-update/

Dropbox Password Manager

Fri, 01 Aug 2025 03:27:06 GMT

This week Dropbox announced that they are discontinuing their password manager. I don’t know anyone that actually uses their password manager, so it’s probably not many people impacted… still, this is a super tight timeline.

I’m not sure exactly what would happen if you don’t do anything and they kill it, but if my parents or in laws were using this it would be potentially disastrous.

Links

https://help.dropbox.com/installs/dropbox-passwords-discontinuation

TRMNL X

Wed, 30 Jul 2025 22:47:27 GMT

Announced today, TRMNL is making a new version they are calling TRMNL X. The TRMNL X is interactive, larger, higher resolution, waterproof, and more powerful than the original (Now called the OG) TRMNL. I wrote about how much I like my TRMNL previously - TRMNL. I love it, but there are times I wish there was a bigger one. Now there will be!

I'm really excited about this new version, and have placed a pre-order. Here is my affiliate link again if you would like to place a pre-order as well - https://usetrmnl.com/?ref=robby10

Links

Google URL Shortener

Wed, 30 Jul 2025 22:30:01 GMT

Although this was announced a fair amount of time ago, the time is nearly here. Google is killing off all shortened URLs that were using the https://goo.gl short link.

Google doing what Google does best - Killing off products. There will be an enormous amount of link rot because of this.

It’s a big problem how much of the internet Google controls or heavily influences. It’s not Google per se that is the problem, it’s a problem with any one company controlling that much of the internet.

Dub.co is my favorite alternative for dynamic links. Really great platform that is easy to use, and does exactly what it’s supposed to. They are also launching a new partner platform affiliate / referral platform that we have been in early testing for, and it’s built with the same standard of quality as the rest of the platform.

Links

Apple's Cloud

Mon, 07 Jul 2025 22:38:26 GMT

According to some recent reporting, Apple considered launching a cloud service to compete more with public cloud providers like AWS, Azure, and Google Cloud. Many people are commenting recently on Apple being late to AI, or potentially even too late to it, but I have long believed that the real boat they missed was with Cloud in general. I would argue that them missing out on Cloud is exactly why they are in such a tough position with AI now.

First, when I talk about Cloud, I’m referring more to AWS, Google Cloud, etc. not really what iCloud is. I don’t think it would be that helpful to completely copy what the other providers are broadly doing. There are plenty of good options, and to some degree it’s just a race to the bottom cost wise, but there are plenty of developer and business focused tools that should be available in an Apple cloud.

Some ideas, off the top of my head -

Business grade storage for businesses to use. You should be able to pay for whatever you need, not have weird “buckets” of storage like iCloud has for business customers. You should also be able to manage these like a business. You should have shared spaces for storage that multiple people can access, you should have rich ACL’s, you should be able to transfer data from one user to another as an admin if someone is terminated. This needs to be far more like Box, Dropbox, Google Drive, etc.
- Bonus - If you had the ability to host static files on an Apple cloud with an S3 compatible endpoint, that would be fantastic.
- Bonus bonus - Why do we still not have time machine in the cloud?
Identity manager - Apple should take on the identity providers like Google, Microsoft, Okta, etc. by offering a more capable and business oriented “Sign-in with Apple” infrastructure. At the same time, they need to integrate with the market leaders far more than they currently do. You should have granular access controls, you should be able to federate these identities elsewhere, support SAML and OAuth, allow groups for access controls, much richer HRIS integrations, etc. there is a long list they could do here. It can’t be half-assed, they need to create an alternative that people would want to use because it’s a good product.
- They should extend this to the EDU market too, for free.
- You should (optionally) be able to sync essentially your whole Mac through the cloud. You should be able to walk up to a computer, sign in to it, and have everything laid out and installed the way you like it.
Productivity software - They should push iWork much further than it has ever gone. Make this a real competitor to Office and Google Workspace. They are very nice tools to use, but they seem utterly unaware of how nearly every business uses these tools. They need to be much more interoperable, significantly improve collaboration, and really push the boundaries of what you can do with these apps.
Mail - Email isn’t going anywhere, particularly in business. Apple should make a real, enterprise-grade email service that is designed for businesses. You need to be able to have WAY more control over email than iCloud allows, and add functionality for groups, access control lists, etc. You also need to make it easy to use business email security tools and backup tools. Take e-discovery seriously and provide a way to do that, and allow 3rd party solutions as well. Importantly - Don’t make it restricted to only Apple devices either.
Contacts / Calendars, etc. - To finish out the productivity tools they need to make contacts and calendars business ready too. Shared contacts, integrations with CRM’s, directory syncing, functional deduplication, far more flexible calendar options, scheduling, conference call integrations, etc. There is a long list of what they could do here.
Gaming - If Apple wants to be taken more seriously in gaming (which, honestly I can’t tell if they do or don’t), they should build a similar application to Xbox Live.
iMessage for businesses - They should make something like Slack but not too much like Slack. Make a business version of iMessage that can be used for those kinds of things.
Business photo sharing - We work with a lot of businesses who rely heavily on taking photos for the business and then making sure everyone has access to them. This is surprisingly difficult to do in 2025 without a bunch of manual instructions that no one wants to follow. This might not make sense for every business, but I know several who would pay a ton to have this work seamlessly, and have a repository shared with everyone who needs access to it (same thing with ACLs, etc.)
Remote Desktop - Make this require a cloud subscription. Make it only work for devices in Apple Business Manager. I’d even be fine if it was built in but still required an approval dialogue for the end users before you join to completely share the screen, or maybe a big warning that comes up so you can’t do it without the end user knowing, but this is such a royal pain to deal with on Mac with 3rd party tools, it makes it extremely difficult to support business owned devices.
- This should extend to iOS too. A lot of the plumbing is in place, just need to make it work for businesses.
FaceTime for business - Compete with Zoom, Google Meet, MS Teams, etc.!

Some of these things they have been making glacial progress in with Apple Business Manager over the last few years, but honestly in many ways, it seems like Apple is just oblivious to how all of this stuff works everywhere else. Most of their services are pretty solid for personal use, but when you try to apply them to businesses, they’re just… Weirdly disconnected from how every other service works.

Some of this is in the name of “privacy”, though over the years I am unfortunately starting to think that some of the reason Apple leans on that so much is to be anticompetitive. Privacy should mean a choice of how to use the device and it’s services, not just lock you out of things that Apple doesn’t want you to use. This should apply to business-owned devices too, and the businesses should be able to do what they need to do.

A large cloud infrastructure to support all of this would lead to several things that are critically important to Apple right now. One - How long have they been beating the “Services revenue” drum? Guess who spends an enormous amount of money - Businesses / Enterprise. Second - I truly believe one of the main reasons Apple is struggling with AI, and frankly why Siri has been so bad for so long is that they don’t take cloud seriously. They need to be able to run large models in a cloud, and it should be controlled and operated by them. The cloud-based responses need to be incredibly fast, which means infrastructure needs to be close to people. Cloud would also mean that Apple would need to deploy updates continuously, and move faster than they ever have in this space. They also need to vastly improve their web apps to support functionality.

I could think of a dozen more examples that to me make a ton of sense, but I’m not convinced Apple could do this, even if they decided to. This would cost a ludicrous amount of money, and they would be trying to catch up to some pretty enormous leads. They have a ludicrous amount of money, but I think culturally Apple is just not prepared for this. Hopefully they can at least be more flexible to integrations, and partner with some cloud services providers in the short term to more rapidly improve the areas they desperately need.

Links

Gemini CLI

Wed, 25 Jun 2025 19:22:14 GMT

It is certainly interesting to see the level of competition in the AI space right now. I've become a huge fan of Claude Code (and will likely continue to use it) but Google is coming in strong with Gemini CLI announced today - Gemini CLI: your open-source AI agent.

Gemini has a couple of advantages -

The context window is enormous compared to all of the other models. This is using 2.5 Pro, which has a 1,000,000 token context window, which is kind of mind boggling.
They are offering a pretty significant amount of usage for free. Claude Code and Codex from OpenAI are both pretty good but will rack up the cost pretty quickly.

I've only had the chance to use it for a couple of minutes, but it seems like a nice experience. I've run in to a couple of hiccups though. First, you can't use a Google Workspace account yet. Second, because of that I tried setting up a Gemini API key instead, but for some reason it wouldn't recognize it and kept trying to do the oauth authentication anyway. I switched to a gmail account though and it worked fine.

My favorite terminal app, Warp also announced what they are calling "Warp 2.0" which is essentially adding more "agentic" capabilities to their AI tools as well. I think they might have a hard time keeping up with all these other CLI tools that are taking off right now, but I hope they are able to stick around!

Links

Wispr Flow

Mon, 23 Jun 2025 03:05:02 GMT

I recently came across an app called Wispr Flow. Wispr Flow is an AI powered dictation that works anywhere on the Mac. They have an iPhone app too, which I'll get to in a second.

The platform uses AI to transcribe, auto-edit, and format your speech into polished text, and adapts its tone to different apps. I had 2 thoughts before using it.

Sounds over hyped on their website. I'm always skeptical of software that claims to be a game changer for productivity, but I also tend to not be able to help but test them out.
I don't think I would ever just dictate to my computer. After all, macOS has this built in, and it's decent, and that has never stuck for me.

Like I said, I can't help myself though. I downloaded it and forced my self to really give it a try. After about a day, I was sold. It honestly feels like a game changer for me. I definitely still feel very weird talking to my computer, and I don't use it in all cases, but I find that there are a ton of cases that it's extremely helpful. The auto correction clearly powered by AI is fantastic. You can correct yourself, and it's remarkably good at writing what you meant to say, rather than a mistake you may have said. You can also add a dictionary of specific words / spellings that you use frequently that may be difficult to spell. It will also suggest items for the dictionary if you say something, then go back and correct it.

It also gets some amount of context of where your cursor is, and uses that to help format the text given that context. If you're writing an email, it will format it like an email. If you're using the command line, it will format it like the command line.

There is an iOS app, which also works pretty well, but the limitations of iOS make it fairly clunky. It shows up as a keyboard, but then you have to flip over to the app, turn on dictation, and then flip back. Once you do that, it works well, but that is a pain to do.

Definitely give it a shot if this kind of thing sounds interesting.

Links

https://wisprflow.ai/

Zendesk Voice Summary Tool

Sat, 14 Jun 2025 19:52:26 GMT

How I Built a Voice Transcription Tool for Zendesk (and Made It a CLI)

At work we've used Zendesk for several years for our ticketing. In the last few years we've also used the Zendesk Talk voice for the phone (and SMS) as well. It's not perfect, but it helps keep information about tickets that are phone calls in the same system as everything else. It records each call, and makes it available via API as well. This was a great use case for AI, both in helping me build this tool, and using AI endpoints for transcription and summarization.

Listening to each call and trying to summarize what the issue was and what was done to resolve the issue is tedious. If the person who received the call can immediately summarize it right after the call that can work, but it's easy to forget something, and if we are busy, it's hard to make the time for it. Knowing what the issue was and what was done to resolve it is valuable information though, and helps us remain proactive in support instead of always reactive.

So I built a tool to automate the whole process. It downloads voice recordings from Zendesk tickets, transcribes them with OpenAI's Whisper, generates summaries with GPT-4o, and posts everything back to the ticket.

Here's how it works and how I packaged it up as a command-line tool.

The Basic Architecture

The tool works in three phases:

Download and Transcribe - Grabs all voice recordings from a ticket and runs them through Whisper
Summarize - Takes all the transcripts and creates a structured summary with GPT-4o-mini
Post Back - Adds the summary as a private comment on the ticket.

File Management

One thing I learned early on - you need a consistent naming scheme or you'll lose track of files fast:

file_basename = f"ticket{ticket_id}_call{call_id}"
audio_file = file_basename + ".mp3"
transcript_file = file_basename + ".txt"

This naming convention means I can easily find all files for a ticket, and more importantly, the tool can check if it's already processed something:

if not os.path.exists(transcript_file):
    print("   Transcribing audio with Whisper...")
    transcript = transcribe_audio(audio_file)
    with open(transcript_file, "w", encoding="utf-8") as tf:
        tf.write(transcript)
else:
    if skip_existing:
        print("   Skipping - transcript already exists")

This saves a ton of time (and API costs) when reprocessing tickets.

Handling API Failures

In order to handle potential failures, I built in a simple retry decorator that handles transient failures:

def retry_on_failure(func):
    """Decorator to retry a function on failure."""
    def wrapper(*args, **kwargs):
        for attempt in range(MAX_RETRIES):
            try:
                return func(*args, **kwargs)
            except Exception as e:
                if attempt < MAX_RETRIES - 1:
                    print(f"  Warning: Attempt {attempt + 1} failed: {str(e)}")
                    print(f"  Retrying in {RETRY_DELAY} seconds...")
                    time.sleep(RETRY_DELAY)
                else:
                    print(f"  Error: All {MAX_RETRIES} attempts failed.")
                    raise
        return None
    return wrapper

You can add @retry_on_failure on any function that makes API calls and you're good to go.

The Multi-Call Problem

Tickets often have multiple voice recordings - maybe the customer called back, or there were multiple conversations. I needed to handle this scenario, ideally without creating a bunch of individual private comments, making it hard to digest and adding a lot of noise.

For single calls, it's simple - just add a timestamp header:

def summarize_multiple_transcripts(transcripts_data: List[Dict], context: Dict) -> str:
    """Summarize multiple call transcripts into a single comprehensive summary."""
    if len(transcripts_data) == 1:
        # Single call - just add timestamp header
        data = transcripts_data[0]
        timestamp = format_timestamp(data['started_at'])
        summary = summarize_transcript(data['transcript'], context)
        return f"**Call on {timestamp}**\n\n{summary}"

    # Multiple calls - create sections for each
    # ... (builds detailed prompt for GPT-4)

The output looks like this:

## Call 1 - March 15, 2024 at 10:30 AM MDT

_Duration: 15m 23s | From: +1-555-0123 -> To: +1-555-0456_

### Description of the Call

Customer called about internet connectivity issues...

### Troubleshooting

- Verified modem lights status
- Performed speed test (5 Mbps down, 1 Mbps up)
- Reset modem and router

### Next Steps

- Schedule technician visit for tomorrow
- Follow up email with ticket number

---

## Call 2 - March 15, 2024 at 2:45 PM MDT

_Duration: 8m 12s | From: +1-555-0123 -> To: +1-555-0456_

### Description of the Call

Customer called back to confirm technician appointment...

Making It User-Friendly

I wanted this tool to work both interactively and from the command line. So when you run it without arguments, you get a nice interactive mode:

$ python voice_summary.py

Zendesk Voice Recording Processor - Interactive Mode
============================================================

Enter ticket numbers or URLs (comma-separated or one per line)
Press Enter twice when done:
12345
12346
https://company.zendesk.com/agent/tickets/12347

Found 3 valid ticket(s): 12345, 12346, 12347

Post summaries to Zendesk? (y/n) [default: y]: y
Skip recordings with existing transcripts? (y/n) [default: n]: y

Processing 3 ticket(s)
   Post to Zendesk: Yes
   Skip existing: Yes

Press Enter to continue or Ctrl+C to cancel...

But it also works great for automation:

parser = argparse.ArgumentParser(
    description='Process voice recordings from Zendesk tickets',
    formatter_class=argparse.RawDescriptionHelpFormatter,
    epilog='''
Examples:
  %(prog)s 12345                    # Process single ticket
  %(prog)s 12345 12346 12347        # Process multiple tickets
  %(prog)s --no-zendesk 12345       # Process without posting to Zendesk
  %(prog)s --skip-existing 12345    # Skip tickets with existing transcripts
  %(prog)s https://company.zendesk.com/agent/tickets/12345  # Process from URL
    '''
)

The Progress Display

Here's how it handles progress indicators, which help with longer operations to know that it's still running:

Processing Ticket #12345
============================================================
Fetching ticket details...
   Subject: Internet Connection Issues
   Customer: John Smith
   Agent: Support Team
   Status: OPEN

Searching for voice recordings...
   Found 2 voice recording(s)

Phase 1: Downloading and transcribing 2 recording(s)...

Processing recording 1/2 (Call ID: abc123)
   Duration: 15m 23s
   From: +1-555-0123 -> To: +1-555-0456
   Downloading audio...
    Downloaded: ticket12345_callabc123.mp3
   Transcribing audio with Whisper...
   Saved transcript: ticket12345_callabc123.txt

Phase 2: Summarizing 2 transcript(s) with GPT-4o-mini...
   Saved combined summary: ticket12345_combined_summary.txt

Phase 3: Posting combined summary to Zendesk...
   Added private comment to ticket 12345

Ticket #12345 Complete!
   Processed: 2/2 recordings
   Time: 45.2s

Turning It Into a Real Command-Line Tool

Rather than running this directly with python every time, I decided to make it in to a command line tool to make it easier to run from anywhere.

The Wrapper Script

First, I created a bash wrapper that handles all the environment setup:

#!/bin/bash
# Wrapper script for voice_summary.py

# Configuration
PROJECT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
VENV_DIR="$PROJECT_DIR/venv"
SCRIPT_PATH="$PROJECT_DIR/voice_summary.py"
TRANSCRIPT_DIR="$HOME/zendesk-transcripts"

# Create transcript directory if it doesn't exist
if [ ! -d "$TRANSCRIPT_DIR" ]; then
    echo "Creating transcript directory at $TRANSCRIPT_DIR..."
    mkdir -p "$TRANSCRIPT_DIR"
fi

# Change to transcript directory
cd "$TRANSCRIPT_DIR" || exit 1

# Activate virtual environment if it exists
if [ -d "$VENV_DIR" ]; then
    source "$VENV_DIR/bin/activate"
fi

# Execute the Python script with all arguments
python "$SCRIPT_PATH" "$@"

This wrapper does a few nice things:

Creates a dedicated directory for transcripts (~/zendesk-transcripts)
Activates the virtual environment automatically
Passes all arguments through to the Python script

Installing It System-Wide

Then I wrote an installation script that sets everything up:

#!/bin/bash
# Installation script for voice_summary command line tool

SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
WRAPPER_SCRIPT="$SCRIPT_DIR/voice_summary"

# Create ~/bin directory if it doesn't exist
if [ ! -d "$HOME/bin" ]; then
    echo "Creating ~/bin directory..."
    mkdir -p "$HOME/bin"
fi

# Create symlink
echo "Installing voice_summary to ~/bin..."
rm -f "$HOME/bin/voice_summary" 2>/dev/null
ln -s "$WRAPPER_SCRIPT" "$HOME/bin/voice_summary"

# Check if ~/bin is in PATH
if [[ ":$PATH:" != *":$HOME/bin:"* ]]; then
    echo "WARNING: ~/bin is not in your PATH"
    echo "To add it, add this line to your ~/.zshrc:"
    echo "    export PATH=\"\$HOME/bin:\$PATH\""
fi

After running this, you can use the tool from anywhere:

$ voice_summary 12345
$ voice_summary  # Interactive mode

Building a Standalone Executable

For distribution, I also created a PyInstaller build script:

# PyInstaller spec file configuration
a = Analysis(
    ['voice_summary.py'],
    hiddenimports=['openai', 'requests'],
    # ... other configuration
)

exe = EXE(
    pyz,
    a.scripts,
    a.binaries,
    a.zipfiles,
    a.datas,
    [],
    name='voice_summary',
    console=True,
    # ... other configuration
)

The build script handles everything:

#!/bin/bash
# Build a standalone executable using PyInstaller

# Install dependencies
pip install -q requests openai pyinstaller

# Build the executable
pyinstaller voice_summary.spec

if [ -f "dist/voice_summary" ]; then
    echo "Build successful!"
    echo "To install system-wide:"
    echo "    sudo cp dist/voice_summary /usr/local/bin/"
fi

Configuration

Instead of hardcoding credentials, the tool uses environment variables:

# Configuration from environment
ZENDESK_DOMAIN = os.getenv('ZENDESK_DOMAIN', 'yourcompany.zendesk.com')
ZENDESK_EMAIL = os.getenv('ZENDESK_EMAIL', '')
ZENDESK_PASSWORD = os.getenv('ZENDESK_PASSWORD', '')
OPENAI_API_KEY = os.getenv('OPENAI_API_KEY', '')

# Validate configuration
if not all([ZENDESK_EMAIL, ZENDESK_PASSWORD, OPENAI_API_KEY]):
    print("Error: Missing required configuration")
    print("Please set the following environment variables:")
    print("  - ZENDESK_EMAIL: Your Zendesk email")
    print("  - ZENDESK_PASSWORD: Your Zendesk password")
    print("  - OPENAI_API_KEY: Your OpenAI API key")
    sys.exit(1)

This makes it easy to use across different environments without touching the code.

Edge Cases I try to Handle

Closed Tickets

You can't update closed tickets in Zendesk. Instead of just failing, the tool asks what you want to do:

def confirm_closed_ticket_processing() -> bool:
    """Ask user if they want to proceed with processing a closed ticket."""
    print("\nWARNING: This ticket is CLOSED.")
    print("   Closed tickets cannot be updated in Zendesk.")
    while True:
        response = input("\n   Do you still want to process? (y/n): ")
        if response.lower() in ['y', 'yes']:
            return True
        elif response.lower() in ['n', 'no']:
            return False

If they proceed, it shows the summary in the console instead of trying to post it.

Timezone Conversion

The API defaults to using UTC, so I convert everything to Mountain Time:

def format_timestamp(timestamp_str: str) -> str:
    """Convert ISO timestamp to human-readable format in Mountain Time."""
    try:
        from zoneinfo import ZoneInfo  # Python 3.9+
    except ImportError:
        from pytz import timezone as ZoneInfo  # Fallback

    dt = datetime.fromisoformat(timestamp_str.replace('Z', '+00:00'))
    mountain_tz = ZoneInfo('America/Denver')
    dt_mountain = dt.astimezone(mountain_tz)
    return dt_mountain.strftime("%B %d, %Y at %I:%M %p %Z")

Batch Processing Stats

When processing multiple tickets, you want to know what happened:

============================================================
FINAL SUMMARY
============================================================
Tickets processed: 45/50
Recordings processed: 127
Total errors: 5
Total time: 425.3s

Failed tickets:
   - Ticket #12399: 403 Forbidden
   - Ticket #12412: No recordings found

What I Learned

Building this tool taught me a few things:

Phase your processing - Breaking it into download, transcribe, summarize, and post phases made debugging way easier
Cache aggressively - Saving transcripts locally saves API calls, and makes it easier to process in general
Make it interactive AND scriptable - Different use cases need different interfaces
Handle failures gracefully - APIs will fail, tickets will be closed, permissions will be wrong
Clear progress indicators matter - Make it easier to know it's still running on longer operations.

The Results

This tool has been extremely helpful in automating summaries of tickets that were phone calls, making it much easier to determine what was talked about and what resolution was reached, helping us determine where to spend time proactively solving problems, and informing our customers the types of items we have been working on with their employees.

Links

https://github.com/robbybarnes/zendesk-voice-summary

Dia Browser

Sat, 14 Jun 2025 17:32:19 GMT

Recently The Browser Company talked about how they are discontinuing Arc, which is still my favorite browser to use. In that article they talked about Dia, their new version of the browser built with AI as the focus. I wrote about this, and how I’m skeptical of it, and frankly irritated that the browser I love is getting killed off.

I remain skeptical, but they have opened up the beta of Dia now to Arc users. I’m a sucker for trying out new software, so naturally I downloaded it, and… I kind of love it.

It’s not quite what I liked about Arc. I miss the side tab bars (Dia puts them back up top where Chrome does), and it’s missing a lot of the settings and developer features that Arc had that I liked, but it does have the best feature of all, which is the one I use dozens of times a day and honestly feels like a feature I can’t live without - ⌘ + Shift + C to copy the current URL. It’s just incredibly useful. I’ve tried some Chrome extensions since writing about all this that are supposed to do this, but they just don’t work well.

The AI features I’m not 100% sold on yet, but I have to admit it is helpful to have a little chat you can open right on any page and ask questions about it, summarize it, have it help you do research, etc. I find myself using it more than I thought I might.

It feels like a bad idea to really start heavily using and relying on another browser from the company that just took away my favorite one. They have yet to make any money as a business, this is all venture backed and at this point, essentially a proof of concept. It’s only a matter of time before they start charging for it or enshittifying it, or just run out of money and go away. I hope they figure out a model that works this time.

Links

Meta and Yandex are de-anonymizing Android users’ web browsing identifiers

Wed, 04 Jun 2025 03:27:07 GMT

From Ars Technica - Meta and Yandex were found to be using embedded tracking scripts to link Android users’ web browsing activity with their app identities, effectively de-anonymizing them, bypassing typical privacy protections like browser sandboxing and incognito mode.

The surveylance economy makes these companies go to some crazy lengths to track everything that you do, just to cram more ads wherever they can. Unfortunately, at least in the U.S., you don't have any recourse.

It's important to note - these trackers will track you and your activity regardless of whether you have an account with them.

Links