• highly context-efficient agent tooling with AST-aware codemaps that let you target specific functionality precisely,
• a context builder that assembles deep, structured prompts from those tools,
• a chat/oracle layer that uses that context for extended analysis.

The core issue is that agents rarely have enough context to see the full picture, so they mix research, planning, and review instead of treating them as separate steps.

RepoPrompt functions as a context pump, applying context engineering to generate highly efficient analysis prompts.

By default, its MCP server for Claude Code is configured per-project via .mcp.json files. But if you want it available in every Claude Code session, regardless of which directory you're in, you can install it globally.

Agent Mode Is Amazing

I run Repo Prompt in Agent Mode with Claude connected via MCP, so the agent can call Repo Prompt’s context engine natively inside the session. The result is that I rarely think about prompting. I just describe what I want, and the agent automatically pulls the right context or invokes Repo Prompt when needed. It feels like a clean separation of intent and execution, where I stay high-level and the system has a new super power that assists with discovery, context, and reasoning.

Prerequisites

• RepoPrompt installed (the macOS app)
• Claude Code installed

Background Context

Claude Code has two config files that look like they'd be the right place for global MCP servers:

• ~/.claude/settings.json — global settings (permissions, plugins, env vars)
• ~/.claude.json — user-level config (MCP servers, preferences)

Despite the naming, MCP servers go in ~/.claude.json, not ~/.claude/settings.json.

Step 1: Locate the RepoPrompt MCP Binary

RepoPrompt ships an MCP server binary inside its app bundle. It also creates a convenient symlink during setup:

# The symlink (created by RepoPrompt's setup)
~/RepoPrompt/repoprompt_cli
# Which points to the actual binary inside the app bundle
/Applications/Repo\ Prompt.app/Contents/MacOS/repoprompt-mcp

You can verify this on your machine:

# Check the symlink exists and where it points
ls -la ~/RepoPrompt/repoprompt_cli

If the symlink doesn't exist, you can use the full app bundle path directly.

Step 2: Add RepoPrompt to ~/.claude.json

Open ~/.claude.json and find the "mcpServers" object. Add the RepoPrompt entry alongside your other servers:

{
  // ... other config (numStartups, autoUpdates, etc.) ...
  "mcpServers": {
    // ... your other MCP servers ...
    // Add RepoPrompt globally — uses the symlink created by RepoPrompt's setup
    "RepoPrompt": {
      "command": "/Users/YOUR_USERNAME/RepoPrompt/repoprompt_cli",
      "args": []
    }
  }
  // ... rest of config ...
}

Replace YOUR_USERNAME with your macOS username. Alternatively, use the full app bundle path if you prefer not to rely on the symlink:

{
  "mcpServers": {
    "RepoPrompt": {
      // Direct path to the binary inside the app bundle
      "command": "/Applications/Repo Prompt.app/Contents/MacOS/repoprompt-mcp",
      "args": []
    }
  }
}

Step 3: Restart Claude Code

Restart Claude Code, then run /mcp to verify. You should see:

RepoPrompt · ✔ connected

That's it. RepoPrompt's MCP tools: context_builder, file_search, apply_edits, get_file_tree, and more are now available globally in every Claude Code session.

Agent Prompt

Alternatively, skip the steps above and just use this prompt with Claude and let it do it for you:

Install RepoPrompt's MCP server globally for Claude Code. Here's what you need to know:
1. Find the RepoPrompt MCP binary. It's either at ~/RepoPrompt/repoprompt_cli (a symlink created by the app) or directly at /Applications/Repo Prompt.app/Contents/MacOS/repoprompt-mcp. Verify which path exists on my system.
2. Add it to ~/.claude.json (NOT ~/.claude/settings.json — MCP servers live in ~/.claude.json despite the naming). Find the "mcpServers" object and add a "RepoPrompt" entry with the binary path and empty args array.
3. Tell me to restart Claude Code and run /mcp to verify it shows as connected. 

2026 Oscar Pool Picks & Predictions

Category-by-category 2026 Academy Awards predictions, Oscar pool picks, and a printable ballot cheat sheet to help you win Oscar night.

Academy Awards Prediction Guide

To set this up, I just asked Claude to set up a cron, which it interpreted as creating a schedule. And it runs this task every five minutes for the duration of the show, which I predicted to be about 3.5 hours long.

Then it just visits this website in Chrome and gets the data.

Then Claude updates the HTML, commits the change, and pushes it. Because it’s a GitHub Pages site, the update is deployed automatically via a GitHub Action.

BTW the craziest part was Claude actually detected the tie and handled that perfectly.

For example, you can ask things like:

• Create a MIDI track with a drum rack
• Add a reverb to the current track
• Launch scene 3

The project lives here:

GitHub - hidingwill/AbletonBridge: 322 tools connecting LLM’s to Ableton Live

322 tools connecting LLM’s to Ableton Live. Contribute to hidingwill/AbletonBridge development by creating an account on GitHub.

GitHubhidingwill

Below are the commands I used to install it on macOS.

1. Install uv (required)

Both projects use uv to run the MCP server.

curl -LsSf https://astral.sh/uv/install.sh | sh

2. Install the Remote Script

Clone the repo and copy the Remote Script into Ableton's User Library:

git clone https://github.com/hidingwill/AbletonBridge.git ~/Code/AbletonBridge

cp -R ~/Code/AbletonBridge/AbletonBridge_Remote_Script \
  "$HOME/Music/Ableton/User Library/Remote Scripts/AbletonBridge"

3. Register the MCP server

I use Claude and Codex, so I set them both up:

claude mcp add --scope user AbletonBridge -- uv run --directory "$HOME/Code/AbletonBridge" ableton-bridge
codex mcp add AbletonBridge -- uv run --directory "$HOME/Code/AbletonBridge" ableton-bridge

4. Configure Ableton Live

Launch Ableton Live, then go to:

Settings → Link, Tempo & MIDI

Set:

Control Surface: AbletonBridge
Input: None
Output: None

4. Ask Your Agent to Control Ableton

After installing the MCP server, quit and reopen your agent so it registers the server. For example, if you’re using Claude, close and relaunch it.

Then open Ableton Live and ask the agent to do something like:

set up a new session with a 909 drum track at 148 BPM, add a vintage-style synth, a 70s-style bass sound, and generate a few simple melodies

I don’t see myself actually using this, but it’s pretty interesting that it’s even possible. It’s impressive that Ableton exposes a mature API that makes this kind of integration feasible.

While it wouldn’t really inspire me to make music this way, I could see it being useful for learning Ableton interactively or for automatically setting up more complex sessions.

Windows note

If you’re on Windows and the install fails, review this issue from the original source repository (this post links to a more developed fork) before proceeding. The Remote Script path may differ, and installing into the User Library may not work on some systems.

Some of that work includes:

• Writing modern DriverKit (USB & Thunderbolt) audio drivers and companion desktop software for a legacy audio interface that was sunset by its original developers. It now works again on macOS 26, and hopefully future releases as well. Currently in active testing before proposing to the rights owner next steps and how it might be publicly released.
• Working with a company on new firmware for a hardware sequencer that is no longer being maintained. Still in the exploratory phase, with source code access expected soon.
• Releasing Printer Bridge, a macOS utility that enables AirPrint support for printers that already work with a Mac. A small afternoon side project that came together quickly while I was doing other things.

It took about six months of outreach to build enough trust with one of these companies for them to feel comfortable sharing the source code with me. The process taught me a lot—especially about diplomacy and how to earn support from companies who have very little direct upside and every reason to be hesitant.

When I mentioned the timeline to someone who doesn’t know me well, they laughed at me and said that I don’t value my time.

I disagree.

One of the best things we can do as stewards of the planet is keep useful things alive for as long as possible. Not only that, I love learning how things work by cracking them open and rebuilding them!

There is so much hardware that still works. It still sounds great, prints fine, feels good to use, or solves a real problem. What usually disappears isn’t the hardware — it’s the software around it. A driver stops getting updated. A desktop app falls behind. A missing feature makes something harder to use in a modern setup. Slowly, something valuable starts looking obsolete.

The good news is that software has never been easier to make. The tools are better, iteration is faster, and more people have the skills to build software that extends the life of existing devices.

Sometimes I reach out to companies that can no longer maintain older products and ask if they’d consider letting me help. The goal is simple: earn trust from the team, move slowly, and explore whether the software can be modernized without creating any work for them. If open sourcing becomes possible, even better. It's early days but I've done this a few times in the past 6-months and hope to do it a lot more!

There are enthusiastic users, customers, and developers who would gladly help keep great hardware alive. That’s good for the hardware, good for the people who bought it, and good for the companies that made it.

Lately I’ve been calling this idea the Hardware Liberation Front.

A loose group of people who write software to keep great hardware alive for as long as possible—drivers, firmware updates, utilities, compatibility layers, bridges between old devices and modern systems.

This idea isn’t new. People like Yvon Chouinard have encouraged repairing and extending the life of things for decades. And the open-source community has long done the same in software, maintaining the code much of the modern world runs on. What’s changing now is that better tools—and AI in particular—make it possible for many more people (like me) to easily participate.

If the idea resonates with you, join in.

Keep your gear alive.
Help someone else keep theirs alive.
Write an update. Share the tool. Open source the fix.

A little software can go a long way.

A while back I wrote about how to start developing audio apps and plugins on macOS using the JUCE-Plugin-Starter I created. That template automates a lot of the tedious setup — dependency installation, project scaffolding, code signing, Xcode project generation — through a set of shell scripts.

I've since turned that workflow into a Claude Code plugin called juce-dev. Instead of running scripts in your terminal and answering prompts, you type /juce-dev:create "My Plugin" in Claude Code and it walks you through the whole thing interactively.

What it does

The plugin's create command handles the full project setup:

• Checks that your Mac has the required tools (Xcode CLT, Homebrew, CMake) and offers to install anything missing
• Finds your JUCE-Plugin-Starter template and checks if your JUCE version is current
• Pulls your developer settings (Apple ID, Team ID, certificates) from the template's .env so you don't re-enter them for every project
• Generates all the derived values — class names, bundle IDs, 4-letter JUCE plugin codes — from the plugin name you provide
• Creates a new project folder, replaces template placeholders, initializes git, and optionally creates a public or private GitHub repo
• Optionally sets up DiagnosticKit a Swift app that can collect user bugs and publish diagnostics with attachments via GitHub Issues (and walks you through configuring the token you'll need to configure that repo)

There are also commands for building (/juce-dev:build) and adding Visage or iOS targets to existing projects.

Visage GPU UI

The plugin has built-in support for Visage, a GPU-accelerated UI framework that renders via Metal. Pass --visage when creating a project and the plugin will clone my Visage fork (which includes iOS touch support and several DAW compatibility patches), copy the JUCE↔Visage bridge files, wire up CMake, and give you a project that renders with Metal out of the box.

The plugin includes a companion skill called juce-visage that provides detailed guidance for working with Visage inside JUCE — things like embedding an MTKView in a plugin window, bridging keyboard and mouse events between JUCE and Visage, handling focus in DAW hosts, building popups and modals inside the GPU layer, and managing the tricky destruction ordering that Metal's display link requires.

Who this is for

Primarily people who are developing macOS or iOS audio apps and:

• Want to build an audio plugin but haven't set up their Mac for it yet
• Have never worked with JUCE before and want to skip the boilerplate
• Want to get from zero to a compiling, running plugin as quickly as possible

You don't need an Apple Developer account to build and test locally. If you do have one, the plugin will configure code signing and notarization so your builds are ready to distribute.

If you already know JUCE well, the plugin still saves time on the repetitive project setup — generating Xcode projects, managing .env configurations, and wiring up optional dependencies like Visage.

Codex users

The plugin is for Claude Code, but if you use OpenAI's Codex CLI, there's a standalone juce-visage skill you can install. It provides the same Visage integration guidance (Metal embedding, event bridging, iOS touch handling, etc.) but not the automated project creation commands.

Install it with a sparse checkout:

mkdir -p ~/.codex/skills
cd ~/.codex/skills

git clone --no-checkout --depth 1 --filter=blob:none --sparse \
  https://github.com/danielraffel/generous-corp-marketplace.git tmp-juce-visage
cd tmp-juce-visage

git sparse-checkout set skills/codex/juce-visage
git checkout

mv skills/codex/juce-visage ~/.codex/skills/

cd ~/.codex/skills
rm -rf tmp-juce-visage

If you’re not familiar with building skills, it’s worth trying out. You can pull just that folder from the GitHub repo without cloning the entire thing using Git’s sparse checkout:

mkdir -p ~/.claude
cd ~/.claude

git clone --no-checkout --depth 1 --filter=blob:none --sparse https://github.com/anthropics/skills.git tmp-skills
cd tmp-skills

git sparse-checkout set skills/skill-creator
git checkout

mkdir -p ~/.claude/skills
mv skills/skill-creator ~/.claude/skills/

cd ..
rm -rf tmp-skills

This clones only the repository metadata and checks out just the skills/skill-creator folder.

--filter=blob:none avoids downloading file contents until needed, and --depth 1 limits the clone to the latest commit.

The folder is then moved into ~/.claude/skills/ so Claude can load it.

Here’s what was happening for me and what fixed it.

Quick repro

• Re-sign the app → launch via Finder/Dock or open MyApp.app → tap installs but no events fire
• Launch the Mach-O directly (.../Contents/MacOS/MyApp) → events fire normally

The Setup

Media keys (play/pause, volume, brightness) often show up as “system defined” events (NX_SYSDEFINED) at the CoreGraphics layer. I intercepted them with a session event tap:

let eventMask: CGEventMask = (1 << CGEventType.systemDefined.rawValue)

let tap = CGEvent.tapCreate(
    tap: .cgSessionEventTap,
    place: .headInsertEventTap,
    options: .defaultTap,
    eventsOfInterest: eventMask,
    callback: eventCallback,
    userInfo: nil
)

In my case, NSEvent.addGlobalMonitorForEvents(matching: .systemDefined) was not reliable for the media keys I needed, so I used a CoreGraphics event tap.

The Bug (What I Observed)

After re-signing a new build (e.g. codesign --force --deep) and launching via Finder/Dock or open MyApp.app:

• tapCreate() returned a non-nil CFMachPort
• CGEvent.tapIsEnabled() initially returned true
• then… no callbacks ever fired

Launching the binary directly worked:

/Applications/MyApp.app/Contents/MacOS/MyApp

In my setup, the failure correlated with Launch Services launches after re-signing, and behaved like a permission/trust evaluation issue: the tap existed, but didn’t receive events, and the usual "disabled" callback path wasn’t dependable.

The Fix

1. Deployment: launch the binary directly (avoid open)

nohup /Applications/MyApp.app/Contents/MacOS/MyApp \
  >> ~/Library/Logs/MyApp.log 2>&1 & disown

The app still appears in the Dock and behaves like a normal app launch; the main difference is stdout/stderr goes to the log file.

2. Safety net: continuously verify tap health and recover

Timer.scheduledTimer(withTimeInterval: 5.0, repeats: true) { _ in
    guard let tap = self.eventTap else { return }

    if !CGEvent.tapIsEnabled(tap: tap) {
        CGEvent.tapEnable(tap: tap, enable: true)

        // If tapEnable doesn't stick, reinstall the tap:
        // remove from RunLoop, create new tap, re-add.
        if !CGEvent.tapIsEnabled(tap: tap) {
            self.reinstallEventTap()
        }
    }
}

And handle both disable events in the callback:

if type == .tapDisabledByTimeout || type == .tapDisabledByUserInput {
    if let tap = info?.tap {
        CGEvent.tapEnable(tap: tap, enable: true)
    }
    return nil
}

What to Check First (Permissions)

Before installing the tap, verify Input Monitoring (“ListenEvent”) permission:

if !CGPreflightListenEventAccess() {
    CGRequestListenEventAccess()
}

Input Monitoring is required to listen for global events. Also note: if you use .defaultTap (not .listenOnly), you may additionally need Accessibility permission for full interception/interaction. Missing permissions can look identical to the "tap installed but no events" symptom.

Summary

Key insight: a non-nil tap is not a healthy tap. Always verify tapIsEnabled at runtime, not just at install time.

Working assumptions (based on observed behavior)

I can’t prove the exact internal mechanism, but given the repeatable pattern in my setup, I’m operating under these assumptions:

• TCC decisions are tied to code identity, and re-signing can effectively create a "new" identity that requires re-evaluation (or re-granting) for Input Monitoring / Accessibility.
• Launching via Launch Services (open, Finder/Dock) is more likely to trigger that identity/permission re-evaluation than launching the Mach-O directly.
• When this happens, a CGEvent tap can exist but be functionally inert (no callbacks), and the normal "tap disabled" callback path may not reliably fire—so health checks + reinstall are the pragmatic mitigation.

If the issue reproduces, the fastest way to validate the hypothesis is to compare:

• direct exec vs open
• tapIsEnabled over time
• current TCC grants for Input Monitoring / Accessibility after each re-sign

Optional mitigation: delay tap installation

In my setup, adding a short delay before installing the tap reduced failures after re-sign + Launch Services launch. I treat this as a best-effort workaround (timing-dependent), not the core fix.

DispatchQueue.main.asyncAfter(deadline: .now() + 1.0) {
    self.installEventTap()
}

Or (often safer): install immediately, then recheck/reinstall after a short delay:

installEventTap()
DispatchQueue.main.asyncAfter(deadline: .now() + 1.0) {
    verifyOrReinstallTap()
}

On January 31, 2026, Belkin the company behind the Wemo–Google Home integration, turned down the integration and I guess Google decided not to step in with a solution.

Overnight, my devices went offline in the Google Home app and stopped responding to voice commands.

Finding the Fix

A Reddit post pointed me in the right direction. People were restoring full voice control using Home Assistant and the Matterbridge add-on to bridge their devices to Google Home via the Matter protocol. I already had Home Assistant running with my Wemo devices connected through the built-in Belkin WeMo integration — which uses UPnP and never touched Belkin's cloud — so my devices were already working in HA. I just needed to expose them to Google Home.

The Setup

1. (Only if required) Update HA Supervisor
   When I first tried to add a third-party add-on repository, I hit this error: 'StoreManager.add_repository' blocked from execution, supervisor needs to be updated first
   Fix: go to Settings → System → Updates and update the Supervisor before doing anything else.
2. Add the Matterbridge repository
   In Home Assistant: Settings → Add-ons → Add-on Store, tap the overflow menu (⋮) in the top right, select Repositories, and add: https://github.com/Luligu/matterbridge-home-assistant-addon
3. Install and start Matterbridge
   Find Matterbridge Home Assistant Application in the store, install it, then start it and open the Web UI.
4. Install the matterbridge-hass plugin
   In the Matterbridge UI, install the matterbridge-hass plugin. Configure it with:
   - Your Home Assistant URL (e.g. http://homeassistant.local:8123)
   - A long-lived access token (HA → your profile → Security → Create token)
   
   Restart the Matterbridge add-on to let it load your HA entities.
5. Pair with Google Home
   In the Google Home app, tap + → Set up device → Matter device, then scan the QR code shown in the Matterbridge add-on. Walk through the pairing flow and assign devices to rooms.

End Result

All of my Wemo devices are back in Google Home, online, and responding to voice commands. Pleasant surprise: they're noticeably faster than before. The old Belkin integration routed commands through the cloud. Now everything runs locally over Matter — "Hey Google, turn off the backyard light" and it's instant.

If you're a Wemo user who lost Google Assistant control in February 2026, this setup is worth the 15 minutes it takes. You get your voice commands back, you get local control, and you end up in a better place than you started.

I've been exploring Tauri lately – the framework for building desktop (and mobile) apps using web technologies with a Rust backend. If you haven't come across it, you: write your UI in React/Vue/Svelte/whatever, let Rust handle the backend, and ship a native binary that's a fraction of the size of an Electron app.

Why Tauri?

Honestly, I was just tired of Xcode build times and wanted the speed of web development. If you've ever maintained separate native codebases for desktop and mobile, you know the pain. Tauri lets you use the web stack you already know while still getting native-feeling performance and access to system APIs. The Rust backend gives you a memory-safe native backend (no bundled browser runtime) and the kind of mature tooling you want when dealing with lots of data or running AI workloads locally. You're not shipping a bundled Chromium – Tauri uses the platform's native webview (WKWebView on macOS, WebKitGTK on Linux, WebView2 on Windows), so binaries stay small and resource usage stays low.

It seems to be a popular choice right now. Apps like Codex Monitor (a desktop command center for orchestrating AI coding agents) and Conductor (parallel Claude Code and Codex agents on your Mac) are shipping with Tauri. The awesome-tauri list has many more across a variety of categories.

For my first project, I'm using Tauri v2 with Vite as the frontend build tool. Vite is a fast dev server and bundler – it uses native ES modules during development so you get near-instant hot module replacement instead of waiting for a full rebuild. It pairs well with Tauri since both prioritize speed.

The Testing Problem

I’ve gotten spoiled by automated testing. I’ve grown used to asking agents to spin up MCP servers so they can drive browser tooling (Chrome DevTools MCP–style) and native build/test stacks (XcodeBuildMCP-style) and validate flows for me. In web dev, you point Selenium or WebDriverIO at your app, click a few buttons, assert some text, take screenshots, and you’re done. I wanted that exact workflow for my Tauri app.

But on macOS there isn’t an Apple-provided WebDriver for embedded WKWebView apps—Apple’s WebDriver story is safaridriver for automating Safari itself, which doesn’t help when your UI is a WKWebView inside a desktop app. Linux has WebKitWebDriver, Windows has Edge WebDriver, and the official Tauri WebDriver stack supports those—but macOS requires a third-party driver or a custom bridge.

I wasn’t the only one frustrated by this. Around the same time I started building a solution, a couple of other projects popped up tackling the same problem (more on those below). But I’d already gone deep enough that it made sense to finish.

What I Built

Tauri-WebDriver is an open-source W3C WebDriver v1 implementation for Tauri apps on macOS, built in collaboration with Claude Code. It’s two Rust crates:

1. A Tauri plugin that runs inside your app in debug builds. It starts a little HTTP server, injects a JavaScript bridge into the webview, and exposes endpoints for finding elements, clicking things, reading text, managing windows, executing scripts, etc.
2. A CLI binary (tauri-wd) that speaks the standard W3C WebDriver protocol on port 4444. WebDriverIO, Selenium, or any W3C-compatible test runner connects to it like they would any browser driver. The CLI launches your app, discovers the plugin's port, and translates every WebDriver command into a plugin API call.

WebDriverIO/Selenium ──HTTP:4444──> tauri-wd CLI ──HTTP──> plugin inside your app

It’s not “100% of WebDriver,” but it covers a surprisingly large subset: element finding, input, screenshots, actions, windows, cookies, iframes/shadow DOM, alerts, print-to-PDF, and computed ARIA roles.

AI-Powered Testing with MCP

One thing I'm particularly excited about is the MCP (Model Context Protocol) integration. I connected tauri-webdriver to mcp-tauri-automation, an MCP server that lets AI agents like Claude Code directly launch, inspect, and interact with your Tauri app. You can say "click the submit button, fill in the form, and take a screenshot" and it just works.

I forked the original project to add some features I needed -- execute_script, get_page_title, get_page_url, multi-strategy element selectors, configurable screenshot timeouts, and wait_for_navigation – and submitted those upstream.

Alternatives

I'd be remiss not to mention the other solutions that exist:

• CrabNebula Webdriver for Tauri – A commercial hosted testing service with macOS WebDriver support.
• tauri-plugin-webdriver – An open-source Tauri plugin that embeds a WebDriver server directly in the plugin (single-crate vs. my two-crate approach). It supports (or plans to support) macOS, Linux, and Windows, so if you need cross-platform WebDriver support, this is probably the more pragmatic choice.

After starting this, I learned others were building similar things so this was admittedly not the greatest use of time. But, I learned more about Rust, Tauri’s plugin system, the W3C WebDriver spec, WKWebView quirks, and what’s happening under the hood when you capture screenshots in E2E tests.

Try It

If you're building a Tauri app on macOS and want automated e2e tests follow the quick start in the GitHub repo. The README also has additional information and a complete endpoint reference.

Disclosure: The code for this project was written in collaboration with Claude Code.

For clarity, the two skills are:

• MCP Skill: primes the agent on how to use the MCP server’s tools (optional if you’re already using the MCP server).
• CLI Skill: primes the agent on how to navigate the CLI (recommended if you’re using the CLI).

My summary of the authors description of the tradeoffs: 

MCP is the better overall experience, but if you care more about token efficiency than predictability, choose the CLI. MCP is more stateful and can persist app configuration across sessions, so the agent doesn’t have to rediscover settings every time it makes a tool call.

To install the scripts, run the command below in your terminal and follow the prompts:

curl -fsSL https://raw.githubusercontent.com/cameroncooke/XcodeBuildMCP/v2.0.0/scripts/install-skill.sh -o install-skill.sh && bash install-skill.sh

Additional details about the skills are available in the project docs.

Why this matters

Xcode workflows are getting a lot tighter: you can run tests, automate builds, and even publish App Store submissions straight from your IDE or terminal. XcodeBuildMCP (plus the new install scripts) pairs well with App Store Connect automation tools like:

• App-Store-Connect-CLI — a fast, lightweight, scriptable CLI for App Store Connect that lets you automate key iOS release steps directly from the terminal.

Pre-requisites

• Desktop app (prebuilt): https://www.codexmonitor.app
  I installed/updated this instead of building the desktop app myself (the latest builds include Tailscale support + the iOS work).
• iOS app (from source): https://github.com/Dimillian/CodexMonitor
  The iOS app isn’t on TestFlight, so I built it locally. This has dependencies but I am not going to list them since building should resolve.
• Xcode + Command Line Tools
  I used my Apple Developer Account (TeamID, AppleID) to build and deploy to my device not sure if that's required.
• Tailscale on macOS and Tailscale on iOS logged in and connected
• Codex installed and authorized to your account

1. Get the desktop app running + note your Tailscale IP

On the Mac where CodexMonitor runs, open Tailscale from the menu bar and copy your Tailscale IPv4 (something like 100.x.y.z). That’s the IP the iPhone will target.

I used that IP as the remote backend address inside CodexMonitor.

2. Configure CodexMonitor desktop to run as a Remote Daemon and Start Mobile Access

In CodexMonitor (desktop) go to:

Settings → Server

Set:

• Backend mode: Remote (daemon)
• Remote backend IP:port: <TAILSCALE_IP>:<PORT>
  • I had to change the port (example below uses 4735)
  • Token: set a token
• Mobile access Daemon: Click Start daemon
• Tailscale Helper: Click Detect Tailscale

If Tailscale Helper Doesn’t Work

You can also start the daemon yourself from a shell. CodexMonitor shows you the exact command to use so don’t copy the generic example below as-is because it won’t include your macOS username, path, IP:port. Replace 100.x.y.z:4735 with your Tailscale IP and the port you set in Step 1.

'/Applications/CodexMonitor.app/Contents/MacOS/codex_monitor_daemon' \
  --listen '100.x.y.z:4735' \
  --data-dir '/Users/username/Library/Application Support/com.dimillian.codexmonitor' \
  --token '12345'

Expected output:

codex-monitor-daemon listening on 100.x.y.z:4735 (data dir: /Users/username/Library/Application Support/com.dimillian.codexmonitor)

3. Build and install the iOS app on your device (local signing)

Clone the repo and install dependencies:

git clone https://github.com/Dimillian/CodexMonitor.git
cd CodexMonitor
npm install

List devices to confirm your iPhone is visible:

./scripts/build_run_ios_device.sh --list-devices

Then build + install to your iPhone (you need an Apple Team ID that’s available in Xcode on this Mac):

./scripts/build_run_ios_device.sh --device "iPhone" --team "<YOUR_TEAM_ID>"

If signing isn’t set up yet

The script supports opening the generated Xcode project so you can do one-time signing setup:

./scripts/build_run_ios_device.sh --open-xcode --team "<YOUR_TEAM_ID>"

In Xcode, add your Apple account and choose the correct team for signing, then re-run the device script.

4. What Codex actually did to get the iOS build working

I asked Codex to run the repo’s iOS device script end-to-end and fix whatever broke. The flow looked like this:

• Ran ./scripts/build_run_ios_device.sh --help
• Listed devices with --list-devices
• First build failed due to missing signing team
• Installed missing JS deps via npm install
• Hit xcodebuild exit code 65 (signing/provisioning issues on that Mac)
• Checked available signing identities (security find-identity -v -p codesigning)
• Re-ran with a local team, still blocked until Xcode account setup was correct
• Eventually isolated a linker failure related to Swift compatibility libs being searched under a stale toolchain path
• Patched the generated Xcode project’s LIBRARY_SEARCH_PATHS to include stable Xcode Swift library directories as a fallback
• After that, the iOS build succeeded and the app installed to my iPhone

One important obvious gotcha: auto-launch via CLI fails if your iPhone is locked. If that happens, unlock the phone and re-run launch:

xcrun devicectl device process launch --device "iPhone" --terminate-existing com.dimillian.codexmonitor

5. Configure the iOS app to talk to the desktop daemon

On iOS, set the exact same values as desktop (you might find the connect overlays are kinda in the way ignore that and tap the fields):

• Host/IP: <TAILSCALE_IP>
• Port: (e.g. 4735)
• Token: the same token you set on desktop

Then connect.

The fix was simple: remove the offending U+2028 characters from the sessions JSONL file. After that, I quit and restarted again and everything came back. Clearly that one character was the culprit.

What to ask Codex

• Search the Codex sessions folder¹ for U+2028.
• Show the exact lines where it appears.
• Remove those characters from the affected session file(s).
• Verify the characters are gone.
• Quit and restart Codex.app to confirm sessions load again.

FWIW You'll probably never hit this issue

1. You’ll want to search the Codex sessions folder in your home directory. On macOS, the path is ~/.codex/sessions. Ask Codex to scan that folder for hidden Unicode line separators and clean them up.

What This Solves

The goal is simple: Get a second opinion without ceremony.

No artifact juggling.
No copying files back and forth.
No breaking flow.

Just use a skill, get a response, continue.

One agent stays in charge. The other is consulted. The lead integrates the result.

Example real world prompt in Claude:

Please review the original source using RepoPrompt to ground the analysis in the actual codebase and consult Apple documentation via Sosumi MCP. After forming a plan, review it with /codex ask it to also use RepoPrompt to ground the analysis and consult Apple documentation via Sosumi MCP, refine it, and produce an updated v2 document with revised phases and align on next steps.

How It Works

Two skills. Two agents.

• Claude can call /codex
• Codex can call /claude

Whichever agent you’re actively using remains primary. The other is consulted for a scoped task and returns output. You decide how to use that response in your prompt. I usually have them consult and align before moving forward.

Setup

The following approaches use sparse checkouts so you only download the exact skill folder you need rather than the entire repo.

Install /codex in Claude

1. Pull only the codex skill

git clone --depth 1 --filter=blob:none --sparse https://github.com/danielraffel/generous-corp-marketplace.git
cd generous-corp-marketplace
git sparse-checkout set skills/codex

2. Create Claude’s skills directory (if missing)

mkdir -p ~/.claude/skills

3. Move the skill into place

mv skills/codex ~/.claude/skills/

4. Restart Claude

Verify installation:

/skills

You should now see /codex.

Install /claude in Codex

1. Pull only the claude skill at the pinned commit

git clone --filter=blob:none --sparse https://github.com/danielraffel/generous-corp-marketplace.git
cd generous-corp-marketplace
git sparse-checkout set skills/claude
git checkout cd7d30498caa7114036e18687243fde4ff081083

2. Create Codex’s skills directory (if missing)

mkdir -p ~/.codex/skills

3. Move the skill into place

mv skills/claude ~/.codex/skills/

4. Restart Codex

Verify installation:

/skills

You should now see /claude.

Final Folder Structure

Claude:

~/.claude/skills/codex/
  agents/
  SKILL.md

Codex:

~/.codex/skills/claude/
  references/
  SKILL.md

What You Now Have

• Claude can consult Codex with /codex
• Codex can consult Claude with /claude

Clean second opinions. No artifact passing. No context juggling.

Ralph Loop / Parallel Optimization

If you’re running a ralph-loop style workflow or keeping a CLAUDE.md you can explicitly allow delegation for parallelizable tasks.

Somewhere I stumbled on someone suggesting using it in a ralph-loop or a CLAUDE.md and they shared this snippet that leverages the /codex skill:

CODEX DELEGATION (OPTIONAL):
- Use /codex <task> or codex exec --full-auto <task> for parallel work.
- Good candidates for Codex delegation:
  - Writing tests for code you just wrote
  - Implementing a component while you work on another
  - Code review of completed work items
- Do NOT delegate to Codex when:
  - The task depends on something you're currently building
  - Multiple agents would edit the same file
  - The task requires your current conversation context
- When delegating, run Codex in background and continue your work.
- Check Codex output before marking work item complete.

Working Ralph Loop Output

HomeBar sits in your menu bar and lets you toggle lights, switches, and other HomeKit accessories with a single click. No need to open the Home app or pull out your phone.

A few things it does:

• Menu bar access to all your HomeKit devices
• Apple Shortcuts integration — run your shortcuts right from the menu
• Keyboard shortcuts — assign hotkeys to any device
• Sensor readings — see temperature, humidity, and other sensor data at a glance
• Dark mode support — matches your system appearance

It's free and open source—available for download if you wanna try it out.

Why asciinema (instead of video)?

I wanted to share a screen capture of a terminal project I’ve been working on—and I wanted something better than a blurry screen recording.

asciinema records terminal sessions as lightweight text-based “cast” files (.cast) that you can replay and embed on the web. Because it’s text (not pixels):

• files stay small
• rendering stays crisp at any resolution
• viewers can copy/paste commands directly from playback

What I liked most: I can record once, then re-embed the same session at different sizes in docs, blog posts, and READMEs without re-encoding video.

The basic workflow

1. Record a terminal session with asciinema
2. Host the .cast somewhere public (I used GitHub)
3. Embed it in Ghost using the asciinema player
4. Trim to “just the good bit” (optional, but usually what you want)
5. Add a cover image for the web player and a fallback image for email/RSS

Install asciinema

Install it however you like—package manager is easiest:

• macOS: brew install asciinema
• Debian/Ubuntu: sudo apt install asciinema
• Arch: sudo pacman -S asciinema

Record a terminal session

Start recording:

asciinema rec demo.cast

Stop by exiting your shell (Ctrl+D) or typing exit.

Replay locally to sanity-check:

asciinema play demo.cast

Host your .cast files

You have two options:

• Upload to asciinema’s hosted service (asciinema upload …)
• Self-host .cast anywhere public (S3, static hosting, GitHub, etc.)

I went with: commit .cast files to a GitHub repo, then use GitHub raw URLs for embeds. That gives Ghost (and the player) a URL it can fetch directly.

Embedding in Ghost

To embed a .cast on your site, you include asciinema player (CSS + JS) and point it at your .cast URL.

In Ghost that usually means:

• Header injection: include player CSS
• Footer injection: include player JS (and init code)
• In the post body: an HTML card containing a container element for the player

One practical detail: if you send Ghost posts as newsletters (or rely on RSS), JavaScript often won’t run in those clients. I learned this the hard way. You’ll want two “previews”:

• Cover image (web): shown on top of the player before someone hits play
• Fallback image (email/RSS): a plain <img> that still looks good even when scripts are stripped

Trimming to “just the good bit”

Usually you don’t want the full unedited recording—you want the segment that demonstrates the feature. Two approaches:

Option A: Start mid-way (easy)

The player supports startAt, so you can begin playback at a specific timestamp.

Option B: True trimming (precise, but fiddly)

A .cast is newline-delimited JSON: one header line, then timestamped events. If you cut time ranges out, you generally need to adjust timestamps to keep playback consistent.

What I was doing manually (and got tired of)

My first pass looked like:

• upload .cast files to GitHub
• grab raw URLs
• hunt for start/end times
• hand-assemble:
  • Ghost header/footer injections
  • the per-clip embed HTML
  • a nice preview image
  • an email-safe fallback

It worked, but it was repetitive enough that I didn’t want to ever do that again.

The tiny tool I built: asciinema-ghost

So I built a simple single-file tool that does the “scrub → clip → embed” loop for me.

It lets you:

• Load one or more .cast files (drag/drop or URL)
• Scrub the timeline and stamp the current playhead into Start / End
• Preview the selection, loop it, and use markers
• Pick a frame as a cover image (web player poster)
• Set a fallback image for email/RSS
• Generate copy/paste-ready Ghost snippets (header injection, footer injection, and HTML-card embeds)
• Save state locally + export/import a project JSON

Local files are great for previewing, but final embeds want publicly hosted .cast URLs (GitHub raw URLs work well). Also: when running locally, browsers can be weird about file:// + fetching assets, so using a tiny local server makes things more consistent.

Web app: https://www.generouscorp.com/asciicinema-ghost/
Source repo: https://github.com/danielraffel/asciicinema-ghost

Examples in the wild

Here’s a post where I’m using this approach for embedded terminal demos.

Takeaways

If you want terminal demos that are crisp, lightweight, copy/paste-able, and easy to embed, asciinema is a great default.

And if you’re on Ghost (or anything that supports code injection), “self-host casts + embed with asciinema player” is straightforward—especially once you have a repeatable way to clip segments, pick a cover image, and include an email-safe fallback.

Structure (what’s happening)

For each embed you want:

• HTML card includes a container <div> with:
  • an <img> = fallback (works in email/RSS/no-JS)
  • a child <div> where the web player mounts
• Header injection loads the player CSS
• Footer injection:
  • mounts AsciinemaPlayer into the mount div
  • hides the fallback <img> once the player is ready
  • overlays a cover image (poster) on the player until playback starts

Post Content (HTML card)

<div id="cast-f60227d3" class="cast-embed">
  <!-- Fallback image (email/RSS/no-JS) -->
  <img
    class="cast-fallback"
    src="https://raw.githubusercontent.com/danielraffel/asciicinema-output/refs/heads/main/worktree-manager4.png"
    alt="worktree-manager4.cast"
    style="max-width: 100%; height: auto; border: 1px solid #ddd; border-radius: 4px;"
  />

  <!-- Web player mounts here -->
  <div class="cast-player"></div>
</div>

<div style="height:16px"></div>

<div id="cast-899ead17" class="cast-embed">
  <!-- Fallback image (email/RSS/no-JS) -->
  <img
    class="cast-fallback"
    src="https://raw.githubusercontent.com/danielraffel/asciicinema-output/refs/heads/main/worktree-manager6.png"
    alt="worktree-manager6.cast"
    style="max-width: 100%; height: auto; border: 1px solid #ddd; border-radius: 4px;"
  />

  <!-- Web player mounts here -->
  <div class="cast-player"></div>
</div>

Post Header Injection

<link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/asciinema-player@3.14.0/dist/bundle/asciinema-player.css">

Post Footer Injection

<script src="https://cdn.jsdelivr.net/npm/asciinema-player@3.14.0/dist/bundle/asciinema-player.min.js"></script>
<script>
(function () {
  if (!window.AsciinemaPlayer) return;

  function ensurePoster(rootEl, posterUrl) {
    if (!posterUrl) return null;

    var playerEl = rootEl.querySelector(".ap-player");
    if (!playerEl) return null;

    var posterEl = playerEl.querySelector(".ap-preview-poster");
    if (!posterEl) {
      posterEl = document.createElement("img");
      posterEl.className = "ap-preview-poster";
      posterEl.alt = "Cover image";
      posterEl.style.position = "absolute";
      posterEl.style.inset = "0";
      posterEl.style.width = "100%";
      posterEl.style.height = "100%";
      posterEl.style.objectFit = "cover";
      posterEl.style.zIndex = "2";
      posterEl.style.pointerEvents = "none";
      playerEl.appendChild(posterEl);
    }
    posterEl.src = posterUrl;
    return posterEl;
  }

  function clearPoster(rootEl) {
    var posterEl = rootEl.querySelector(".ap-preview-poster");
    if (posterEl) posterEl.remove();
  }

  function initCast(rootId, castUrl, startAt, endAt, posterUrl) {
    var rootEl = document.getElementById(rootId);
    if (!rootEl) return;

    var fallbackImg = rootEl.querySelector(".cast-fallback");
    var mountEl = rootEl.querySelector(".cast-player");
    if (!mountEl) return;

    var opts = {
      startAt: startAt,
      controls: "auto",
      markers: [[startAt, "Start"], [endAt, "End"]]
    };

    var player = AsciinemaPlayer.create(castUrl, mountEl, opts);

    // When the player is ready on the web: hide fallback + show cover overlay
    var onReady = function () {
      if (fallbackImg) fallbackImg.style.display = "none";
      ensurePoster(rootEl, posterUrl || (fallbackImg && fallbackImg.src));
    };
    player.addEventListener("ready", onReady);

    // Remove cover once playback starts
    var onPlay = function () { clearPoster(rootEl); };
    player.addEventListener("play", onPlay);
    player.addEventListener("playing", onPlay);
  }

  initCast(
    "cast-f60227d3",
    "https://raw.githubusercontent.com/danielraffel/asciicinema-output/refs/heads/main/worktree-manager4.cast",
    9.56,
    36.84,
    "https://raw.githubusercontent.com/danielraffel/asciicinema-output/refs/heads/main/worktree-manager4.png"
  );

  initCast(
    "cast-899ead17",
    "https://raw.githubusercontent.com/danielraffel/asciicinema-output/refs/heads/main/worktree-manager6.cast",
    7.40,
    576.31,
    "https://raw.githubusercontent.com/danielraffel/asciicinema-output/refs/heads/main/worktree-manager6.png"
  );
})();
</script>

How To Install (in Claude Code)

# 1. Add the marketplace
/plugin marketplace add danielraffel/worktree-manager

# 2. Install Worktree-Manager
/plugin install worktree-manager@generous-corp-marketplace

# 3. Install Chainer
/plugin install chainer@generous-corp-marketplace

# 4. Restart Claude Code
# Quit and reopen Claude Code to load the plugin(s)

Worktree-Manager

The first plugin I built is called Worktree-Manager. It’s designed to make creating and managing git worktrees easier —handy when you’re building multiple features in parallel with agents and want to avoid stepping on each other’s changes. Example Commands.

Here’s a quick demo of it in action.

Chainer

The second plugin I built is called Chainer. You tell Claude Code what you want to build, and Chainer figures out which plugin(s) to use and runs them in the right order—end to end. Instead of manually picking tools and stitching steps together, you just describe the goal in natural language and Chainer orchestrates the workflow for you. Example Commands.

In the ~10-minute demo below, I gave it a prompt, and Chainer chose the frontend-design plugin and completed the task end-to-end.

Build a Galaxian-inspired arcade shooter as a single, self-contained index.html (everything inline: HTML/CSS/JS and any shaders), with no server, no build tools, no external libraries, and no external assets—it must run from file:// and on static hosting. Design, implement and build modern arcade features (beyond the original) that add real depth and replayability. Output the complete index.html when you’re done.

Play the game Claude built

Void Hunters

There are probably better plugins for each job, but building these was a great way to learn how Claude Code plugins—and Claude Code itself—work under the hood. I especially enjoyed digging into AskUserQuestion, which turns a wall of text into a guided, multi-step flow.

What an inspiring time to make digital artifacts.

Over the weekend I was gifted an OpenAI ChatGPT Pro account and decided to use it the only way I know how: by immediately building something using Codex that I’ve been annoyed by for way too long.

The problem

When I’m working in Cursor or VS Code with an agent (Codex, Claude, Gemini, etc.), I frequently want a terminal open as a first-class citizen in the editor area—right next to the tabs for the files I’m reading/writing.

Opening an agent in the terminal and moving it manually isn’t a lot of work, but it adds friction that doesn’t need to exist.

Most terminal-focused extensions default to sidebars, which means I’m constantly repositioning the terminals they add. That side-by-side panel layout makes sense when I’m actively co-editing code, but it breaks down when an agent is doing the writing and reviewing for me and I am less "hands on". In those cases, I want the agent’s terminal and the file it’s working on to live as side-by-side tabs in the editor area, each with as much screen space as possible.

To address this I built a tiny extension: Commands: Open Terminal in Editor. You can find it for free in these marketplaces:

• VS Code Marketplace
• Open VSX

Note: The namespace for extensions is quite full and I needed a name quickly. 😂

What my extension does

It adds a status bar button that opens a terminal in the editor area (instead of a panel / sidebar). You can customize the command, nickname, icon, order, whether it appears in the status bar and if it's enabled.

The hard boundary (and why this isn’t “up in the chrome”)

When I started, my intention was to put the button in the same “privileged” place where Claude/Codex-style UI appears—top-right editor chrome / custom toolbar-y areas.

Unless I misunderstood, that's not possible for normal extensions.

Most 3rd party extensions cannot inject UI into:

• the window title bar
• the top-right editor chrome
• overflow menus you don’t own
• macOS traffic-light / native toolbar rows

This seems to be a deliberate VS Code sandboxing decision, and I found no real workaround besides striking a partnership agreement.

Implementation

Instead of fighting VS Code’s UI boundaries, I leaned into the surfaces extensions are allowed to use: an Activity Bar item, Status Bar buttons, and a Command in the Command Palette (⌘⇧P / Ctrl+Shift+P).

The result is a small, configurable system that lets me:

• Define custom agent commands (Claude, Codex, Gemini, or anything else)
• Assign each one an icon
• Choose which agents appear in the status bar
• Open each agent in a terminal that lives in the editor area, side-by-side in a tab with files

In practice, this gives me a status bar button per agent. Clicking one opens a dedicated terminal directly in the editor—no panes, no dragging, no context switching. Below are screenshots.

How I built it

I used Codex as a “pair” for the whole loop:

1. Scaffold an extension
2. Implement the command to open/move a terminal into the editor area
3. Add a status bar item wired to that command
4. Iterate until it felt simple + reliable
5. Package + publish

If you’ve never built a VS Code extension: the workflow is basically TypeScript + the VS Code Extension API, compiled into the out/ directory, with commands declared in package.json.

Local Build & Run Workflow

Prerequisites

• Node.js
• npm
• Marketplace specific CLI tools for publishing (vsce/ovsx)

Install dependencies

From the project root:

npm install

Run this again only if dependencies change.

Compile the project

To build the extension locally:

npm run compile

The extension must compile successfully before it can be run or debugged.

Run & debug the extension

1. Open the project in your editor (e.g. VS Code).
2. Open the Run and Debug activity panel item.
3. Select the extension run configuration.
4. Click the Play ▶️ button.

This launches a new Extension Development Host window containing a fresh project with the compiled extension loaded.

Use this window to:

• Interact with the extension
• Test features and commands
• Observe logs and errors in the Debug Console

Typical development loop

1. Make code changes
2. npm run compile
3. Run / Debug the extension (▶️)
4. Test in the Extension Development Host
5. Repeat

You do not need to restart your main editor—only the Extension Development Host. At first, it can be confusing when a new project window opens, but that’s the environment where the extension runs.

Packaging + publishing (the part that was more annoying than the code)

Writing the code was straightforward. The real effort went into publishing—supporting both VS Code and Cursor required setting up multiple accounts and navigating a maze of hoops.

Why publish to two marketplaces?

• VS Code Marketplace is the main channel for Microsoft VS Code.
• Open VSX matters because IDEs like Cursor rely on it (they can’t just use Microsoft’s marketplace directly), so publishing there makes the extension installable in more places.

Publish to the VS Code Marketplace (vsce)

I had to install Microsoft’s extension packaging tool:

npm install -g @vscode/vsce

Then package/publish the extension:

vsce package
vsce publish

To publish to the VS Code Marketplace, you need an Azure DevOps org + a PAT (personal access token).

The steps I followed:

1. Create a free Azure DevOps account
2. Create an organization (the UI is… quirky):
3. Create a PAT (Personal Access Token) to publish
4. Compile → publish with vsce using the token when requested

Publish to Open VSX Marketplace (ovsx)

For Open VSX I installed their packaging tool and used it as follows:

npm install -g ovsx
ovsx publish -p PAT_TOKEN

Before I could publish there’s a little extra identity/ownership friction:

1. I had to create a free OpenVSX account
2. Create a free Eclipse account and agree to lots of agreements
3. Sign into Open VSX using that Eclipse identity and agree to more agreements
4. Generate an Access Token (to get a PAT) so I can publish the extension
5. Create a namespace to publish the extension under (namespace info)
6. To make the namespace show as “verified”, I filed an issue requesting ownership/verification
7. Compile → publish with ovsx using the token when requested

Cursor verification (extra steps beyond Open VSX)

Cursor adds its own verification layer for Open VSX publishers so folks can search for an extension in their IDE.

What I had to do:

• Host a simple webpage on my own domain
• Link to the published extensions
• Ensure consistent publisher/extension IDs across marketplaces
• Request verification in their forum

Creating all these accounts and “proving you own the publisher identity” chain was the most time-consuming part of this project.

Takeaways

• Building the extension took around 10 minutes.
• While there was no direct monetary cost to publishing, figuring out how to publish across the various marketplaces took longer than writing the code.
• The real constraints are UX sandboxing (where you can put UI) and distribution identity (publishing + verification across ecosystems).
• If you want something usable in VS Code and Cursor, plan for multiple marketplaces + verification steps.

If you want to try it:

• VS Code Marketplace
• Open VSX

The source for this extension is on Github:

GitHub - danielraffel/Commands

Contribute to danielraffel/Commands development by creating an account on GitHub.

GitHubdanielraffel

Your request is invalid or could not be processed by the service
content is not valid Base64

The Root Cause

n8n v2 has a breaking change switching the default binary data storage mode from memory to filesystem(N8N_DEFAULT_BINARY_DATA_MODE=filesystem). This improves performance for large files, but the GitHub node doesn't properly handle the conversion from filesystem-stored binary data to Base64.

In v1, binary data was stored in memory and the GitHub node could directly access and encode it. In v2, binary data is stored as file references, and the node fails to read and encode it correctly.

The Fix

Add an Extract from File node between the binary source and the GitHub node to manually convert the binary data to Base64.

Before (n8n v1 - worked)

HTTP Request → GitHub Node (Binary File: ON)

After (n8n v2 - working solution)

HTTP Request → Extract from File → GitHub Node (Binary File: OFF)

Step-by-Step Solution

1. Add an Extract from File node

Insert it after whatever node produces the binary data (HTTP Request, Read Binary File, etc.) and before the GitHub node.

Configure it with:

• Operation: Move File to Base64 String
• Input Binary Field: data (or whatever the binary field is named)

2. Update the GitHub node

• Turn OFF the "Binary File" toggle
• Set File Content to: ={{ $json.data }}

Working n8n v2 Workflow

{
  "nodes": [
    {
      "parameters": {
        "method": "POST",
        "url": "YOUR_SCREENSHOT_SERVICE_URL",
        "options": {}
      },
      "name": "HTTP Request",
      "type": "n8n-nodes-base.httpRequest",
      "typeVersion": 4.2,
      "position": [400, 300]
    },
    {
      "parameters": {
        "operation": "binaryToPropery",
        "options": {}
      },
      "name": "Extract from File",
      "type": "n8n-nodes-base.extractFromFile",
      "typeVersion": 1.1,
      "position": [600, 300]
    },
    {
      "parameters": {
        "resource": "file",
        "operation": "edit",
        "owner": "YOUR_USERNAME",
        "repository": "YOUR_REPO",
        "filePath": "path/to/file.png",
        "fileContent": "={{ $json.data }}",
        "commitMessage": "Update file"
      },
      "name": "GitHub",
      "type": "n8n-nodes-base.github",
      "typeVersion": 1,
      "position": [800, 300]
    }
  ],
  "connections": {
    "HTTP Request": {
      "main": [[{"node": "Extract from File", "type": "main", "index": 0}]]
    },
    "Extract from File": {
      "main": [[{"node": "GitHub", "type": "main", "index": 0}]]
    }
  }
}

Key Takeaway

The critical change is that in v2, you can no longer rely on the GitHub node to automatically handle binary-to-Base64 conversion when using filesystem storage mode. The Extract from File node bridges this gap by explicitly converting the binary data to a Base64 string before passing it to GitHub.

Tested on n8n v2.1.4 (Self Hosted) with binaryDataMode: filesystem

After some trial and error, I discovered the real cause: I had SoundSource by Rogue Amoeba running, and it was continuously accessing audio. Quitting SoundSource instantly made the purple dot disappear.

It turns out these inner contents are called a zung, or inner relic. When a statue, stupa, or religious structure is created, it’s not considered spiritually “complete” until the zung is inserted in a ceremony of consecration. This isn’t just symbolic decoration—it’s believed to imbue the object with actual spiritual power, enabling it to bless anyone who comes into contact with it.

At the heart of this process is something called the sogshing, a wooden core placed inside the hollow statue. Imagine a slender wooden pillar with a tapered top and a vajra at the base, painted a deep red and inscribed on all four sides with mantras. This sogshing forms the inner spine of the statue.

Wrapped around it in silk are layers of sacred items, such as:

• miniature statues (often of Yeshey Sempa, considered the main relic),
• sacred relics,
• precious metals,
• gemstones.

Then the surrounding space is filled meticulously with rolled mantras, sandalwood, incense powders, and other offerings. Only when everything is in place is the base sealed and the entire statue formally consecrated.

I had always thought of large Buddha statues as either solid or hollow, and quietly empty inside. Realizing that many of them contain carefully arranged scripture, relics, and symbolism made me realize they’re not just objects of devotion—they’re vessels.

From now on, whenever I see one, especially the towering giants, I’ll wonder what prayers and relics are quietly sitting inside, radiating meaning outward.

1. Create a Python virtual environment

python3 -m venv esp32-nat
cd esp32-nat
source bin/activate

Using a venv keeps macOS’s system Python clean and avoids PEP 668 pip restrictions.

2. Install esptool inside the venv

pip install pyserial esptool

This gives you the flashing tool without touching system packages.

3. Download the ESP32-C6 firmware

The original esp32_nat_router repo does not provide ESP32-C6 binaries, but the extended project does:

👉 Releases:

https://github.com/dchristl/esp32_nat_router_extended/releases

For the M5NanoC6, download the latest full build:

esp32c6nat_extended_full_v7.2.0.zip

Unzip it and place the .bin file into:

~/esp32-nat/bin/esp32c6nat_extended_full_v7.2.0.bin

What the filenames mean

• …full… — contains bootloader + partitions + firmware.Use this for the first flash.
• …update… — incremental firmware-only packages for devices already running the extended version (OTA/web UI). Not suitable for a clean flash.

4. Put the M5NanoC6 into USB flash mode

1. Hold the BOOT button (GPIO9)
2. Plug the device into your Mac over USB-C
3. Release the button once connected

Check the serial port:

ls /dev/cu.*

You should see something like:

/dev/cu.usbmodem2101

That’s your device.

5. Flash the firmware (ESP32-C6 uses a single combined image)

From inside your working directory:

esptool --chip esp32c6 \
  -p /dev/cu.usbmodem2101 \
  --before default-reset --after hard-reset write-flash \
  -z --flash-size detect \
  0x0 bin/esp32c6nat_extended_full_v7.2.0.bin

If you see “Hash of data verified,” the flash succeeded.

6. Connect & configure the router

After rebooting, the M5NanoC6 broadcasts a Wi-Fi network:

ESP32_NAT_Router

Connect to it and open:

http://192.168.4.1

Configure:

• STA (upstream) Wi-Fi SSID + password
• SoftAP (your private network) SSID + password

Save & reboot.

Even though the ESP32-C6 supports Wi-Fi 6, the NAT router firmware only operates a 2.4 GHz AP.

Summary

This takes about five minutes and turns a $6 ESP32 board into something genuinely useful: a pocket-sized NAT router with a private SSID, surprisingly useable 2.4 GHZ range, and low power draw. I  wouldn’t rely on it as a full replacement for a more capable, multi-band travel router, but it definitely has its place. Especially, when all you need is to extend Wi-Fi to a low-bandwidth device.

To kick things off, here’s an unedited “Today I Learned” entry: ChatGPT explaining what “based” means.

The slang term “based” has evolved a lot over time, but today it generally means:

Being unapologetically yourself, holding your beliefs confidently, even if they’re unpopular.

It’s often used as the opposite of “cringe” or “trying too hard to fit in.”

Originally, “based” came from the phrase “basehead” (a derogatory term for someone addicted to freebasing cocaine), but rapper Lil B (“The BasedGod”) reclaimed it to mean being true to yourself — not caring what others think. Internet culture then adopted and broadened the meaning.

💬 Examples

1. Confident authenticity

“She told her boss that she wouldn’t work overtime without extra pay.”
→ “That’s so based.”

Meaning: She stood up for herself and didn’t care about being seen as difficult — she’s grounded in her principles.

2. Contrarian opinion (but respected)

“He said he prefers physical books over Kindle because he likes the smell of paper.”
→ “Based.”

Meaning: Even though it’s old-fashioned, it’s honest and respectable.

3. Internet irony or humor

Sometimes people use based sarcastically or ironically:

“He eats cold pizza for breakfast every day.”
→ “Based behavior.”

Meaning: It’s funny and weird, but in a self-assured way — he doesn’t care what others think.

4. Political “based” (used across the spectrum)

In politics, based can mean: Not caring about political correctness; saying what you think even if it’s controversial.

People on the right often use it to praise blunt, anti-establishment statements.

People on the left or center sometimes reclaim it ironically to mean “boldly saying the truth.”

“He said he doesn’t trust either political party because they’re both corrupt.”
→ “That’s based.”(Independent-minded, not afraid to criticize the system.)

“She called out billionaires for not paying taxes.”
→ “Based queen.”(Used in left-wing or ironic internet slang.)

5. Meme culture “based”

Online communities (like Reddit, 4chan, Twitter/X, etc.) popularized based as a meme word — part compliment, part joke.

It can mean cool, confident, or savage, but also used ironically to praise something absurd or over-the-top.

“He unironically wears Crocs to business meetings.”
→ “Extremely based.”(Ironically admiring his confidence.)

“That cat just knocked over a $500 vase.”
→ “Based cat.”(Playful internet humor — rebellion framed as confidence.)

6. “Based and redpilled”

This phrase became popular in some online circles to mean: “Awake to the truth,” especially regarding politics, media, or society.

It comes from The Matrix’s “red pill” metaphor.

However, “redpilled” can sometimes carry extremist or conspiracy connotations depending on context.

So, “based and redpilled” might mean anything from “independent thinker” to “aligned with fringe views.”

“He stopped watching mainstream news and started reading independent blogs.”
→ “Based and redpilled.” (Thinks for himself — believes he’s seeing the truth.)

“She deleted all her social media accounts and started journaling instead.”
→ “Based and redpilled.” (Rejecting digital noise and reclaiming her attention.)

“He built a backyard bunker and says he’s ready for the collapse.”
→ “Based and redpilled.” (Prepper mindset — possibly sliding into conspiracy territory.)

“She explained how algorithms shape what we believe online.”
→ “Based and redpilled.” (Critical thinker calling out systemic influence.)

“He insists every pop song hides subliminal messages.”
→ “Based and redpilled.” (Used ironically — someone who’s taken the idea too far.)

Back in 2023, I started self-hosting this blog using Ghost. It was a great excuse to write more and it inspired me to learn how to use Google Cloud. I wanted to email posts to subscribers, and at the time to do that (easily) with Ghost I had one option: use a bulk mail provider called Mailgun. While Mailgun had a free tier it was mentioned nowhere obvious on their site.

I remember thinking, it’s almost like they didn’t want this plan to exist. (Pin that thought.)

I found a tip instructing me to reach out to Mailgun support asking to downgrade my account to their pay-as-you-go plan:

Mailgun Support — Aug 8, 2023
I understand that you would like to switch to the pay as you go (Flex) plan. We will check and help you on this. Thank you for your request. We are happy to confirm, we have successfully downgraded the account to the requested plan.

I wired everything up and it worked. I sent around 70 emails to a small list. Then one day it stopped working. I don’t even remember how I noticed but I eventually found this in my Ghost logs: Mailgun Error 403: Domain not allowed.

So I opened a ticket with Mailgun and a few days later:

Mailgun Support — Jun 27, 2024
Your account was automatically placed on an evaluation period enforcing limits (100 msgs/hr, max 9 recipients). To help protect our customers against spam, we have automated systems in place to flag accounts that appear suspicious. Sometimes we get it wrong… Please read our Email Best Practices/AUP and answer:
– What types of emails will you be sending?
– Transactional, marketing, or both?
– How do you source email lists/contacts and what are the URLs of these sources?
– Could you please provide the URLs to your Terms of Service and Privacy Policy for our review?
– Expected monthly volume of messages?

Okay. I answered everything, assuming it was a false positive and they’d flip the switch back on. Instead, it escalated:

Mailgun Support — Jun 28, 2024
After reviewing the ticket, it has been determined that we will need to engage another group of colleagues. We are transferring the ticket to them.

And then:

Mailgun Support — Jul 1, 2024
After reviewing your account details and activity, we’ve decided to permanently disable your Mailgun account. Unfortunately, we are unable to fully disclose specific reasons behind this action in order to protect our customers, internal processes, and compliance systems. Our Terms or AUP are available on our website with more information.

No appeal process. No logical explanation. No support number. I tried finding and emailing the CEO William Conway who was ironically, unreachable. After a few more attempts for mercy, I accepted my fate.

Fast forward to October 2025

I stumbled upon a community attempt to add Postmark support to Ghost. Quite a bit of time had elapsed and it didn’t seem to be progressing, but a note from Ghost’s CTO stuck with me with clear guidance: “Make the smallest change you can that moves bulk mail toward an adapter, not built-in.” That was the nudge I needed.

One evening I built the foundation for multiple bulk email providers in Ghost’s newsletter pipeline. A few days later, I extended it with an Amazon SES adapter. SES provides Ghost with a highly affordable, alternative email-sending solution.

Getting locked out of sending a newsletter on my own domain as a legitimate, small sender was demoralizing. I missed sharing my thoughts with others and am glad to have a way to reach out again.

Ghost likely has higher-priority work than adding alternate email providers for self-hosters, so I did my best to follow their guidelines.

Hopefully it’s useful to the Ghost community and maintainers will review and reach out to discuss next steps to explore getting this upstreamed. My sense is folks have wanted more bulk-mail options for a while. I believe it makes Ghost more resilient and more valuable. It’s good timing too since Ghost recently added the ability to email a post without publishing it.

I’m excited to return to a more consistent writing rhythm and share some of the projects I’ve been working on. I’ve actually been publishing pretty regularly—it just wasn’t making it to inboxes. Starting today, that changes.

And if Mailgun ever pulls the plug on your Ghost newsletter too, you’ve now got an alternative. In unsurprising news, Mailgun has discontinued its pay-as-you-go plan.

Update 11/25/2025

I recently came across a simple but effective solution for using AWS SES instead of Mailgun for sending Ghost newsletters — without modifying Ghost’s source code:

GitHub - exlab-code/ghost-cms-amazon-ses-adapter: This project provides a simple but effective solution for using AWS SES instead of Mailgun for sending Ghost newsletters, without modifying Ghost’s source code.

This project provides a simple but effective solution for using AWS SES instead of Mailgun for sending Ghost newsletters, without modifying Ghost&#39;s source code. - exlab-code/ghost-cms-amazon-se…

GitHubexlab-code

The approach I built takes a much more complex path. It’s designed to help Ghost migrate from Mailgun to an adapter model, making SES the first reference email adapter with built-in analytics support — something the above approach doesn’t include. Unfortunately, using my approach currently requires patching Ghost after every update. I do have a script to automate it, but it’s fragile and definitely a bit of a hassle. If Ghost eventually accepts the adapter approach, this should make long-term maintenance much simpler.

My approach also adds open, click, and bounce tracking for SES emails via a lightweight AWS pipeline: SES → SNS → SQS → Ghost (with polling every 5 minutes). I shared SES Setup instructions for the faint of heart.

Great to see there are options out there to suit different needs and preferences!

The Problem

VS Code intercepts Ctrl+K for its own "chord" keybindings, so it never reaches the terminal/REPL. You get a message about waiting for another key instead of clearing the line.

The Solution

You need to override the keybinding in your User keybindings file (not the read-only Default one).

Step 1: Open the correct file

• Press Ctrl+Shift+P → type Preferences: Open Keyboard Shortcuts (JSON)
• Or directly open: code "%APPDATA%\Code\User\keybindings.json"

Step 2: Add this configuration:

  [
    {
      "key": "ctrl+k",
      "command": "-workbench.action.terminal.clear",
      "when": "terminalFocus"
    },
    {
      "key": "ctrl+k",
      "command": "workbench.action.terminal.sendSequence",
      "args": { "text": "\u000b" },
      "when": "terminalFocus"
    }
  ]

Step 3: Save (no restart needed)

Why This Works

The key insight: you need to send the actual control character \u000b, not a command like cls or clear. The REPL uses readline-style keybindings where Ctrl+K is a character sequence, not a shell command.

Now Ctrl+K clears from cursor to end of line, and Ctrl+U clears from cursor to beginning - just like in bash!

“You’ve reached your free plan limit. Your limits will reset on [date].”

But what happens when that date comes? For many of us — nothing.

The reset never actually happens. Instead, the date just quietly moves forward by another month.

This bug has been discussed by hundreds of users in the GitHub Community forum, some for almost a year now. The pattern is the same every time: free users hit the supposed “monthly limit,” wait patiently for the reset, and then find themselves still locked out. No usage, no code completions, no reset.

Why It Matters

GitHub markets a free tier for Copilot, and the documentation promises monthly resets. That’s a fair deal. But when those resets never occur — even if you haven’t used the service — it crosses from “technical bug” into “broken promise.”

To be clear, I don’t believe this is malicious or a sneaky way to drive upgrades. It’s most likely a low-priority bug that’s slipped through the cracks because free-tier users don’t get formal support. Still, this bug sends the wrong message: that “free” users’ experiences don’t matter enough to fix something this visible and easily verified.

A Simple Ask

GitHub, if you really intend to offer a free Copilot tier, please take a look at this bug  — it’s been raised repeatedly by users (here, here and elsewhere.) If it’s been quietly deprecated, just say so. I trust this isn’t malice — it’s likely just low priority and nobody’s bothered to investigate. Still, it wastes people’s time, gives the wrong impression, and comes off very sloppy. Just fix it, or say it’s no longer supported. I trust this isn’t meant as a subtle push to get people like me to reactivate our paid accounts.

Embarrassingly, the cause turned out to be much simpler: I was running AdGuard Home, and one of my blocklists was preventing the device from connecting properly. I’m always amazed that when I run into weird network behavior, my brain doesn’t immediately shout, “Try turning off AdGuard and see if that fixes it!” Fortunately, when it happened again last night, I actually remembered this time — I temporarily disabled AdGuard, and everything worked perfectly.

While Peloton provides a list of domains that need to be allowlisted for the Bike to work I found it wasn’t accurate. At time of writing they don’t list pelotime.com which seems to be required if you want to sync your heart rate data from your Apple Watch during a class.

After some trial and error I allowlisted just the following domains in AdGuard and everything on my Peloton seems to work.

@@||onepeloton.com^$important
@@||pelotoncycle.com^$important
@@||pelotime.com^$important

After updating to macOS Tahoe 26.1, I found that the interface stopped working over USB Audio. For some reason, I could get audio in but not out. I was pretty bummed and tried everything I could think of to fix it. Eventually, a helpful note from Apogee support mentioned that they’d found better results using Thunderbolt instead of USB Audio, and suggested trying a Thunderbridge which I happen to own.

That turned out to be great advice. Yesterday, I tried setting it up but got stuck — I didn’t have a way to connect a Thunderbolt cable. Today, I remembered I actually own a USB-C to Thunderbolt adapter. I was relieved to find that once I plugged everything in and switched the Apogee to Symphony mode, both audio input and output were working again.

Huge thanks to Apogee for taking the time to test this, share that tip and helping me squeeze a bit more life out of this very expensive, end-of-life gear. Really appreciate it.

I started poking around in Activity Monitor, and in the Network tab I noticed something suspicious — Data received: 22.93 GB. That seemed unusually high. Based on a few online suggestions, I downloaded DaisyDisk to get a clearer picture of what was going on.

Seconds after scanning, I found the culprit: the Overcast podcast app.

It had automatically downloaded every podcast I was subscribed to, quietly consuming 912.7 GB of space. I immediately deleted the app and the Overcast Container folder, reclaiming nearly a terabyte.

I like to occasionally use Overcast on desktop, so I’ll reinstall it — but next time, I’ll switch the default download option from automatic to manual. Definitely user error on my part, but wow. A startup alert in the app about massive disk usage would’ve been appreciated.

But here’s the best part: it also works on some older AirPods Pro models — specifically the AirPods Pro (2nd generation) and AirPods Pro (3rd generation) — when paired with an iPhone 15 Pro or later running the latest firmware. It’s not heavily advertised (likely because Apple wants to promote it as a new-model feature).

Learn more about how to set it up →

I tried a range of fixes—recreating automations, toggling Home’s location permissions, upgrading Homebridge, and updating several third-party plugins—without success. The following steps show how I fixed Home app location automations. They almost certainly involve more toggling than needed, but this approach worked for me:

1. Go to: Privacy & Security → Location Services → System Services
   Disable:

• Alerts & Shortcuts Automations
• Device Management
• Home Accessories
• Significant Locations & Routes
• Improve Location Accuracy

2. Then go to: Privacy & Security → Location Services → Home
   Disable:

• Home Location access (for both app setup and Home app use)

3. Reboot your iPhone.
4. Return to: Privacy & Security → Location Services → System Services
   Re-enable:

• Alerts & Shortcuts Automations
• Device Management
• Home Accessories
• Significant Locations & Routes
• Improve Location Accuracy

5. Go back to: Privacy & Security → Location Services → Home
   Re-enable:

• Home Location access (for both app setup and Home app use)

6. Reboot once more.
7. Privacy and Security -> Location Services -> Home

• Re-enable:
  • Home Location access (for both App setup & Home app use)

6. One more iPhone reboot!

💡 Additional Discovery: things were more mixed up than I realized

• While I didn't change this setting I found that my automations in the Home app had switched to using my iPad for location instead of my iPhone.
• To fix it, on my iPhone I went to Settings → [My Apple Account] → Find My → My Location and changed it to This Device.

Afterwards, I confirmed that the Home app was again using my iPhone for location in my geofence automations.

I’ve updated my Ghost updater script to fully support migrating from Ghost 5 to Ghost 6, for instances installed with the companion Ghost Google Cloud installer — which has also been updated for v6 compatibility.

The new release streamlines configuration, improves SSH handling, and ensures Node.js version selection matches Ghost’s requirements. It will backup and update your instance, and you can continue using it for future updates to Ghost v6.

GitHub - danielraffel/gCloud-Ghost-Updater: A user-friendly script designed to reduce downtime while updating a Ghost instance hosted on Google Cloud.

A user-friendly script designed to reduce downtime while updating a Ghost instance hosted on Google Cloud. - danielraffel/gCloud-Ghost-Updater

GitHubdanielraffel

While running my own upgrade, I also discovered a few changes were needed for both my nginx config and my Ghost config. I’ve documented these below. They require manual edits and are not included in the update script.

Note: I've only lightly tested the updater script on macOS.

1. Script Enhancements

• .env overrides file
  • Added support for .env overrides with sensible defaults.
  • Environment variables now control key parameters.
• Node.js version selection
  • Prefers engines.node (major) from current/package.json if available.
  • Falls back to the Ghost-supported major from the helper script if not.
• SSH improvements
  • SSH_KEY_PATH is optional — if it doesn’t exist, SSH falls back to your agent/default identities.
  • All SSH/SCP calls now consistently use ${SSH_USER} and $SSH_IDENTITY_OPTS.
• New environment variables
  • SSH_USER, SSH_KEY_PATH, LOCAL_NODE_VERSION_SCRIPT, RESOURCE_POLICY_NAME
  • SPEEDY_MACHINE_TYPE, NORMAL_MACHINE_TYPE
  • SSH_CONNECT_TIMEOUT, SSH_MAX_ATTEMPTS, SSH_RETRY_SLEEP

2. Nginx Configuration Changes

While upgrading, I could not access the new Network tab so I had to manually update my /etc/nginx/sites-available/ configs for ActivityPub and federation endpoints. These need to be applied in both SSL and non-SSL server blocks.

Non-SSL Example

# ActivityPub proxy (HTTP)
location ~ ^/\.ghost/activitypub/ {
    proxy_set_header X-Forwarded-For   $proxy_add_x_forwarded_for;
    proxy_set_header X-Forwarded-Proto $scheme;
    proxy_set_header X-Real-IP         $remote_addr;
    proxy_set_header Host              $host;
    add_header X-Content-Type-Options  nosniff;
    proxy_ssl_server_name on;
    proxy_pass https://ap.ghost.org;
}

# Well-known federation endpoints
location ~ ^/\.well-known/(webfinger|nodeinfo)$ {
    proxy_set_header X-Forwarded-For   $proxy_add_x_forwarded_for;
    proxy_set_header X-Forwarded-Proto $scheme;
    proxy_set_header X-Real-IP         $remote_addr;
    proxy_set_header Host              $host;
    add_header X-Content-Type-Options  nosniff;
    proxy_ssl_server_name on;
    proxy_pass https://ap.ghost.org;
}

SSL Example

# ActivityPub endpoints (proxy to Ghost AP service)
location ~ ^/\.ghost/activitypub/ {
    proxy_set_header X-Forwarded-For   $proxy_add_x_forwarded_for;
    proxy_set_header X-Forwarded-Proto $scheme;
    proxy_set_header X-Real-IP         $remote_addr;
    proxy_set_header Host              $host;
    add_header X-Content-Type-Options  nosniff;
    proxy_ssl_server_name on;
    proxy_pass https://ap.ghost.org;
}

# Well-known federation endpoints
location ~ ^/\.well-known/(webfinger|nodeinfo)$ {
    proxy_set_header X-Forwarded-For   $proxy_add_x_forwarded_for;
    proxy_set_header X-Forwarded-Proto $scheme;
    proxy_set_header X-Real-IP         $remote_addr;
    proxy_set_header Host              $host;
    add_header X-Content-Type-Options  nosniff;
    proxy_ssl_server_name on;
    proxy_pass https://ap.ghost.org;
}

I discovered these nginx conf changes were added by the Ghost team via a post on the Ghost forum.

3. Temporary Ghost Config Fix

During the upgrade, I discovered my install didn’t have an email service configured — which blocked staff login. As a temporary workaround Cathy Sarisky kindly suggested disabling staff device verification in config.production.json:

"security": {
  "staffDeviceVerification": false
}

Note: This is not a long-term solution. The proper fix is to configure a working mail service.

Created a simple Alex Markdown that helps ensure that checkpoints and commits occur while working and feature development occurs on branches.

Created a simple Alex Markdown that helps ensure that checkpoints and commits occur while working and feature development occurs on branches. - ALEX.md

Gist262588213843476

Note: This was inspired by Chorus.md

Apple just released the macOS 26 beta at WWDC, and if you're doing any kind of iOS or macOS development, it's a great time to spin up a test environment without risking your main system.

A while back, I shared a guide on how to install macOS on macOS in a virtual machine using UTM on macOS. That guide still works perfectly for macOS 26—there’s just one small extra step if you want to install the beta version.

After setting up your VM with a working version of macOS:

1. Sign in to your Apple ID using your developer account inside the VM.
2. Head to System Settings > General > Software Update.
3. Enable Beta Updates and choose macOS Developer Beta.

From there, the system will detect and install the latest macOS 26 beta (a.k.a. macOS Tahoe). I’ve updated the original guide with this tweak, but wanted to call it out here separately since it’s the only real change.

I wanted to be able to hit Cmd+Shift+B in Sweetpad and have it run the project using one of the defined Xcode schemes.

But because the .xcodeproj was being placed inside build/ — not the root folder — Sweetpad kept failing with errors like:

ENOENT: no such file or directory, open '...project.xcworkspace/contents.xcworkspacedata'

✅ Here’s how I got it working:

1. Create a .vscode folder at the root of the source project (not in build/).
2. Inside that, add a settings.json file with this content:

{
  "sweetpad.workspacePath": "build/PlunderTube.xcodeproj",
  "sweetpad.build.configuration": "Debug",
  "sweetpad.build.scheme": "PlunderTube",
  "sweetpad.build.sdk": "macosx"
}

3. Reset Sweetpad’s cache via the command palette (Cmd+Shift+P → Sweetpad: Reset Extension Cache).
4. Rebuild the project in CMake.
5. Then…Cmd+Shift+B worked to rebuild the project.

Now Sweetpad recognizes the generated .xcodeproj and lets me build and run the Xcode scheme as expected, directly from the VS Code interface — even though everything lives inside a build/ directory.

Recently I've been playing around with making audio plugins on macOS using JUCE. I ended up putting together a few simple scripts to make it easier to quickly spin up new audio projects.

The JUCE Plugin Starter repo includes:

• A script to install all required dependencies outside of Xcode (like CMake and PluginVal).
• A quick setup flow that clones the repo with the template and scripts.
• A script that walks through reinitializing and renaming the repo so you can start a fresh plugin project, configure .env variables, and publish it to your own GitHub account.
• A script to generate the Xcode project and open it, which has been helpful when making changes that require rebuilding the project file.

The simplest way to get everything running is to just copy and paste the following into your terminal. That said, these commands execute several scripts and install multiple components, so it’s wise to review the full README first to understand what’s happening and avoid any surprises.

# Install required tools (Xcode CLT, Homebrew, CMake, PluginVal, etc.)
bash <(curl -fsSL https://raw.githubusercontent.com/danielraffel/JUCE-Plugin-Starter/main/dependencies.sh)

# Clone the starter project and set up environment
git clone https://github.com/danielraffel/JUCE-Plugin-Starter.git
cd JUCE-Plugin-Starter
cp .env.example .env

# Run the first-time setup to configure your plugin project
chmod +x ./init_plugin_project.sh
./init_plugin_project.sh

# Generate and open the Xcode project (downloads JUCE on first run)
chmod +x ./generate_and_open_xcode.sh
./generate_and_open_xcode.sh

Once your plugin is built and tested, you can package it for safe, notarized distribution using the sign_and_package_plugin.sh script.

• The script signs, notarizes, and staples each format
• All formats are bundled into a single .pkg installer
• The .pkg is signed and notarized
• Finally, the .pkg is included in a ready-to-share .dmg

Maybe this is only useful to me as a way to prototype new ideas, but if it helps others get started, awesome. The Xcode project template the repository generates sets you up to build a Standalone App, AU plugin (for Logic, GarageBand), and VST3 plugin (for Reaper, Ableton Live, etc.).

GitHub - danielraffel/JUCE-Plugin-Starter

Contribute to danielraffel/JUCE-Plugin-Starter development by creating an account on GitHub.

GitHubdanielraffel

Update: After creating this, someone pointed me to a more feature-rich template called pamplejuce.

• Running Autonomous Agents in Isolated macOS Environments
• How to install macOS in UTM
• Enabling Beta Versions of macOS in Your VM
• Lessons Learned

Running Autonomous Agents in Isolated macOS Environments

Lately I’ve been experimenting with a range of autonomous agents, some of which run locally on my Mac. To keep these processes sandboxed, I’ve started isolating each one in its own containerized environment. One of the main reasons I started isolating agents in VMs is that they sometimes hijack the mouse and keyboard—making my system nearly unusable while they're running. When I need to run something on macOS in isolation, UTM has been the simplest way to set up a lightweight macOS virtual machine. Just a heads-up: it only works on Apple Silicon.

UTM wraps around QEMU (a powerful, open-source emulator) but hides most of the complexity. You also have the option to use Apple’s Virtualization framework, which tends to run faster and integrates better with Apple Silicon. For macOS VMs, that’s what I use.

What I like about this setup is how quick it is to get started. UTM can boot from an existing macOS recovery partition, which means you don’t have to track down an installer unless you really want or need to. You can switch between your main system and a clean VM environment in seconds. It’s fast enough to be practical, and it doesn’t mess with the host.

A note on licensing

Apple allows you to run up to two virtual instances of macOS on a Mac, in addition to the main OS. As long as you’re using an official .app or IPSW installer and staying within that limit, you’re within the bounds of their terms. This seems aimed at supporting developers, researchers, and similar use cases—while also drawing a clear line to prevent anyone from spinning up macOS as a hosted service.

How to Setup macOS in UTM

If you're curious, here’s a quick overview of the setup process using UTM on macOS. The screenshots below show what you'll see along the way:

1. Start Screen

When you open UTM and click Create a New Virtual Machine (eg + UTM), you’ll see the choice between Virtualize (for native CPU architecture, faster) and Emulate (for other CPU types, slower). For macOS on Apple Silicon, stick with Virtualize.

2. Choose the OS

UTM offers preconfigured options. Pick macOS 12+.

3. Import or Download the macOS Installer

Here you can either point to an IPSW file or let UTM fetch it from Apple automatically. If you have the option to continue without selecting a file, UTM will use the installer on your boot partition.

If you want or need an IPSW file, you can look here:https://ipsw.me/product/Mac. These files usually point to Apple’s CDN, but it’s worth double-checking the URL to ensure it hasn’t been hosted and/or potentially modified by a third party.

4. Set Resources (RAM and CPU)

This screen lets you assign memory and CPU cores to your VM.

5. Set Disk Size

Specify how much storage to allocate.

6. Summary Screen

Here’s where you review the configuration. You’ll see the engine (Apple Virtualization), storage size, RAM, and the path to the IPSW installer if one is selected. I recently had to have my Mac re-imaged at the Apple Store, so I’ve now get a much newer installer than the one it originally shipped with.

7. VM Appears in UTM

Once saved, your VM shows up in the sidebar. You can launch it any time from here. It will take a little time to install.

8. macOS Installer Downloading

If you skipped adding an IPSW earlier, UTM begins downloading it now. The terminology might say "downloading" but it’s really copying from the boot partition. You can cancel it at any time.

9. Launch the VM

Once the installer has fully copied over, your new macOS VM will appear in the left-hand sidebar. Just hit the play button to launch it.

10. macOS Boots in a New Window

The VM will start in a separate window. From here, you can go full screen and walk through the usual macOS setup process. Once it’s up and running, you’ve got an isolated, fast macOS environment to experiment with.

Although you can enable file sharing to share folders between the host and guest, direct drag-and-drop file transfer between windows is not supported. 😔

Enabling Beta Versions of macOS in Your VM

Want to run the latest macOS betas—like macOS 26 "Tahoe"—in your VM? Once you've completed the standard macOS installation and setup steps above, it's just a matter of opting into beta updates:

1. Sign in to your Apple Developer account from within the VM:
   1. On the Mac inside the VM, go to  Apple menu > System Settings.
   2. Click your name at the top of the sidebar.
      1. If you don’t see your name, click Sign in and enter your Apple Account email or phone number, then your password.
   3. Complete the process by clicking Sign in with Apple to authenticate your Developer account.
2. Open System Settings > General > Software Update.
3. Click Beta Updates and select macOS Developer Beta.

From there, the system will prompt you to download and install the latest available macOS beta. This is especially handy for developers working on macOS or iOS software who want to test against upcoming changes without risking their main environment.

✅ Note: This step is completely optional. If you're not working with beta software, you can skip it entirely and stick with the stable macOS release you originally installed. But, now you know how to run macOS 26 Tahoe Beta in a VM on Your Mac using UTM.

That’s it. Once the setup is done, you’ll have a fully functional macOS environment you can run in parallel to your main system. Useful for dev testing, isolating risky processes, or just giving agents a safe sandbox to play in.

Lessons Learned

Here are a few tips and workarounds that have made it easier to do Xcode development inside the client VM:

1. Apple prevents logging in to the App Store from virtualized VMs. If you need apps you’ve purchased, download them on the host and copy them over. When I first tried this, I hadn't signed in to my Apple Account under  Apple Menu > System Settings. Once I did that, app downloads worked—classic oversight! 😅
2. Drag and drop doesn’t work. Setup shared folders in UTM. Just be thoughtful about what folders you share—if your goal is to sandbox AI tools safely, limit access on your host machine to only what’s absolutely necessary.
3. Clipboard copying doesn’t work. I use an app called Clipboard Remote to transfer clipboard content between the host and the VM over the local network.
4. Obviously, SSH keys don’t automatically carry over. Either copy them from your host machine (or generate scoped ones for the VM):

scp -rp ~/.ssh/* username@MACOS_UTM_CLIENT_IP:~/.ssh/

4. For Xcode and Command Line Tools on the client VM, I downloaded them via Apple’s developer site.
5. c/ua looks like a promising alternative to hosting macOS in UTM, but it’s still early days—I’m not quite ready to recommend it just yet unless you're a developer.

It’s a Slack-native bot that can fully own engineering tasks. You can ask it to do things like build a feature from a Figma file, implement a product spec, or fix a bug. It handles the entire workflow: writing code, running unit tests, making revisions, and ultimately committing to your repo for human review.

The software is still in alpha and a bit rough around the edges, but it’s surprisingly capable. And while the tech itself is impressive, what stood out in our conversation was the complexity of introducing it to a team.

Unlike most developer tools that support engineers, this one can independently ship full features—even tackle complex projects without human intervention. That shift raises thorny questions: Who owns the output? Could it replace someone’s role? How should performance be measured? And how do you introduce it without triggering fear or resistance?

My suggestion: Treat this as a series of structured experiments on the path to potential adoption—and be transparent throughout. Start with a pilot project co-led by members of your product, design, and engineering teams. Pick something that’s not on the active roadmap: ideally, work that’s difficult to prioritize or too disruptive to fold into active development. Avoid using a marquee feature the team is already excited to build.

This lets you complete lower priority work while evaluating the tool’s value. Make it clear this isn’t a stealth effort to replace the team. It’s a structured trial to assess the tech’s maturity, identify what kinds of projects (if any) it's best suited for, and define roles clearly—using your preferred RACI framework or equivalent—so no one is caught off guard.

I also highlighted a near-term shift: while engineers have already embraced AI coding assistants, this exploration isn’t just about encouraging their adoption of autonomous tools. It’s about evaluating whether certain technical work—like feature development or bug fixes—can proceed with less direct involvement from engineers than has traditionally been required.

Engineers will remain essential, especially for high-complexity tasks, oversight, and code review. But their role may increasingly involve responding to work initiated by AI tools and orchestrated by team members outside of engineering. That’s a meaningful shift—one that could reshape team structure, ownership, and how work flows across the organization.

If an autonomous coding tool proves valuable and you decide to bring it into regular use, mark that moment clearly. Recognize the shift—acknowledge what’s changing, reaffirm team roles, and make space for discussion. This helps ensure the transition feels intentional, not incidental.

Eventually, I think most of us will work alongside AI teammates. For tech companies, that might look like Slack bots taking tickets, writing code, and shipping updates. That future isn’t fully here yet for most companies to consider adopting—but it’s getting close. Forward-thinking teams should start shaping how they evaluate and integrate these tools now. Soon, it won’t be easy to compete with teams that are using AI across more phases of development—and just as easy to fall behind.

Curious, I looked it up.

As it turns out, the expression "soup to nuts" dates back to formal American and British dining customs in the 19th and early 20th centuries. In those multi-course meals:

• Soup was typically served first
• Nuts came last, often offered with port or sherry after dessert

So the phrase literally referred to the entire meal experience, from the very first spoonful to the final nibble. Over time, it became a popular idiom meaning "the whole thing" or "start to finish."

The phrase began showing up in print in the early 1900s, gradually shedding its culinary roots and finding new life in business, storytelling, and tech — anywhere someone wanted to talk about something being handled comprehensively.

• Command + ` — switch to the next window
• Command + Shift + `— switch to the previous window

It works in Safari, Finder, Notes—basically any app with more than one window open. Super handy when juggling multiple Safari windows. Just wish I’d learned it earlier.

I decided to take a more drastic step. I wiped the machine completely and reinstalled macOS from scratch. Still no luck.

This MacBook Pro is four years old, maxed out with RAM and GPUs, and originally cost over $5k. The idea of needing to replace my computer right as a new round of U.S. tariffs kicked in was less than ideal. I ran Apple’s built-in diagnostics at home, and to my surprise, there were no physical hardware errors. But something still wasn’t right.

Mysterious Disk Errors

I booted into Recovery Mode and ran fsck_apfs, which started throwing a bunch of low-level errors like:

error: doc-id tree: record exists for doc-id #####, file-id ####### but no inode references this doc-id

These messages essentially mean that the file system had become partially corrupted at a structural level—likely deep in the APFS (Apple File System) metadata. These aren’t your everyday permission errors; they’re signs of serious inconsistencies.

I did everything I could think of: Safe Mode, Disk Utility, Terminal repairs, a full wipe. Nothing worked.

Genius Bar to the Rescue

As a last resort, I made a Genius Bar appointment at the Stonestown Apple Store. When I brought it in, the initial diagnostics (Mac Resource Inspector) showed no hardware failures. But I could still reproduce the issues—and Disk Utility errors kept showing up at home, even if the in-store tools didn’t catch them.

That’s when the Apple tech offered something I hadn’t tried (and am unsure I could do myself): they would keep the machine for 24 hours and run more advanced diagnostics. More importantly, they would use Apple Configurator to perform a deep-level wipe and reinstallation, which not only restores macOS but can also update low-level firmware and reset the entire APFS container from scratch.

In other words: this wasn’t just reinstalling the OS—it was a true factory reset, deeper than any tool I had access to.

The Result? A Brand New Mac (Almost)

They not only reimaged the machine with the latest version of macOS Sequoia, but also wiped and rebuilt the system partitions in a way I couldn’t have done myself. After I picked it up, the machine felt brand new. The beachballs were gone. The disk errors? Completely vanished.

I’m not entirely sure how much of that process I could’ve replicated on my own—even with Terminal or booting into DFU mode—but I’m grateful they did it. Even more so because I’m out of warranty, and they did it all for free.

Bonus: A Ride to Remember

While they worked on my Mac, I took the liberty of going for a 62-mile bike ride that day.

The day turned out to be unexpectedly great on two counts—I got my machine back in working shape, and I got a ride in I might not have otherwise made time for. I picked up my Mac in my cycling clothes.

Big thanks to the folks at the Stonestown Apple Store. You took care of me and my machine when I really needed it.

Steve — my longtime friend and neighbor — and I used to occasionally compare notes on our energy use. After both installing nearly identical solar setups, we no longer need to trade utility bills. Instead, we’ve turned our solar production and energy consumption into a daily, automated solar showdown between our homes — a bit of friendly competition that not only keeps things fun, but also gets us checking our own stats more often and thinking regularly about how to be more efficient and environmentally mindful each day.

🎯 How It Works

Every hour, our solar inverters send stats to a shared GitHub data repo, via our home servers (both of us run Proxmox).

At the heart of it is the solarshowdown-api — a lightweight Go service that pulls data from InfluxDB, packages it up as a JSON file, and posts it directly to the data repo.

The frontend — a simple, responsive page built with vanilla JavaScript and CSS hosted on GitHub pages — reads from these JSON files and displays a live head-to-head dashboard showing:

• 🌞 Solar Power Generated
• 🌿 Energy Consumed
• ⚡ Energy Sold to the Grid
• 🔌 Energy Imported from the Grid
• 🔋 Battery Discharge
• ⚡ Peak Solar Array Power Generation

🏆 Daily Solar Champion

Each day, the page calculates a Net Score and crowns a champion based on performance. Bonus categories add a twist:

• Solar MVP (most generated)
• Grid Hustler (most sold)
• Energy Vampire (most consumed 😅)
• Battery Boss (most discharged)
• Peak Performer (highest peak)
• Net Champion (overall winner)

And, if you share the link to the page the social preview will update daily via JS — so whoever’s on top gets the spotlight!

📈 About the Project

Want to start your own showdown? Everything is open source, the backend API and frontend are hosted on GitHub.

One particular roadblock? My Apogee Symphony I/O MKI which has been sunset by Apogee. While the last software installer technically supports Apple Silicon, the official installer still requires Rosetta to run. And since there’s no way to uninstall Rosetta once it’s on your system, I didn’t want to install it just for the sake of running a legacy .pkg file.

So… I didn’t.

🛠️ What I Did Instead

I used Suspicious Package — a fantastic little tool that lets you inspect and extract files from .pkg installers — to manually extract the application files, plug-ins, daemons, and kernel extensions from the Apogee installer DMG.

Even better, Suspicious Package let me inspect the installer’s postflight script, which revealed exactly what the official installer does — like creating the .plist file that registers the Symphony system and I/O components. This gave me confidence that I could fully replicate the install process with a shell script.

From there, I wrote:

• An installer script that mimics the official installer (minus Rosetta)
• An optional uninstaller that removes all files and settings cleanly

The process involves a few extra steps, like manually placing extracted files and enabling “Reduced Security” mode to allow the legacy drivers, but it works great — and it avoids installing anything unnecessary.

🔍 For Anyone Else Running Into This…

If you’re a fellow Symphony MKI user on an Apple Silicon Mac and want to avoid Rosetta too, I documented everything and shared the scripts here:

👉 GitHub Repo: symphony-mki-installer-sans-rosetta

The repo includes:

• A step-by-step guide
• Download links for the official installer
• Screenshots of what to expect
• Detailed instructions for using Suspicious Package to extract only what you need

⚠️ Important Note: This project does not redistribute Apogee software — just scripts and instructions. You’ll need to download the official installer yourself and extract files locally.

🙌 Credit Where It’s Due

Big thanks to the developer of Suspicious Package — it’s one of those tools you don’t realize you need until you really need it. It made this process possible. And thanks to Apogee for enabling Apple Silicon support for this audio interface before sunsetting support. They certainly didn’t need to and I’m very appreciative that they did. 👏

⚠️ Disclaimer

This is a community workaround.

I’m not affiliated with Apogee, and this project isn’t endorsed by them.

Everything is shared as-is, without warranties. Use it if it helps — and use it carefully.

This time, I decided to use nvm (Node Version Manager) to locally manage Node.js (v20, recommended by Ghost). Using nvm allows each project directory to have its own specific Node version, avoiding clashes. To streamline this, I created a simple script that sets everything up automatically:

• Installs Node.js v20 with nvm
• Sets up Ghost locally
• Adds local development tools like yarn and gscan

Optional manual step: Automatically switches to the correct Node version when you enter the directory (enabled via an addition to your .zshrc).

Now, when I want to remove or reset the setup, it's as simple as deleting the project folder—minimal residue left behind to cleanup.

If you’re curious or want to use the same setup, check out the repo on GitHub.

Why I Rarely Open Xcode Anymore

For the past few months, I’ve been using Sweetpad, a macOS extension that integrates with VS Code-based editors like Cursor. It’s completely changed how I approach Apple app development. I can now build native iOS, watchOS, and macOS apps directly in Cursor—and deploy them from the terminal—without constantly relying on Xcode.

That’s not to say I never touch Xcode anymore—but I do so far less frequently.

How My Workflow Changed

With Sweetpad, I can:

• Select my app target
• Choose a simulator or real device
• Build and deploy—all from within Cursor

This means less context switching and more time using Cursor’s powerful AI code models and smarter completions. I've found it to be a productivity win.

Custom Keyboard Shortcuts in Cursor

I've mapped a few shortcuts in Cursor’s terminal for everyday tasks:

• Cmd+Shift+K → Clean builds
• Cmd+Shift+B → Build & run

Once triggered in the terminal, Cursor lets me pick the destination device (simulator or real) streamlining testing.

Hot Reload with InjectionIII

For UI iteration, I use InjectionIII, which adds hot-reloading to SwiftUI views. It lets me see changes without doing a full redeploy—huge time-saver for fiddly frontend tweaks.

Where I Learned This

I picked up these tools from the Cursor Masterclass by Rudrank Riyam and Ray Fernando. I expected the Cursor + Sweetpad workflow to feel hacky—but I was genuinely impressed. It’s smooth, modern, and lets me stay inside a developer-friendly, AI-enhanced environment.

My Swift Rules for Cursor

I’ve published a Cursor rules file (Markdown) for Swift iOS development. It includes:

• Sweetpad build support
• InjectionIII hot reload integration
• VIPER architecture scaffolding
• SwiftUI best practices

Note: These rules are heavily inspired by the Swift Cursor Rules from Ray Fernando & Lou Zell and include some verbatim text with attribution.

When I Still Use Xcode

As my projects grow more complex—like handling shared data in app groups across iOS and watchOS—I still turn to Xcode for things like:

• Debugging multiple simulators
• Managing entitlements
• Deep integration testing

I've also been experimenting with Alex Sidebar, a tool that brings AI assistance alongside Xcode. It's a huge step up from what Xcode offers out of the box and offers many of the benefits of using Cursor with Sweetpad.

Final Thoughts

For someone new to Swift, tools like Sweetpad and Cursor have significantly streamlined Apple app development. I’d love to see Apple adopt AI-native workflows that match the quality of these tools. In the meantime, they’ve been instrumental in helping me build quickly and efficiently.

Lately, though, more and more websites are catching on and throwing up “please disable your ad blocker” messages. Out of curiosity, I tried something today on my iPhone: I opened the page in Mobile Safari, tapped “High Distracting Items,” selected the overlay—and just like that, it too disappeared. While my testing has been limited, the change on iOS and iPadOS appears to be persistent.

On macOS, the experience is a bit different. When attempting to remove the same content, a disclaimer appears: “Hiding distracting items will not permanently remove ads and other content that update frequently.”

The “Hide Distracting Items” feature seems to apply only to the device where it’s used—it isn’t synced across iOS, iPadOS, and macOS. So if you want to hide the same element on a page across all your devices, you’ll need to do it separately on each one.

Using samplers to mangle audio reminds me of the creative possibilities available using AI today. Just as it was possible to process sounds into something new, it’s possible to combine data and algorithms using AI to generate images, video, text, and code that not only surprises but has its own distinct essence. However, while these possibilities excite me, for some others, venturing into the realm of AI isn’t as fun sounding.

Current Barriers to Adoption

Let’s start with the obvious: the world is heavy right now. Between political drama, economic instability, and an endless stream of global uncertainty, even people who are doing “fine” are often just trying to get through the day. Their focus is largely divided between managing daily responsibilities and seeking relaxation. Engaging with new technology demands cognitive and emotional resources that are often depleted.

The Emotional Weight

There’s a lot of emotional baggage that comes with AI. For some, it doesn’t feel exciting—it feels dystopian. Instead of being empowering, it feels like it’s eroding the very things that give people purpose, security, or even joy. It can feel like a threat—not just to people’s livelihoods and craft, but to their sense of identity and their legal rights. For others, playing with tech just isn’t that interesting—or how they ever wanted to spend their time.

When First Impressions Fail

Even when people do try out new AI tools, the initial experience often isn’t great. I’ve demoed tools like Cursor—which I imagine would be an absolute gift for many folks working at tech companies—and discovered some never opened it again. Using an IDE can be daunting if you’re not accustomed to spending your days in one, so it’s perfectly reasonable for people to move on if they don’t quickly connect with it.

Cursor—and many other AI tools—are evolving at breakneck speed. This rapid development not only introduces genuine innovation but also brings bugs, broken features, and unpredictable changes. Getting the most out of these tools requires frequent use and unconventional thinking, best achieved through playful tinkering. This approach can uncover new ways to utilize the technology that might not be immediately obvious.

For those accustomed to stability and who already excel in their current roles, these tools might initially seem like a step backward. Similarly, if you’ve previously struggled with learning technical skills, it’s easy to feel that these tools aren’t suitable—especially now, when time and energy to learn something new are particularly scarce. Fortunately, there is a wealth of tutorials available online, both free and paid, that can help bridge this gap quickly. These resources are designed to flatten the learning curve, offering step-by-step guidance that can accelerate your proficiency and confidence in using these tools.

Diverse Reactions

In my circles, I’ve noticed a divide: generalists tend to be more inclined to explore and experiment, while specialists tend to be more skeptical—often focused on where the tools fall short.

For example, most of the experienced engineers I know are used to picking up new technologies in a very deliberate way: reading the docs, diving into the language, working through tutorials. They’re thoughtful and methodical—and usually not interested in engaging with something in a half-baked manner. When AI spits out buggy code in a language they’ve mastered, it’s not just frustrating—it feels amateur and they don't want any part of it.

On the other hand, I’ve also seen folks who are newer to a field, or simply less technical overall, who just want to jump in and make things. For them, AI is a creative unlock. It allows them to accomplish in a short amount of time what used to take weeks or months—work they didn’t have the time, patience, or ambition to tackle before. They’re not chasing perfection—they’re chasing momentum. For them, AI unlocks capabilities they haven't developed on their own. Whether the code is well-written or not doesn’t matter—they don’t know, and frankly, don’t care.

Both of these reactions, and a spectrum in between, are valid. One person sees AI as a toy or a threat. Another may see it as the beginning of Something Big. General purpose technologies reshape entire industrial sectors, so it’s no surprise they spark strong, polarized responses.

For those with deep experience, choosing not to engage with tools that feel unpolished isn’t wrong—it’s often a sign of discernment and maturity. But this moment also calls for shoshin—a beginner’s mind. A mindset rooted in curiosity, openness, and a willingness to explore new ways of working, even when things are still rough around the edges.

How to Build Intuition

No matter where you stand, one thing is clear: these tools aren’t going anywhere. For those expecting plug-and-play solutions, it might be surprising to realize that their real power lies in unlocking entirely new ways of thinking and working.

Using AI tools effectively often requires reimagining familiar workflows, adapting to shortcuts, and embracing alternative paths to the same outcome—sometimes faster, sometimes messier. Doing your best work in this new landscape requires not just learning how and when to use these tools, but also being open to how they can reshape your creative or professional process entirely. As you navigate this new landscape, don’t be surprised if you find yourself chasing your tail at times.

That kind of adaptation takes trial and error: testing things out, hitting walls, stepping away, and coming back later. It’s less about judging a tool’s value in the moment, and more about building the muscle to understand where it fits, how it works, and when it truly shines. Have fun with it. Be playful.

Simon Willison’s ongoing experiments prompting vision models to generate images of a “pelican riding a bicycle” are a great example. He’s using a lighthearted, familiar prompt to consistently test what the latest models can do. This approach to monitoring advancements in state-of-the-art image generation models has been both delightful and engaging.

Consider staying open—even if your first experience wasn’t great. I’m not suggesting you throw the same problem at every new model or force AI into everything you do. But it’s worth returning with fresh challenges and noticing what works and what doesn’t. Over time, you’ll build intuition—for when to lean in, when to walk away, and which tools are the right fit for the job. More often than not, what you discover will surprise you.

Corporate Resistance

AI has the potential to reshape how we build software products. But embracing that potential isn’t just an individual challenge—it’s a cultural one.

As one experienced product manager recently put it (paraphrasing):

"AI can and should transform how we build software. But many companies—especially larger ones—aren’t embracing that shift. There’s still a strong preference for specialists, even though AI increasingly rewards generalists who can move quickly, adapt, and experiment. In this new era of software development, I find that especially striking. Over the past two years of interviewing and job searching, I’ve consistently seen employers leaning in the opposite direction—which, to me, feels short-sighted and like a missed opportunity."

I responded:

"Totally. Mature companies tend to suffer from continuity bias, and many employees are incentivized to protect their existing roles. In contrast, startups thrive on risk-taking—there’s a cultural push to embrace change, experiment, and bring others along. In bigger organizations, that kind of mindset often gets crushed by the existing culture before it can gain traction."

The current climate favors curiosity, boldness, and speed over caution and rigidity. Succeeding in this kind of environment isn’t just about mindset—it’s about making things happen. With access to tools that offer real leverage, the advantage goes to those who are willing to experiment, move fast, and turn possibilities into reality. It means getting out of your comfort zone, trying new approaches, taking smart risks, and staying open to change.

What Lies Ahead

I get that this perspective isn’t for everyone—and I don’t expect universal agreement. I generally lean towards optimism, even though I’m aware that I am likely underestimating the potential drawbacks. However, one thing is certain: the transition towards widespread use of AI is already in progress. It’s not slowing down, and I’m genuinely excited about what it enables me to do today and in the near future—even if not everyone feels the same.

Over the next 1–3 years, I expect coding models will outperform most top engineers when it comes to writing high-quality code. We’re nearing a point where a generalist can prompt their way to fully functional software products—front end, back end, design, marketing, and deployment—without needing deep expertise in any one domain.

That’s a significant shift. It doesn’t replace the need for experts or devalue craftsmanship—but it does raise the bar for what individuals can build on their own. And it’s likely to reshape how we work and where we choose to apply our time, energy, and human judgment.

For me, it’s an exciting time to adapt—technically, emotionally, and creatively—and I’ve chosen to lean in. I’m enjoying exploring how to use these tools not just to work smarter, but to play, experiment, and express myself in new ways.

That’s my goal—to enjoy the process, remain curious, and explore new ways to play with the machines.

I expected real-time data, but what I got was a seismic tracker that hadn’t been updated in nearly six years.

Lately, Apple’s AI efforts have faced plenty of criticism, but this highlights an even deeper issue—they’re struggling with the basics. Industry leaders mastered search and real-time information retrieval decades ago, yet Apple still fails to return relevant results for simple queries.

As AI and large language models redefine how we access knowledge, the next wave of consumer AI will require systems that deliver accurate, thoughtful, and context-aware responses. If Apple is already this far behind on foundational tech, competing with AI-first companies—moving at an unprecedented pace—will be an uphill battle.

Something drastic needs to change.

Dear Mayor Lurie,

As a long-time resident of San Francisco, I have been closely observing the ongoing changes across our city. I voted for you and I appreciate the initiatives your administration has begun to implement to enhance safety, security, and overall quality of life, I find myself wondering how best to measure these improvements.

I frequently travel through areas such as 6th Street, Market Street, and the Tenderloin, and I have noticed that many of these neighborhoods still appear quite challenging. Obviously, I don’t expect change overnight. To better understand the tangible impact of your administration’s efforts, could you please advise if there is a dedicated dashboard or a set of statistics that residents can regularly monitor? Ideally, I am looking for a data-driven resource that ties the various initiatives and improvements directly to measurable outcomes across city services.

Your guidance would not only help me gauge the progress being made but also bolster community confidence in the positive changes underway. Thank you for your commitment to our city and for considering this request.

Update 1: After several weeks without a response, I followed up again on March 10, 2025.

I was hoping someone from your office could direct me to a resource where I can track the performance of your initiatives. Could you let me know if there’s anything public-facing, if something is in the works, or if no such resource exists? I’d really appreciate a clear answer to this request. Thanks!

This time, I received an immediate automated reply to my email.

Thank you for reaching out to me. I greatly value hearing from members of our community and appreciate you taking the time to connect.

Due to the large number of inquiries my office receives, it may take several days for us to respond. My team and I are committed to reviewing every message and will be in touch as soon as we are able.

If you need more immediate assistance, you may want to direct your inquiry to the appropriate person on my team:

City Services: Please call 311 or visit https://www.sf.gov/topics/311-online-services

Press Inquiries: For media and press-related questions, please email mayorspressoffice@sfgov.org

Proclamation and Commendation Requests: If you are requesting a proclamation or commendation, please contact commendations@sfgov.org

Scheduling Requests: To invite me to an event or request a meeting, please reach out to scheduling@sfgov.org

Appointments and Board Opportunities: For information on appointments or serving on boards, please email mayor.appointments@sfgov.org

Thank you for your patience and understanding as my team works to respond as quickly as possible. I am committed to a responsive city government and to serving you and our community.

Sincerely,

Daniel Lurie
Mayor of San Francisco

Update 2: Still trying to get a response to my request. I reached out again on March 21, 2025.

I wanted to follow up on the note I sent a few weeks ago on March 10th—you mentioned it might take a few days to get back to me but it’s now been a month since my initial outreach on Feb 20th. I am hoping someone from your office could direct me to a resource where I can track the performance of your initiatives.

If there’s anything public-facing, in development, or if nothing like that currently exists, I’d really appreciate a clear answer either way. And if there’s someone else I should be speaking with about this, I’d be grateful for a quick redirect.

Thank you!

Interestingly, Chrome remained unaffected and continued to function normally, even when Safari refused to load pages. The only solution I found to get Safari to load pages once it entered this state was to restart my machine.

Recently, I made a small change in AdGuard Home’s DNS settings that might have resolved the issue. Under Upstream DNS servers, I switched from making single DNS requests to parallel requests. Since then, I haven’t encountered the Safari problem. If the issue returns, I’ll update this post, but for now, this adjustment appears to have fixed my issue. 🤞

Hopefully, this helps others with a similar setup who are experiencing the same Safari issue!

In the event the GPT ever disappears here's the prompt I used:

This GPT asks me one question at a time so we can develop a thorough, step-by-step spec for a new idea I am exploring. Each question should build on my previous answers, and our end goal is to have a detailed specification I can hand off to a developer. Let’s do this iteratively and dig into every relevant detail. Remember, only one question at a time.

Our brainstorm should end naturally. Once we’ve wrapped up the brainstorming process, or I ask, please compile our findings into a comprehensive, developer-ready specification in a file called spec.md. Include all relevant requirements, architecture choices, data handling details, error handling strategies, and a testing plan so a developer can immediately begin implementation.

Start by asking me about my idea.

In step two, he suggested feeding the output into a reasoning model with additional prompts. It’s a great idea. For those specific commands, check out his post, and if you plan to use this workflow regularly, consider setting up keyboard shortcuts based on the prompts he outlined.

Nice workflow, Harper! 👏

Note: I have absolutely no idea why a decent percentage of the time the GPT says it cannot be found. 😬 Refreshing seems to help as does using the GPT in a browser.

Having managed many iOS apps at Google and worked closely with representatives at Apple on App Store releases, I’ve seen firsthand the benefits of a diverse app portfolio. Standalone apps allow Google to:

• Deliver tailored user experiences for specific audiences that rival top-tier competitors.
• Target specific App Store keywords and rank highly in critical product categories.
• Simultaneously secure promotional App Store opportunities for multiple Google products.
• Gain insights into industry trends, revenue, and download metrics by analyzing the performance of multiple Google apps across a broad spectrum of top-ranking apps, including direct competitors and emerging players.

As an outsider, it can be difficult to understand why a company like Google would occasionally adopt such a fragmented product strategy. For example, why did they “ship their org chart” by creating multiple entry points for Google Assistant—offering it as a standalone iOS app, within the Google Home app, and as a settings option in the Google app—despite the customer confusion, internal competition, and operational inefficiencies this created? Often, the pressure to launch quickly, combined with internal politics, forces teams to make short-term compromises with the expectation of streamlining later. In the long run, maintaining a clear and focused product experience benefits both the people who use it and the people who build it. I see this app separation as a sign that Google is evolving and applying lessons from past missteps—a positive indicator for the future!

Removing Gemini from the Google Search app is a smart move. It not only differentiates the two experiences but also gives the Gemini team room to innovate and develop its own revenue stream. Bundling Gemini within the Google Search app was clearly the fastest path to market; now, this separation paves the way for more strategic development. Not to mention, the ChatGPT app on iOS and macOS is outstanding and constantly getting better. If Gemini wants to compete, it will need to step up massively.

Kudos to everyone at Google who contributed to this thoughtful—if obvious—internal decision to break up the iOS Google Search and Gemini apps sooner rather than later.

Personally, I hope that as Gemini and Search continue to experiment together, they address the quality of their integrations. The current AI-generated overviews continue to fall short of the high standards I associate with Google Search, and improving these will be key to maintaining trust and credibility.

9/25 Update: I strongly recommend Fix #3—it’s consistently worked across multiple Apple Watches.

🔧 Fix #1: How to Enable Developer Mode on watchOS When It Doesn’t Appear

I was working on a simple app for my Apple Watch and needed to enable Developer Mode to build and run it on my device. However, despite repeatedly checking Settings > Privacy & Security, the Developer Mode option was nowhere to be found. After experimenting with a few solutions, I finally discovered a fix:

1. Connect the iPhone to a Mac with a physical USB cable.
2. Open Xcode and go to Manage Run Destinations.
3. The watchOS device should appear—follow the prompts on the Watch to trust the computer.
4. Now go to Privacy & Security on your Apple Watch—Developer Mode should appear.
5. Enable it, then restart your watch!

🧼 Fix #2: Reset Xcode When It Can’t Detect Your Apple Watch

After wiping and reinstalling macOS Sequoia 18.4 on a Mac where I had previously used Xcode, I ran into a new issue—Xcode could no longer detect my Apple Watch, even when it was connected via a USB cable. This fix required fully resetting Xcode-related files and reinstalling from scratch.

⚠️ Heads up!

This process is destructive. It wipes Xcode-related caches, simulators, settings, logs, and preferences. While it has helped resolve stubborn issues (e.g. simulator/device pairing), it’s time-consuming and doesn’t always guarantee a fix. Only do this if other troubleshooting hasn’t worked.

🔐 Before You Start:

• Backup any custom device profiles, provisioning profiles, and simulator data you want to preserve.
• Save/export settings and any unsaved changes in your Xcode projects.

💡 Should you decide to proceed, here are the steps I followed:

1. Reset simulators and derived data

# Erase all simulators
xcrun simctl erase all

# Remove derived data
rm -rf ~/Library/Developer/Xcode/DerivedData

2. Delete Xcode and support files

# Remove Xcode
sudo rm -rf /Applications/Xcode.app

# Remove all Xcode developer settings and caches
rm -rf ~/Library/Developer
rm -rf ~/Library/Caches/com.apple.dt.Xcode
rm -rf ~/Library/Application\ Support/Xcode
rm -rf ~/Library/Preferences/com.apple.dt.Xcode.plist
rm -rf ~/Library/Preferences/com.apple.dt.xcodebuild.plist
rm -rf ~/Library/Logs/DiagnosticReports/Xcode_*

# Delete command line tools and reset developer directory
sudo rm -rf /Library/Developer/CommandLineTools
sudo xcode-select --reset

⚠️ Note: This clears all Xcode preferences, logs, and caches. Your actual project files are not affected but you'll need to re-download Xcode and sign back in to your Apple Developer account. Ugh.

3. Reinstall Xcode and Command Line Tools

• Download Xcode from the Mac App Store, or use the Apple Developer site if you need a specific version.

After installation, re-install Command Line Tools in the terminal:

xcode-select --install

4. Open Xcode and Re-Pair Devices

After Xcode is installed and launched:

• Open Window → Devices and Simulators
• Plug in your iPhone and Apple Watch via USB
• Your Watch should hopefully now appear and pair successfully

🌐 Fix #3: When Xcode Can’t Find Your Apple Watch—Try a Hotspot

On one macOS setup, none of the previous fixes worked—Xcode still wouldn’t detect my Apple Watch. Here’s what finally did the trick:

1. Enable Personal Hotspot on your iPhone.
2. Connect your Mac and Watch to the hotspot via Wi-Fi.
3. Physically connect both the iPhone and Apple Watch to your Mac using USB cables.
4. Open Xcode > Devices and Simulators—and if you’re lucky, your Apple Watch will finally appear for setup.

Note: I'm speculating but this may be helpful if you’re on a mesh network (e.g., Eero, Nest, Orbi) with lots of devices, where bonjour and device discovery can be flaky. The hotspot setup helps by isolating traffic to just the essential devices, eliminating potential network noise or routing issues that can interfere with device pairing in Xcode.

This frustration led me to build a simple website that pulls a live webcam image of the bridge and allows me to configure my estimated arrival times for both crossings to get weather forecasts that allow me to dress accordingly. After creating the site, I thought it would be even nicer to have a small widget on my phone, so I decided to port it to Swift as a learning exercise. Given the niche audience for an app like this, I’m unsure whether I'll ever publish it on the App Store, but I’ve shared the code so others can compile it if they’d like.

For now, I have a handy widget on my phone that lets me quickly check a recent snapshot of the Golden Gate Bridge, along with current weather conditions and some inspiration for the two best times to cross today. I also got to learn a bit about Swift.

GitHub - danielraffel/ggb-weather-swift

Contribute to danielraffel/ggb-weather-swift development by creating an account on GitHub.

GitHubdanielraffel

A friend recently became intrigued by claims that some impressive new AI models have been sabotaged by government propaganda, so he began exploring ways to reverse that influence. In his search, he encountered the concepts of model ablation and mechanistic interpretability—techniques used to understand and analyze the inner workings of machine learning models, particularly complex ones like deep neural networks. Since I wasn't familiar with these concepts and don't specialize in this field, I looked them up. Here's what I learned:

Model Ablation

Model ablation is the process of systematically removing or disabling parts of a model (such as neurons, layers, weights, or even entire components) to observe how these changes affect the model’s performance or behavior. The goal is to identify which parts are critical for certain tasks or functionalities.

Key Points:

• Understanding Component Importance:
  By "ablating" (i.e., turning off or removing) specific components, researchers can infer the role and importance of those components in the overall model performance. For example, if removing a particular layer significantly degrades performance on a task, that layer is likely crucial.
• Identifying Redundancies:
  Ablation studies can reveal if some parts of the model are redundant or if there are alternative pathways in the network that can compensate for the loss of certain components.
• Practical Applications:
  • Model Pruning: Ablation methods can lead to more efficient models by identifying and removing unnecessary components, which is especially useful for deploying models on resource-constrained devices.
  • Debugging and Optimization: Helps in diagnosing why a model might be failing or underperforming on certain tasks by pinpointing which parts of the network contribute most to errors.
• Methodology:
  Researchers typically conduct ablation studies by modifying the model’s architecture or parameters in controlled experiments and then measuring changes in performance, activation patterns, or other metrics.

Hypothetical Application for Removing Propaganda:
Imagine an open source AI model that, allegedly, has been influenced to output propaganda. A researcher might:

• Systematically Disable Components:
  Run controlled ablation experiments where specific layers or neurons are temporarily disabled.
• Evaluate Output Changes:
  Examine whether the removal of certain components reduces or eliminates outputs that resemble propagandistic language or biases.
• Isolate Critical Propaganda Circuits:
  Identify parts of the network that, when disabled, lead to a significant drop in propaganda-like responses. This would provide clues about which parts of the model are responsible for incorporating such bias.

This process is highly iterative and requires careful testing. It might reveal that a particular layer or set of neurons is over-representing certain political narratives. Once these are identified, one might consider permanently modifying or “pruning” these components to mitigate the undesired influence.

Mechanistic Interpretability

Mechanistic interpretability is an approach aimed at understanding the internal mechanisms and computations of a machine learning model at a granular, algorithmic level. Instead of treating the model as a "black box," this approach seeks to reverse-engineer the network’s inner workings to explain how it processes information and makes decisions.

Key Points:

• Dissecting the "Algorithm":
  The goal is to identify and describe the specific computations, circuits, or pathways within the network that lead to particular outputs. This might involve mapping out how information flows through the layers, how neurons interact, and what kind of operations they perform.
• Human-Understandable Explanations:
  Unlike high-level statistical analyses, mechanistic interpretability strives for explanations that are understandable in human terms. For example, researchers might explain that a certain network circuit acts similarly to a logical "if-then" statement or performs a specific type of pattern matching.
• Research Directions and Examples:
  • Circuit Analysis: Efforts in mechanistic interpretability often involve identifying “circuits” within neural networks that are responsible for certain behaviors, such as recognizing objects in images or processing language.
  • Layer and Neuron Analysis: Detailed studies might focus on the role of individual neurons or groups of neurons, tracking how changes in their activation relate to the model's overall output.
• Benefits:
  • Trust and Reliability: A clearer understanding of how models work can help build trust in their decisions, which is especially important in high-stakes applications like healthcare or finance.
  • Safety and Robustness: By knowing the internal mechanisms, researchers can better anticipate and mitigate failure modes or vulnerabilities (such as adversarial attacks).

Hypothetical Application for Removing Propaganda:
Using mechanistic interpretability, a researcher could:

• Map the Information Flow:
  Dive into the model’s internal circuits to identify which parts of the network are responsible for processing politically charged or propagandistic content.
• Trace Specific Computations:
  Analyze how specific inputs trigger outputs that seem to carry propaganda. For instance, if certain word patterns or phrases consistently lead to biased responses, the researcher might trace these back to particular neurons or pathways.
• Develop a Modification Strategy:
  With a detailed map of the computations, the researcher can propose targeted modifications. These might include:
  • Re-calibrating the Weights: Adjusting the influence of neurons that contribute to propagandistic outcomes.
  • Altering Activation Functions: Tweaking how these neurons activate in response to certain inputs.
  • Implementing Filters or Safeguards: Adding components that specifically detect and neutralize propagandistic signals before they affect the final output.

This approach, while theoretically promising, is exceptionally challenging. It requires a deep understanding of the model’s architecture and behavior, as well as a rigorous validation process to ensure that modifications do not inadvertently impair the model’s overall performance or introduce new biases.

How They Relate and a Hypothetical Workflow

While model ablation is often used as an experimental tool to understand which parts of a model are necessary for its performance, mechanistic interpretability is a broader effort to map out and explain the inner workings of the model in detail. Together, these approaches could form a hypothetical workflow for removing unwanted propaganda influences:

1. Initial Diagnosis with Ablation:
   • Systematically disable various components of the AI model.
   • Monitor changes in outputs, especially those suspected of carrying propaganda.
   • Identify which parts, when removed, result in a significant reduction of bias or propagandistic content.
2. Deep Dive with Mechanistic Interpretability:
   • Analyze the identified components to understand their specific functions and interactions.
   • Map out the neural circuits and computations that contribute to the propagation of biased outputs.
   • Develop targeted strategies (e.g., weight adjustments, architectural changes) to mitigate or remove the undesired influence.
3. Validation and Iteration:
   • Validate the modified model against a wide range of inputs to ensure that the removal of propaganda does not compromise the model’s ability to perform its intended tasks.
   • Iterate on the modifications, continuously refining the approach based on performance metrics and further interpretability studies.

Final Thoughts

It’s important to note that this entire process is hypothetical and fraught with challenges. Removing ideological bias or propaganda from an AI model is not as straightforward as simply “turning off” a few neurons. The interdependencies within deep neural networks mean that changes in one part of the model can have unforeseen effects on others. Moreover, the definitions of “propaganda” or “bias” are subjective, and any modifications must be carefully balanced against the risk of degrading the overall performance or introducing new biases.

While model ablation and mechanistic interpretability offer promising avenues for understanding and potentially modifying AI models, applying these techniques to remove something as complex and nuanced as propaganda requires not only technical expertise but also a careful, nuanced approach to ensure the integrity and reliability of the model remain intact.

It took me over five years to finally commit to installing solar on my house. Throughout my investigations, I had some unusual experiences. One company, in particular, visited multiple times over several years. Initially, I reached out because I was interested in a new type of solar panel they had developed. They came early in the product’s lifecycle to assess whether my home was a good candidate, but then I didn’t hear from them for nearly a year. After regularly contacting them when they finally got back to me, they said my home wasn’t suitable for their technology.

A few years later, I contacted them again to explore their more traditional solar panels and received a quote—but the cost of their battery and PV system was extremely high, and the projected payback period was too long to justify the investment. A few more years passed, and I received another quote from a different local installer. This time, the payback period was a much more reasonable 3-4 years. I decided to move forward, especially since federal incentives and California’s SGIP battery rebate made the financials more attractive. The SGIP rebate has since been capped, but is still a valuable rebate.

The reason I wanted to write this post is that I’ve heard from several people exploring solar who were told by installers that their home wasn’t a good fit. However, many of them live in sunny parts of the Bay Area, where shading and overcast conditions likely aren’t significant issues given modern PV efficiency gains. Even with partial shading, a PV system configured in parallel using bifacial, half-cell design panels can reduce power loss. Adding microinverters or power optimizers can further enhance efficiency.

On overcast days, my system still generates a useful amount of power, though output can fall below 20% of peak capacity. Fortunately, those days aren’t frequent, and even on overcast days it's usually enough to cover most of my daytime energy needs. More importantly, with a large enough battery backup, I can bank excess energy on sunnier days to offset the dips during cloudier periods. Since overcast conditions where I live are sporadic and tree shading is often manageable, I suspect some installers may be overestimating their impact.

This raises a key question: Why do some installers discourage solar installations? Don’t they want to make money?

I suspect the issue comes down to maximizing profit and setting a minimum project cost to justify their time. For example, if an installer’s minimum viable project is $45,000 to $50,000 in an affluent area, they may simply walk away from anything smaller. There are costs to continuing to engage with a potential customer who might realize the deal isn’t worthwhile, so it’s easier for them to cut things off early. If the estimated payback period exceeds 10+ years, it becomes a tough sell. Most solar quotes outline costs and payback periods, and rather than presenting an unappealing financial case, my assumption is that some installers might simply say, “Your home isn’t a strong candidate,” citing tree cover or another factor as an easy explanation. Ideally, those who do that would be upfront and admit, “Our pricing is on the higher end; you might find a better deal elsewhere,” but that could come across as acknowledging they’re overcharging. While some installers may prioritize their margins or simply have higher operating costs, many others are truly committed to helping people adopt solar and are driven to find cost-effective solutions that maximize system performance. These are the providers worth seeking out.

If an installer has told you that your home isn’t a good fit for solar, it’s worth considering another opinion from one that uses more cost-effective technology, such as inverters and battery solutions from younger companies like EG4, which offers high performance inverter and battery hardware at a fraction of the cost of more established, premium brands. The market is full of affordable PV panel manufacturers. A more cost-effective installer may be able to cut the cost in half without sacrificing power generation or storage capacity.

Smaller solar installers aren’t cutting prices out of desperation—they can simply afford to offer lower costs. Advances in solar and battery technology have made systems far more efficient and affordable, allowing smaller businesses to pass those savings on to customers. In California, although some homes have major challenges that make solar impractical (such as heavy shading or unsuitable roof angles), they are the exception rather than the norm. The real question is cost: How long will it take for the system to pay for itself? Higher-cost systems naturally result in longer payback periods, making the investment harder to justify—especially if they don’t generate enough solar energy to store in batteries.

With energy costs in California expected to keep rising, now may be the best time to explore a whole-home backup system—one that can power your entire house during an outage, increase energy independence, and reduce long-term utility costs. The grid is becoming more strained and less reliable, making a well-designed solar-plus-battery system a smart investment for both savings and resilience. Plus, federal and state rebates won’t be around forever, so taking advantage of incentives now could significantly improve your financial return.

Ingredients

• 2x 28oz can fire roasted tomatoes
• 2 bunch green onions (~1c chopped)
• 2-3 heads of garlic
• 1 dried pasilla chili (deseeded and roughly chopped)
• 15-20 medium dried chili de árbol (deseeded and roughly chopped)
• 1 guajillo chili (deseeded and roughly chopped)
• 2 bunch cilantro (~1c packed, removed from stems)
• 1/8c canola oil
• 1 tbs kosher salt

Steps

1. Coarsely chop the onion into big chunks. Leave the garlic cloves unpeeled.
2. Pan roast the onions and garlic with no oil for 7-10 minutes until they are slightly blackened.
3. When done, transfer the onion and garlic to a bowl or plate. I find it’s easier to separate them. Remove the skin and cut the stem from the garlic cloves. Set both aside.
4. In a large sauce pan add the tomatoes and deseeded chili’s. Simmer for 10 minutes.
5. Add the chopped cilantro, garlic and onions and simmer for 1 minute.
6. Remove from heat and blend in a Vitamix or other high powered mixer until mostly smooth.
7. Drizzle oil in to emulsify.
8. Add salt to taste.
9. Chill and consume the next day.

Note: Although it might be tempting to add a little water while sautéing or blending, I’ve found it’s usually unnecessary and can easily make the salsa too thin.

At this point, my perspective is that the concerns surrounding seed oils are mostly exaggerated and fueled by misinformation rather than solid science. I tend to agree with my friend’s take: “Diet is hard to science. Probably diversity of natural substances is the best?”

Avoiding seed oils entirely would be challenging—and honestly, it feels like an unnecessary restriction that narrows my vegan and vegetarian choices. While they are commonly found in highly processed foods, I see that as a separate concern. The evidence on the health risks of highly processed foods seems solid to me, and I do make an effort to limit them. When salad chains like Sweetgreen switch to a fully “seed oil-free” menu, I get the business rationale given current trends, but it also seems like they’re catering to misconceptions rather than science.

If I’ve overlooked something significant or new research emerges, I’m open to reconsidering my stance. But for now, avoiding seed oils altogether seems unnecessary.

Step 1: Back Up Containers on the Source Machine

The first step was to create backups of each container on the source Proxmox machine (my MacBook Air). Proxmox automatically stores these backups in the following directory:

/var/lib/vz/dump/

You can trigger the backups via the Proxmox web interface by selecting each container and choosing the "Backup" option.

Tip: It’s a good idea to regularly back up your containers and store the backups on a remote drive or another machine. While you can set up a dedicated Proxmox Backup Server, I find that using simple image backups works just as well, as long as you stick to a consistent backup routine.

Note: If you're looking to also back up and restore your Proxmox host, this thread could be helpful. There may be custom configurations that can streamline the restoration process.

Step 2: Transfer the Backup Files to the New Proxmox Machine

After backing up the containers, I transferred the backup files to the new Proxmox machine. While SSH'd into the source machine, I used scp to copy the files over:

scp -r /var/lib/vz/dump/* root@[targetIP]:/var/lib/vz/dump/

Make sure to replace [targetIP] with the IP address of your new Proxmox machine.

This command recursively copies all backup files from the source machine to the new one. Using scp worked great for me, but you can also use other tools like rsync if you prefer incremental transfers.

Step 3: Restore Containers on the New Machine

Once the backup files were on the new machine, I opened the Proxmox web interface, navigated to the "Backup" section, and selected "Restore" for each container image. The restore process went smoothly, and within minutes, all my containers were up and running on the new system.

Final Thoughts

Migrating Proxmox containers to a new machine was much easier than I expected. By simply backing up, transferring, and restoring container images, I was able to replicate my entire setup without any headaches.

While Proxmox Backup Server is a great option for centralized and automated backups, this simple image-based method works perfectly for me. The key is to back up regularly and store those images on another machine or an external drive to safeguard against hardware failures.

If you’re thinking about upgrading your Proxmox hardware or just want to be prepared for emergencies, this approach is a straightforward and reliable solution.

The following assumes you are already familiar with Homebridge and have it set up with your Apple Home app. If you're new to Homebridge, you may want to check out Homebridge's official documentation to get started

Setting Up the Homebridge Plugin

To accomplish this, I used the homebridge-onkyo-pioneer plugin, which provides support for Pioneer and Onkyo receivers. Setting it up was straightforward, with only a few key configurations required:

1. Finding the Receiver's IP Address:
   Since my amp was connected via Ethernet and I hadn’t manually configured the network settings yet, I used a network scanner to discover its IP address. It's worth making this IP address static and reserving it on your router to ensure it doesn't change, preventing potential connection issues with Homebridge in the future.
2. Configuring the Plugin:
   After installing the plugin, the main settings required were:
   • IP Address: Adding the amp’s IP.
   • Device Name: Choosing a friendly name.
   • Volume Control Type: Selecting light bulb as the accessory type for volume control (other options include fan).

My Homebridge Configuration

Here’s the final configuration I used in the plug-in's config.json file:

{
    "statePollingInterval": 30,
    "debug": false,
    "receivers": [
        {
            "ip": "192.168.86.58",
            "name": "VXS-LX505",
            "volumeAccessory": "bulb",
            "maxVolume": 200
        }
    ],
    "platform": "OnkyoPioneer",
    "_bridge": {
        "username": "XX:XX:XX:XX:XX:XX",
        "port": 30209,
        "name": "homebridge-onkyo-pioneer EBCD"
    }
}

The key change, which is described below under resolving volume control issues, involved updating the maxVolume setting to 200.

Pairing with HomeKit

To optimize performance and ensure a stable connection, I set up the Pioneer receiver as a child bridge in Homebridge. In fairness, I have no idea if adding a child bridge for this device actually improves or enables anything. Regardless, the process I took involved two main steps:

Phase 1: Adding the Child Bridge

1. Opened the Apple Home app and tapped "Add Accessory."
2. Used the camera to scan the QR code displayed in the Homebridge plugin interface.
3. The child bridge was successfully added to HomeKit, but the receiver itself didn’t appear as a controllable device.

Phase 2: Manually Adding Accessories

Since the receiver didn’t automatically import any devices, I had to manually add it by following these steps:

1. Opened the Apple Home app and tapped "Add Accessory."
2. Selected "More Options."
3. Found the Pioneer receiver listed as two separate accessories—one for inputs and another for power/volume.
4. Added both to my HomeKit setup.
   1. Note: If/when asked added the following HomeKit code: 031-45-154

Once both accessories were added, the receiver finally appeared in the Home app, allowing me to control it directly from my iPhone.

Resolving Volume Control Issues

After getting everything set up, I noticed an issue with volume control—HomeKit's slider maxed out at -32 dB, far below the receiver's true maximum.

The Fix:

To resolve this, as described above in the config, I updated the maxVolume setting in my Homebridge configuration from 100 to 200, then restarted Homebridge. This allowed the Apple Home app to control the full volume range from -80 dB to +17 dB, aligning perfectly with the amp’s physical volume dial.

Final Thoughts

With this setup, I can now:

• Turn the receiver on/off with Siri or automations.
• Adjust volume using HomeKit sliders.
• Change inputs from the Home app.
• Create HomeKit automations to control the receiver alongside other smart devices.

If you're looking to integrate your Pioneer AV receiver with Apple HomeKit, Homebridge makes it relatively simple with the right configuration. Just be sure to set the correct maxVolume and explore HomeKit's automation capabilities to make the most of your smart home setup!

Pics or It Didn't Happen

With Nginx, Cloudflare, and Tailscale, each service in my home lab now has its own memorable, SSL-secured, private URL. Here’s how I configured my setup.

Step 1: Install Necessary Software on Proxmox PVE Host

Update the System:

sudo apt update && sudo apt upgrade -y

Install Certbot and Cloudflare DNS Plugin:

sudo apt install certbot python3-certbot-dns-cloudflare -y

Install Nginx:

sudo apt install nginx -y

Step 2: Configure Cloudflare for DNS Verification

1. Log in to your Cloudflare dashboard.
2. Create an API Token:
   • Navigate to My Profile > API Tokens.
   • Create a new token with the following settings:
     • Zone: DNS - Edit
     • Zone Resources: Include specific zones (your domains).
   • Copy the generated token.

Store the API Token Securely:

sudo mkdir -p /etc/letsencrypt
sudo nano /etc/letsencrypt/cloudflare.ini

Add the following to the file:

dns_cloudflare_api_token = YOUR_API_TOKEN

Secure the file:

sudo chmod 600 /etc/letsencrypt/cloudflare.ini

Step 3: Create a DNS A Record in Cloudflare

For each new subdomain:

1. Create an A Record:
   • Name: <subdomain>.yourdomain.com (e.g., service.yourdomain.com).
   • Content: Use any public IP—this doesn't need to point to your actual server, as we'll update it later. It can even be an IP registered to someone else, since this is a temporary placeholder.
   • Proxy Status: Enable Cloudflare proxy (orange cloud) if desired.

Verify the DNS Record:

ping <subdomain>.yourdomain.com

Ensure the subdomain resolves to the placeholder public IP.

Step 4: Obtain SSL Certificates

Run Certbot to generate an SSL certificate for the subdomain:

certbot certonly --dns-cloudflare --dns-cloudflare-credentials /etc/letsencrypt/cloudflare.ini -d <subdomain>.yourdomain.com

Certificates will be stored at:

/etc/letsencrypt/live/<subdomain>.yourdomain.com/

Step 5: Update Nginx Configuration

1. Create or Edit Your Configuration File:
   Open your Nginx configuration file or create a new one specifically for your setup:

sudo nano /etc/nginx/sites-available/proxmox

2. Add Server Blocks for Your Subdomains:
   Include a server block for each subdomain. Replace <subdomain>, <tailscale-IP>, and <port> with the appropriate values:

# Redirect HTTP to HTTPS for <subdomain>.yourdomain.com
server {
    listen 80;
    server_name <subdomain>.yourdomain.com;

    return 301 https://$host$request_uri;
}

# HTTPS server block for <subdomain>.yourdomain.com
server {
    listen 443 ssl;
    server_name <subdomain>.yourdomain.com;

    ssl_certificate     /etc/letsencrypt/live/<subdomain>.yourdomain.com/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/<subdomain>.yourdomain.com/privkey.pem;

    location / {
        proxy_pass http://<tailscale-IP>:<port>;
        proxy_http_version 1.1;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;

        # Optional: Increase timeouts for long connections
        proxy_read_timeout 300s;
        proxy_send_timeout 300s;

        # Disable buffering for real-time data
        proxy_buffering off;
    }
}

3. Set the New Configuration as Default:

Disable the default configuration that comes with Nginx:

sudo rm /etc/nginx/sites-enabled/default

Enable your new configuration:

sudo ln -s /etc/nginx/sites-available/proxmox /etc/nginx/sites-enabled/

Step 6: Test and Reload Nginx

If the test is successful, reload Nginx:

sudo systemctl reload nginx

Test the configuration:

sudo nginx -t

Step 7: Update DNS to Tailscale IP

1. Return to the Cloudflare dashboard.
2. Update the A record for the subdomain:
   • Change the Content value from the public IP to the Tailscale private IP (e.g., 100.X.X.X).

Verify the new DNS record:

ping <subdomain>.yourdomain.com

Ensure it resolves to your Tailscale IP.

Step 8: Verify the Setup

1. Open the subdomain in a browser to verify functionality.

Test HTTPS access for the subdomain:

curl -k https://<subdomain>.yourdomain.com

Step 9: Set Up Automatic SSL Renewal

Automate SSL certificate renewal with a cron job:

sudo crontab -e

Add the following line:

0 3 * * * certbot renew --quiet --post-hook "systemctl reload nginx"

Notes on SSL and Tailscale IPs

While Tailscale provides a highly secure private network, adding SSL to subdomains ensures that browser connections are treated as secure, eliminating those annoying warnings about "insecure connections." This makes accessing services much more seamless, especially when using modern browsers that enforce HTTPS for many functionalities.

It’s also worth noting that while Tailscale IPs are stable, they’re not static. In rare cases, a Tailscale IP could change, which might require updating the DNS record for the affected subdomain to avoid disruptions.

To troubleshoot, I compared the behavior of my macOS laptop (connected via Wi-Fi) with Proxmox running on the same MacBook Air (connected via Ethernet through a USB dongle). Despite being on the same subnet, Proxmox devices could ping a specific device (EnvisaLink DUO) but failed to connect using curl or netcat.

Initial Observations

On macOS (Connected via Wi-Fi)

• Ping: ping 192.168.86.150 → Success
• HTTP Request: curl http://192.168.86.150 → Success (retrieved the expected webpage)
• Netcat: nc -zv 192.168.86.150 4025 → Success
• MTU Size: ifconfig returned an MTU size of 1500
• Port Scan: nmap -p 80 192.168.86.150 showed port 80 as open.

On Proxmox (Host and VMs Connected via USB Dongle)

• Ping: ping 192.168.86.150 → Success
• HTTP Request: curl http://192.168.86.150 → Hangs with no response
• Netcat: nc -zv 192.168.86.150 4025 → Hangs
• MTU Size: ip link show returned an MTU size of 1500
• Port Scan: nmap -p 80 192.168.86.150 showed port 80 as filtered.

This was puzzling: even though Proxmox was on the same subnet and could ping the target device, it couldn’t establish connections using other protocols.

Troubleshooting Steps

1. Verified Network Configuration

I confirmed that both the Proxmox host and its VMs had static IP addresses in the correct subnet.

2. Checked ARP Resolution

The ARP table showed that the target device was reachable. I flushed the ARP table to rule out any stale entries, but the issue persisted.

3. Ran tcpdump

Capturing outgoing packets with tcpdump revealed that SYN packets were being sent to the target device, but no responses were received.

4. Tested DNS Resolution

I added the target device’s IP to /etc/hosts to ensure hostname resolution wasn’t an issue. However, this didn’t solve the problem.

5. Checked MTU Size

Both macOS and Proxmox reported an MTU size of 1500, ruling out MTU mismatches as a potential cause.

6. Compared nmap Results

This was the key clue:

• On macOS, nmap reported port 80 as open.
• On Proxmox, nmap reported port 80 as filtered.

Since no firewall was running on Proxmox, I suspected that the USB Ethernet dongle might be interfering with traffic.

Honing in on the USB Ethernet Dongle

Given that the issue only occurred when using the USB-to-Ethernet dongle, I started to suspect that the dongle might be filtering or altering traffic. To investigate further, I checked the dongle’s offloading features using ethtool:

ethtool -k enx803f5d096607

The output showed that RX and TX checksumming were enabled:

rx-checksumming: on
tx-checksumming: on
  tx-checksum-ipv4: on
  tx-checksum-ip-generic: off [fixed]
  tx-checksum-ipv6: on
  tx-checksum-fcoe-crc: off [fixed]
  tx-checksum-sctp: off [fixed]

Offloading generally improves performance by allowing the network interface to handle certain tasks. However, in some USB Ethernet dongles, enabling offloading can cause issues with packet integrity or filtering.

The Fix

To test whether disabling RX/TX checksumming would resolve the issue, I ran:

sudo ethtool -K enx803f5d096607 rx off tx off

I then re-ran the nmap scan:

nmap -p 80 192.168.86.150

This time, the port was reported as open:

PORT   STATE SERVICE
80/tcp open  http

A quick test with curl also worked:

curl http://192.168.86.150

Result:

<HTML><BODY><H1>Server Requires Authentication</H1></BODY></HTML>

Finally, the issue was resolved.

Automatically Disabling RX/TX Checksumming at Boot

The command sudo ethtool -K enx803f5d096607 rx off tx off is temporary and will be reset on reboot. To make it persistent, I created a systemd service:

Enable the service:

sudo systemctl enable disable-offload.service

Add the following content:

[Unit]
Description=Disable RX/TX checksumming on Ethernet USB dongle
After=network.target

[Service]
ExecStart=/sbin/ethtool -K enx803f5d096607 rx off tx off
Type=oneshot
RemainAfterExit=true

[Install]
WantedBy=multi-user.target

Create a new systemd service file:

sudo nano /etc/systemd/system/disable-offload.service

This ensures that the ethtool command runs automatically at boot.

Why Disabling Checksumming Helped

USB Ethernet dongles can have limited hardware capabilities. Enabling checksum offloading can lead to packet corruption or filtering by the dongle itself. Disabling RX/TX checksumming forces the kernel to handle checksumming in software, which resolved the issue in this case.

Final Thoughts and Lessons Learned

If you’re running Proxmox on a machine with a USB-to-Ethernet dongle and encounter strange network behavior where ping works but other protocols hang, try disabling RX/TX checksumming using ethtool. This simple fix saved me hours of frustration and could help others avoid similar issues.

Sometimes, the problem isn’t with your network configuration or the target device but with the hardware in between.

Commands Recap

Check offloading status:

ethtool -k <interface>

Disable RX/TX checksumming:

sudo ethtool -K <interface> rx off tx off

Re-enable checksumming (if needed):

sudo ethtool -K <interface> rx on tx on

I recently shared my experience cobbling together a DIY EV solar charging solution—something I don’t recommend! Thankfully, I discovered a much more mature project called EVCC, which I wish I had known about earlier. It’s a fantastic option for those looking to optimize their EV charging and who are comfortable using the terminal. Once installed it's user-friendly enough to be shared with other household members who may need to use it to quickly fast charge an EV.

Since EVCC is open source, it didn’t matter that it lacked native support for my Lux Power/EG4 inverter. A buddy and I purchased a third-party dongle designed to extract data from the otherwise closed inverter, and we figured out how to integrate it with EVCC. This allowed us to manage charging for our similar setups, which each include an EG4 18kPV inverter, a Tesla Model 3, and a Tesla Universal Mobile Connector (UMC). The dongle streams data via MQTT, enabling EVCC to track critical metrics such as solar generation, grid usage, and battery status, while also supporting dynamic control of battery discharge during fast charging.

In addition to integrating the inverter, I set up TeslaBLEHttpProxy to let EVCC smartly control the (dumb) Tesla UMC. This works by enabling EVCC to communicate with the Tesla vehicle through the proxy locally over Bluetooth, allowing near real-time charging adjustments based on solar and grid conditions. With this setup, I can dynamically adjust charging parameters such as amperage, enable fast charging, limit charging to solar excess, and more.

To better manage energy costs, I configured EVCC to account for PG&E’s seasonal tariffs under my Electric Home Rate Plan (E-ELEC). Using a custom formula, the tariffs automatically adjust between summer and winter rates, with different time-of-use (TOU) pricing tiers. This ensures that I can charge at the lowest possible cost by prioritizing solar energy, battery reserves, or grid power depending on availability and cost.

Overall, this custom setup offers a fully integrated solution that balances solar self-consumption, grid tariffs, and vehicle charging. It’s ideal for anyone comfortable with configuring these components and looking to maximize their EV charging efficiency.

If you’re interested in setting up something similar, check out this repository. Clone it, copy evcc.env.sample to evcc.env, and edit the values to match your setup. If you don’t plan to use InfluxDB, be sure to uncomment DISABLE_INFLUX in evcc.env. Once your values are set, run gen.sh to generate evcc.yaml with your customized configuration. The repo provides pre-configured PG&E seasonal tariffs for California residential E-ELEC households and annual feed-in export energy pricing for 2025, both of which can be easily removed if they don’t match your setup. This allows for real-time energy cost calculations.

While your setup is likely to differ, this repository serves as a useful example of how to use EVCC to:

• Integrate a Lux Power/EG4 inverter using a third-party dongle.

• Enable smart control of a Tesla with a UMC charger via Bluetooth using TeslaBLEHttpProxy.

• Configure seasonal summer/winter tariffs for importing energy via PG&E.

• Configure annual feed-in export energy pricing via PG&E.

Requirements:

• EVCC – Open-source EV charging controller.

• Monitor My Solar Dongle – If you’re integrating an EG4 or Lux inverter.

• TeslaBLEHttpProxy – If you’re planning on using a Tesla UMC with EVCC.

For more details and to get started, check out the repository:

GitHub - skrul/evcc-config

Contribute to skrul/evcc-config development by creating an account on GitHub.

GitHubskrul

How I Use Text Replacements

When I’m running out of messages and need to start a fresh chat, I simply message Claude:

I need to summarize our original goals, the approaches we've tried, our current progress, any relevant details like the technologies or software packages involved, and what remains to be done. Additionally, I need to suggest clear next steps to prepare for a new discussion.

Claude returns a concise summary that I can easily paste into a new chat to keep making progress without hitting my quota. To save time, I’ve created a short text replacement that quickly expands into that message.

Setting Up Text Replacement

Here’s how to set up text replacements on iOS or macOS:

1. Go to Settings > General > Keyboard > Text Replacement.
2. Tap the + button.
3. Enter your saved summary in the "Phrase" field.
4. Choose a shortcut, like ffs, in the "Shortcut" field.
5. Save it.

Now, anytime you type your shortcut, your saved summary will appear.

Why This Works Well with Claude

Claude Pro has limits based on message count and conversation length. Longer chats use up your quota faster because Claude re-reads the entire thread with every message. Starting a new chat with a clear, concise summary avoids this problem and keeps things efficient.

By using text replacements, I can quickly transition to a new thread without losing momentum. Hopefully, future improvements to Claude will eliminate the need for this workaround.

The Problem

At the end of every year, I always come across best of lists featuring albums I missed out on. Manually searching for each album on Spotify and adding its tracks to a playlist is tedious. I wanted a faster way to generate full album playlists.

The Solution

Here’s how I solved the problem:

1. Copy List from the Web

I use a shortcut on my iPhone that can scrape web content directly from Safari. When browsing an end-of-year album list on my phone, I share the page with this shortcut which copies the entire text into my clipboard. Note: I'm often on mobile but you can also just easily copy/paste lists on desktop web.

2. Extract Album and Artist Names

Once I have the list I often need to clean it up so I paste it into ChatGPT and ask it to:

“Extract only the album titles and artist names, formatted as ‘Artist - Album’ pairs, with each pair on a new line and line no numbers, bullets or extra text.”

This step generates a clean list of album-artist pairs to use (e.g., Charli xcx - BRAT).

3. Create a Spotify Web API App

To use the tool, you’ll first need to set up a Spotify Web API app. It’s simple and takes about 60 seconds:

• Log in to Spotify for Developers.
• Click Create an App, give it a name, sign up to use the Web API, and set localhost as the return URI.
• Copy the client token and secret provided.

4. Setup the Tool with your Credentials

Paste the client token and secret into step 1 of the tool I built and press Authenticate. Note: I don't store or log anything but you are welcome to download the html file if you want to run it locally.

5. Convert Album-Artist Pairs to Spotify URLs

Copy and paste your cleaned up list of album-artist pairs into step 2 of the tool. It will automatically generate Spotify album URIs, saving you from manually searching for each album on Spotify. Once created, copy the generated Spotify URIs.

6. Generate a Playlist with Tracks from Each Album Using Spotlistr

Once you have the Spotify album URIs, it’s time to create the playlist:

• Open Spotlistr.
• Paste the list of Spotify album URIs into Spotlistr.
• Spotlistr will automatically generate a playlist, pulling all the tracks from each album.

The result is a Spotify playlist that includes every track from the albums on your list—not just a single song from each. Note: You'll want to reference the original list and make sure you found tracks for the correct album, some are bound to be wrong but this should get you most of the way there.

Why It’s Useful

This approach creates a playlist featuring every track from each artist’s album. If you frequently discover music through curated lists, this workflow transforms a tedious task into a more efficient process. If you dig what you discover hopefully you’ll consider supporting both the artist and the source of the list!

Workflow Overview

The following screenshots illustrate the high-level workflow. Each step represents the process, showing how tasks flow from start to finish. Let’s dive into each section to understand the connections and actions involved.

Step 1: Find a Best of Album List

Step 2: Convert the list to album - artist pairs

Step 3: Convert the list to Spotify URIs

Step 4: Convert the Spotify URIs to a Spotify Playlist

Step 5: Enjoy Listening to Your Spotify Playlist

Today, I took it a step further by enabling push notifications with Pushover whenever Hazel adds a file to Apple Books. This small tweak ensures I know exactly when a PDF is available to read. The setup was straightforward, and I’ve shared the steps below so others can replicate it.

I originally started exploring Pushover for sending notifications from the Apple Home app, but I found way for that app to send push notifications even when a security alarm is adjusted via a geofence. However, I’m glad I found another use for Pushover!

How to Set Up Hazel and Pushover Notifications for Apple Books

Step 1: Create a Pushover Account and API Token

1. Go to Pushover.net and create an account.
2. Create a new application to get your unique API token.
   • You’ll need both the API token and your User key for the script.

Step 2: Set Up Hazel Rule

1. Open Hazel and create or edit the rule that processes the PDFs.
2. Add conditions to ensure Hazel only runs this rule for PDFs in your watched folder. For example:
   • If extension is pdf
3. Add an action to run a shell script at the end of the rule.

Step 3: Write the Shell Script

Here’s the script I use:

#!/bin/bash

# Pushover API credentials
API_TOKEN="your_pushover_api_token"
USER_KEY="your_pushover_user_key"

# Extract only the file name from Hazel
FILE_NAME=$(basename "$1")

# Send push notification
curl -s \
  --form-string "token=$API_TOKEN" \
  --form-string "user=$USER_KEY" \
  --form-string "message=Hazel added file: $FILE_NAME to Apple Books" \
  https://api.pushover.net/1/messages.json

• Replace your_pushover_api_token and your_pushover_user_key with your Pushover credentials.
• The script uses basename to extract just the filename (e.g., File.pdf) from the full file path Hazel passes to the script.

Step 4: Add the Script to Hazel

1. In the Hazel rule editor, choose the "Run Shell Script" action.
2. Copy and paste the script into the editor.
3. Hazel automatically passes the file path of the processed file as $1 to the script—no additional configuration needed.

Step 5: Test the Rule

1. Drop a PDF into the folder monitored by Hazel.
2. Hazel will process the file, add it to Apple Books, and trigger the script.

You should receive a Pushover notification like this:

Hazel added file: File.pdf to Apple Books

Additional Notes

• Why Pushover? I discovered Pushover recently, and its simple API makes it perfect for custom notifications like this. Plus, it works across all my devices.
• If you want to batch notifications for multiple files or customize the message further, you can extend the script to handle more complex scenarios.

This small upgrade to an existing automation is a nice way to learn when new reading material is ready to consume in Apple Books.

The Problem

The v1.2.0 update promised improved connection handling to resolve random crashes during startup. Despite this fix, the application wouldn’t launch after installing v1.2.0 alongside CorOS 3.1.0. Something deeper was preventing Cortex Control from functioning properly on macOS.

The Solution

1. Investigating the Installer
Using Suspicious Package, I analyzed the Cortex Control installer to pinpoint what it installs on the system. This tool revealed several files and directories worth investigating.

2. Removing Old Files
I manually removed the following files and directories to clear remnants of the previous installation:

Application and support files:

/Applications/Neural DSP/Cortex Control.app  
/Library/Application Support/Neural DSP/Cortex Control

Configuration and log files:

~/Library/Preferences/com.NeuralDSP.CortexControl.plist  
~/Library/Logs/ndsp_appnapdisable.log

3. Updating macOS and Reinstalling Cortex Control:

Since it had just come out I upgraded macOS to version 15.2, restarted my system, and reinstalled Cortex Control v1.2.0 using the official .pkg installer. This resolved the issue, and the application launched successfully!

Conclusion

If you’re experiencing issues with Cortex Control on macOS Sequoia, removing old files and updating to the latest macOS version might do the trick. NeuralDSP’s v1.2.0 improvements are great, but a clean slate ensures compatibility. I’m back to seamlessly controlling my Quad Cortex on the floor from my desktop!

To achieve this, I purchased the Eyezon Duo. After it arrived, I followed the initial software activation instructions to register the device to my account.

Next came the installation, which involved wiring the Duo to my alarm system and running an Ethernet cable through my attic, as the device doesn’t support Wi-Fi and requires a wired internet connection.

To create a custom-length cable, I bought a spool of Cat6e cable from Best Buy Insignia. They sell an entire spool, measure what you take, and allow you to use what you need. You return the remainder for a refund, and it costs approximately $0.30 per foot.

I was motivated to get the wiring done while I had some solar installers on-site so that I could borrow their Ethernet crimper, cable tester and ladder to access my attic. Thanks, Jesse!

Retrieving the Honeywell Installer Code

After installing the Eyezon Duo, I needed to add it as a virtual keypad/panel to my Honeywell alarm system. To do this, the first step was retrieving the installer code for my alarm. Once I had the installer code, I was able to move forward with the setup. Make sure to save this code since you may need it again in the future. I attempted to get this code from the folks who manage my alarm but it was against their policy since they don’t want folks messing up their systems.

Don't Know Your Installer Code?

Step 1: Shut down the system.
1. Shut down transformer.
2. Shut down battery.
3. Leave system off for 60 seconds.

Step 2: Bring the system back up.
1. Repower the battery.
2. Repower the transformer.

Step 3: Force system to programming mode and retrieve existing installer code.
1. Within 30 seconds of rebooting system, push and hold the * and # keys together on a keypad.
2. Hold for 2 seconds and the 20 should appear on the display which indicated you are in programming mode. If 20 does not appear the panel is locked and you must contact the installer for the code.
3. Enter #20 and the display will show the existing installed for digit code, one digit at a time.

I ran into the following challenges with the Eyezon Duo instructions.

Finding the Wire to Connect the Duo to the Alarm Panel

The first challenge was figuring out how to wire the Duo to my alarm system. The instructions mentioned that the necessary cable wasn’t included. However, when I thoroughly unpacked the box, I unexpectedly found a short cable tucked away in the packaging.

Logging into the Duo Device on the Local Network

The second challenge was figuring out how to connect to the Eyezon Duo device on my local network. I stumbled on some instructions online that mentioned the default username is “user,” and the password is the last six digits of the device’s MAC address (which can be found on a sticker on the bottom of the device). It’s a good idea to snap a photo and jot down these details for reference.

Adding the Duo as a Keyboard to the Honeywell Panel

Next, I encountered a challenge adding the Duo as a keypad, as the default address 18 was already in use by my Honeywell panel. To resolve this, I logged into the Eyezon Duo device portal and registered the Duo to a different keypad address—in my case, address 21 was available.

To complete adding the Duo as a keypad I needed to enter the following codes on my Honeywell panel:

(Installer Code) 800 *194 10 *99

Programming the Duo to Work with the Honeywell Alarm

Once the Duo was configured as a keypad, I programmed the Honeywell Vista Panel following the 23-step process outlined on pages 9 and 10 of the manual. Initially, I was unsure if every step was necessary—but yes, they all are.

Honeywell Vista 10P, 15P, 20P & 21iP

1. Enter (Installer Code) + 800 to access installer programming mode. “20” should appear on the display. If you
do not know the Installer Code, see Troubleshooting Tips on page 13.

2. Keypad programming: *190 to *196 (addresses 17-23) are the keypad programming sections. Enable the assigned Envisalink4 addresses as needed. If it is a single partition system using the default Envisalink4 address of 18, the programming section is *191. In section *191 enter 10. If the keypad was on Partition 2, you would enter 20.

3. *29 Enable IP/GSM (IP/GSM/LRR support required for your Envisalink4 to transmit alerts): The codes to enter in the section depend on the age of the panel. Start by entering 1, If you hear 3 beeps proceed to #4; if not continue with *0**.

4. *48 Report Format: Enter 77 (this is pre-set and cannot be changed on ADT Panels).

5. *49 Split/Dual Reporting: Enter 5 and you will hear 3 beeps.

6. *50 Burglary Dialer Delay: Enter 0 and you will hear 3 beeps.

7. *54 Dynamic Signalling Delay: Set to 0 and you will hear 3 beeps.

8. *55 Dynamic Signalling Priority: Set to 1 and you will hear 3 beeps.

9. *59 Exit Error Alarm Report Code: Set to 0 and you will hear 3 beeps.

10. *60 Trouble Report Code: Enter 10 and you will hear 3 beeps.

11. *62 AC Loss Report Code: Enter 10 and you will hear 3 beeps.

12. *63 Low Battery Report Code: Enter 10 and you will hear 3 beeps.

13. *64 Test Report Code: Enter 10 and you will hear 3 beeps.

14. *65 Open Report Code: Enter 110 and you will hear 3 beeps.

15. *66 Arm Away/Stay Report Code: Enter 111100 and you will hear 3 beeps.

16. *67 RF Transmitter Low Battery Report Code: Enter 10 and you will hear 3 beeps.

17. *70 Alarm Restore Report Code: Enter 1 and you will hear 3 beeps.

18. *71 Trouble Resolve Report Code: Enter 10 and you will hear 3 beeps.

19. *73 AC Restore Report Code: Enter 10 and you will hear 3 beeps.

20. *74 Low Battery Restore Report Code: Enter 10 and you will hear 3 beeps.

21. *75 RF Low Battery Restore Report Code: Enter 10 and you will hear 3 beeps.

22. *84 Auto Stay Arm: Enter 0 and you will hear 3 beeps.

23. Enter *99 to exit programming.

Once the panel programming was complete I connected to the Eyezon portal (and mobile app) and confirmed I was able to control the Honeywell alarm. The next step was figuring out how to connect the Duo to HomeKit.

Connecting the Duo to Homebridge to Expose it in HomeKit

To connect unsupported 3rd party devices to HomeKit I am using Homebridge. I installed the homebridge-envisalink-ademco plugin and then configured the plugin with the IP address of the Duo on my network, the port, the MacID password, and my alarm code (which happens to be user code #2.)

Since the plugin was now referencing the Duo device by its IP address, I wanted to ensure the address didn’t change. To achieve this, I logged into the Duo device and configured it to use a static IP address under the network options. I then assigned this static IP address to the device’s MAC ID in my router’s settings.

In the Apple Home app, I was now able to see and adjust the alarm states. However, there was still more work to be done to see and control all the devices connected to the alarm.

I wanted to have access to all the contact sensors, motion sensors, smoke alarms, and other devices in the Apple Home app. To achieve this, I needed to retrieve the corresponding zones and device names from the Honeywell panel.

Retrieving Zones from the Honeywell Panel

Using ChatGPT, I got some helpful instructions to guide me through the process. Starting with zone 01, I worked through each zone incrementing by one until no more appeared, taking photos of the zones and their names for future reference.

Step-by-Step to View Zone Names:

1. Enter Programming Mode:
* Enter your Installer Code (default is 4112), followed by 8 and 00.
Example: 4112 + 8 + 00.
* The keypad will display Installer Code 20.

2. Enter Zone Descriptor Programming:
* Press *82.
* The keypad will display "Alpha?".
* Select Yes by pressing 1 (to confirm Alpha programming).

3. View the Zone Descriptors:
* The keypad will display "Enter Zone No." prompting you to input a zone number.
* Input a zone number to view its programmed descriptor (e.g., 01 for Zone 1).
   * The keypad will show the name (if programmed) for that zone.
   * To move to the next zone, simply enter the next zone number or use the arrow keys (* to proceed and # to go back).

4. Review Additional Zones:
* Repeat the process for each zone to view its name.
   * Example: Enter 02 for Zone 2, 03 for Zone 3, etc.

5. Exit Programming Mode:
* After reviewing all zones, exit programming mode by pressing *99.
* This ensures the system returns to normal operation.

Configuring the Envisalink Ademco Plugin with Honeywell Zone Names and Adding SpeedKey Switches

I began by reviewing and updating the Homebridge Envisalink Ademco config.schema to integrate my alarm sensors into a custom configuration file. This ensures that all devices connected to my alarm system—such as contact sensors, motion sensors, door/window sensors, and smoke detectors—are visible to the plugin, appear in HomeKit, and can be included in automations.

Since my partner and I use Apple Home’s geofence settings for first-person-arrived and last-person-left automations, I wanted to automate arming and disarming the alarm based on presence. This eliminates the need to manually interact with the alarm panel every time we come and go. While Apple Home allows geofence-based triggers for sensitive devices like alarms, locks, and garage doors, it requires user confirmation when these actions are triggered. While this is a sensible security measure for most users, we prefer automatic arming and disarming with a push notification for validation.

Apple’s confirmation requirement can be bypassed by using switches, which allow direct control of sensitive devices in automations. The Homebridge Envisalink Ademco plugin supports speedkeys, which act as custom switches that send specific commands to the alarm system. Below is an example of how I configured the Zones and Speedkeys sections in the configuration file.

Zones
This section includes the alarm zones I retrieved from my panel. These zones ensure the supported sensors (e.g., door, window, smoke, motion) are detected and displayed in HomeKit.

    "zones": [
        {
            "name": "Tamper",
            "partition": "1",
            "zoneNumber": "8",
            "sensorType": "door"
        },
        {
            "name": "XX Window",
            "partition": "1",
            "zoneNumber": "13",
            "sensorType": "window"
        },
        {
            "name": "XX Heat",
            "partition": "1",
            "zoneNumber": "14",
            "sensorType": "smoke"
        },
        {
            "name": "XX Motion",
            "partition": "1",
            "zoneNumber": "15",
            "sensorType": "motion"

Speedkeys
In this section, I created custom switches (speedkeys) for each alarm state, such as Disarm and Away. These switches send raw command strings in the format <PIN><Ademco Alarm Command> directly to the EnvisaLink TPI, part of the Duo hardware. The following snippet worked without any modifications:

"speedkeys": [
    {
        "name": "Disarm",
        "speedcommand": "@pin1"
    },
    {
        "name": "Away",
        "speedcommand": "@pin2"
    }
]

Behavior in the Home App
The speedkeys will appear as switches in the Home app. By accessing the settings for these switches, you have the option to show them as separate tiles, rename them and make other adjustments. Because the switches have identical names by default, you’ll need to test each one to determine which controls arming and which controls disarming. I recommend renaming them for clarity.

The Homebridge Envisalink Ademco plug-in continuously monitors the EnvisaLink TPI stream, ensuring the alarm state updates accurately in HomeKit. If you want to add additional alarm commands (e.g., Bypass, Max, Night, Stay, etc.), refer to the tpi.js file under exports.alarmcommand.

With these speedkeys configured, I successfully created switches that automate arming and disarming the alarm when triggered by a geofence crossing. This approach not only avoids Apple’s confirmation prompts but also provides push notifications for validation. I'll show how I use these switches in the section below on configuring geofence alarm triggers in the Home App.

Note: I’ve included # comments for clarity in the example configuration file, but you may need to remove them to save the file correctly.

{
    "name": "Envisalink-Ademco",
    "host": "192.168.XX.XX", # Enter the IP for your Duo
    "port": 4025,
    "deviceType": "20P",
    "password": "XXXXXX", # Enter last 6 digits of your Duo MacID
    "pin": "XXXX", # Enter your alarm pin
    "changePartition": false,
    "openZoneTimeout": 30,
    "heartbeatInterval": 30,
    "commandTimeOut": 10,
    "autoReconnect": true,
    "sessionWatcher": true,
    "chimeToggle": false,
    "envisalinkFailureSuppress": false,
    "ignoreFireTrouble": false,
    "ignoreSystemTrouble": false,
    "maintenanceMode": false,
    "policePanic": {
        "enabled": true,
        "name": "Police Panic"
    },
    "firePanic": {
        "enabled": true,
        "name": "Fire Panic"
    },
    "ambulancePanic": {
        "enabled": true,
        "name": "Ambulance Panic"
    },
    "partitions": [
        {
            "name": "House"
        }
    ],
    "zones": [
        {
            "name": "Tamper",
            "partition": "1",
            "zoneNumber": "8",
            "sensorType": "door"
        },
        {
            "name": "XX Door",
            "partition": "1",
            "zoneNumber": "9",
            "sensorType": "door"
        },
        {
            "name": "XX Door",
            "partition": "1",
            "zoneNumber": "10",
            "sensorType": "door"
        },
        {
            "name": "XX Door",
            "partition": "1",
            "zoneNumber": "11",
            "sensorType": "door"
        },
        {
            "name": "XX Window",
            "partition": "1",
            "zoneNumber": "12",
            "sensorType": "window"
        },
        {
            "name": "XX Window",
            "partition": "1",
            "zoneNumber": "13",
            "sensorType": "window"
        },
        {
            "name": "XX Heat",
            "partition": "1",
            "zoneNumber": "14",
            "sensorType": "smoke"
        },
        {
            "name": "XX Motion",
            "partition": "1",
            "zoneNumber": "15",
            "sensorType": "motion"
        }
    ],
    "bypass": [
        {
            "enabledbyPass": true
        }
      ],
    "speedKeys": [
        {
            "name": "Disarm",  
            "speedcommand": "@pin1"
        },
        {
            "name": "Away",
            "speedcommand": "@pin2"
        }
    ],
    "_bridge": {
        "username": "XX:XX:XX:XX:XX:XX", # Auto-added just redacted mine
        "port": 50577
    },
    "platform": "Envisalink-Ademco"
}

Adding the JSON Configuration File to the Plugin

I then pasted my updated configuration file into the Homebridge Envisalink Ademco plugin settings under the JSON Config section in Homebridge and restarted Homebridge.

Creating a Child Bridge and Pairing with the Home App

After restarting, I returned to the plugin, selected Child Bridge Config, and paired it with the Home app.

A QR code will be displayed, which you can scan with your iOS device to guide you through the pairing process.

Once the plugin is successfully paired as a bridge, a confirmation message will appear on the screen.

Adding Honeywell Zones to the Duo Portal

Performing the next series of steps simply ensures I have pretty names for all of my devices if I opt to use the Eyezon services. I logged into the Eyezon web portal and navigated to Systems > Settings.

I scrolled down to Zone Labels and selected Manage Zone Labels.

Next, I added each zone and label name from my Homebridge Envisalink Ademco configuration file to the Duo portal, ensuring I selected the appropriate partition before submitting each entry.

Viewing Alarm Sensors in the Apple Home App

With the Homebridge Envisalink Ademco plugin configured and Duo zones updated, I launched the Apple Home app. Sure enough, now all of my alarm’s contact sensors, motion sensors, and alarm sensors appeared, ready to be integrated into Apple Home automations. In my case, some alarm entities were displayed in a room as tabs above physical devices.

Configuring Geofence Alarm Triggers in the Home App

Refer to the 9/25 update at the end, which notes a few minor adjustments for setting up speed keys in v2.1.0. FWIW I self-resoled in this Github issue.

Since my partner and I use Apple Home’s geofence settings for first-person-arrived and last-person-left automations, I wanted to automate arming and disarming the alarm based on presence, removing the need to manually access the panel each time we come and go.

To enable this feature, I added the arm and disarm switches I created using speedkeys to their respective automations. It's worth noting before doing this I renamed my speedkey switches to Disarmed Home and Armed Away for better clarity.

Using these switches, I configured my geofence automations to trigger the appropriate switches, allowing the alarm to automatically arm and disarm as people come and go.

Configuring an Automation to Arm the Alarm When the Last Person Leaves

In the “When the Last Person Leaves” automation, I set it to turn on “Armed Away,” which arms the alarm (e.g., sets it to Away mode).

Configuring an Automation to Disarm the Alarm When the First Person Arrives

In the “When the First Person Arrives” automation, I set it to turn on “Disarmed Home,” which disarms the alarm (e.g., sets it to off).

Now, when the first person arrives or the last person leaves, the alarm in the home automatically adjusts, and my partner and I receive push notifications from the Home app about the alarm state changes.

If you rely on Apple Home Activity History to track who locked/unlocked or armed/disarmed, note that geofence-triggered arm/disarm events are not attributed to any specific user.

Enabling Critical Alerts to Get Push Notifications When the Alarm Goes Off

Apple Home supports sending Critical Alerts on iOS 15 and iPadOS 15 or later. To ensure these alerts are active, verify that they are enabled under Settings > Notifications > Home.

Once configured, if the security system triggers the alarm when in Away, Home, or Night (e.g., the alarm is activated), you’ll automatically receive the corresponding alert. While no additional automations are required to enable these critical alerts it's worth intentionally setting off your alarm to confirm everything is setup and working correctly.

Manually Adjusting the Alarm in the Apple Home app

It is also possible to manually adjust the alarm modes directly in the Apple Home app.

If you rely on Apple Home Activity History to monitor who armed or disarmed the system, note that manually triggered arm/disarm events are attributed to a specific user, while geofence-triggered events are not.

When Push Notifications Are Sent

Push notifications are sent in these scenarios:

• When someone else sets a mode.
• When an automation sets a mode.
• When you set a mode, but the Home app is closed or the device is locked (conditions set by Apple).

Note: Each person in the household who wants to receive push notifications from the Home app should check Settings > Notifications > Home. For instance, I made sure critical alerts were enabled on my partners phone.

Refining Alarm Notification Wording

A nice implementation detail I discovered is that by assigning the alarm and its sensors to a room named after my home address, I can receive more descriptive notifications. For example, moving the alarm to a room named “123 Main” will generate a push notification that says, “123 Main Alarm was disarmed.” Since the push notification will use the room name where the alarm is installed in the Home app it might read a bit goofy if you don’t adjust it.

Using Alarm Contact Sensors and Motion Sensors in Apple Home Automations

With the Envisalink Ademco plugin configured to expose all entities connected to the alarm, it’s possible to create automations utilizing them.

For instance, I set up an automation to turn on the Den light at night whenever the Front Door is opened, leveraging the Front Door Alarm contact sensor.

Final Thoughts

In the end, integrating my aging Honeywell alarm system into a modern smart home ecosystem was a rewarding challenge. By using Eyezon Duo, Homebridge and carefully configuring the Envisalink Ademco plugin, I was able to breathe new life into an older system while achieving seamless functionality with Apple Home. Automating my alarms with geofencing has significantly enhanced the convenience of securing my home. If you’re considering a similar upgrade, this demonstrates that even legacy systems can adapt to modern smart home needs with the right tools and effort.

A big thank you to haywirecoder for developing the Homebridge plugin for Envisalink Ademco and for taking the time to explain to me how to use speedkeys for arming and disarming. And, for updating it to work with the new Homebridge v2 plugin spec. 🙇

Update 9/25

I recently upgraded to homebridge-envisalink-ademco version 2.1.0 and found that my config required a very minor tweak (in fact, I believe it may have already been broken sometime before the update). If you are upgrading, the speed key is removed from existing first person arrives home, last person leaves home automations and needs to be manually re-added. I adjusted my Speed Key settings to look like this in the Homebridge envisalink-ademco plug-in config:

And, my JSON config now looks like this:

"speedKeys": [
    {
        "name": "Disarm",
        "speedcommand": "custom",
        "customcommand": "@pin1"
    },
    {
        "name": "Away",
        "speedcommand": "custom",
        "customcommand": "@pin2"
    }

Step 1: Set Up a Subdomain on Your DNS provider

If you’re adding a subdomain to an existing domain, log in to your DNS provider (e.g., Cloudflare) and create a new A record. For this example, we'll set up your.site.com pointing to your Home Assistant's private IP address, such as 192.168.86.99.

Step 2: Create API Token (Cloudflare specific)

This will differ depending on your DNS provider. On Cloudflare, you will need to create an API token by following these steps:

1. Register a new API Token by tapping Create New Token

2. Complete the following fields:

• Token Name: Name the token appropriately (e.g., "Home_Assistant") for clarity.
• Permissions:
  • Set Zone > Zone to Read.
  • Set Zone > DNS to Edit. This allows you to modify DNS records while ensuring other zone settings remain secure.
• Zone Resources:
  • Restrict the token to a specific zone (site.com) to minimize exposure.
• Client IP Address Filtering (Optional):
  • If you want to restrict API access to specific IPs (e.g., your Home Assistant instance), set the Operator to Include and input the trusted IP address or range.

3. TTL (Optional):

• If you prefer the token to have a limited lifespan, define the start and end date.

After proceeding, you’ll receive your unique API token. Be sure to save it in a secure location. You’ll also need to use it in Step 4 when registering a new SSL certificate, where you’ll be prompted for the Cloudflare Credential file API token.

Step 3: Install Nginx Proxy Manager

1. Install the Nginx Proxy Manager add-on in Home Assistant.

2. Go to the Info tab and click Start to activate the add-on.

3. Navigate to the Configuration tab, specify the port you’ll use for SSL (e.g., 443), and click Save.

4. Return to the Info tab and click Open Web UI to access the Nginx Proxy Manager interface.

Step 4: Configure the Proxy Host

1. In the Nginx Proxy Manager interface, go to Hosts > Proxy Hosts.

2. On the new page, tap Add Proxy Host.

3. When the proxy host window pops up enter your domain name (e.g., your.site.com), configure the forwarding hostname/IP (e.g., 192.168.86.99), set the forward port (e.g., 8123), and enable Websockets Support.

4. Switch to the SSL tab and select:

• Request a new SSL certificate.
• Enable options: Force SSL, HTTP/2 Support, HSTS Enabled, HSTS Subdomains, and Use a DNS Challenge.
• Select your DNS provider (eg Cloudflare). In the Credentials File Content section, make sure to update it with the API token from Step 2.
• Attempt to save.

Might Need to Troubleshoot Networking Issues

If you encounter issues while saving, check the Home Assistant logs to identify the problem:

1. Go to Settings > System > Logs in Home Assistant.

2. Tap the overflow menu and select Show Raw Logs to review detailed error messages.

For example, I encountered the following error:

Logger: homeassistant.components.http.forwarded
Source: components/http/forwarded.py:90
Integration: HTTP
A request from a reverse proxy was received from 172.30.33.2, but your HTTP settings do not allow it.

This error indicates that the reverse proxy's IP (172.30.33.2) was being denied. To resolve this, add the following lines to your configuration.yaml file:

http:
  use_x_forwarded_for: true
  trusted_proxies:
    - 172.30.33.0/24

Restart Home Assistant for the changes to take effect.

Step 5: Register the Domain Again

After addressing the issue, return to the Nginx Proxy Manager web UI and attempt to register the SSL certificate again. This time, the domain should hopefully register successfully.

Step 6: Add the HTML Add-on

I can’t remember if it was strictly necessary or exactly when I did it in this process, but I definitely installed the HTML5 Push Notifications add-on and recommend doing the same.

Step 7: Test Sending a Notification to the Home Assistant Mobile App

1. In Home Assistant go to Developer Tools > Actions

2. Assuming you've already installed the Home Assistant mobile app and successfully logged in select the action Notifications: Send a notification via mobile_app and enter a message and title and tap perform action.

3. Assuming all is working you'll hopefully see the notification on your mobile device.

Update: Definitely consider EVCC instead.

Overview

As a Tesla owner with an EG4 home solar setup, I wanted to optimize my charging process to make the most out of excess solar energy. I charge my vehicle with the mobile connector that came with my car. It lacks internet connectivity, cannot be programmed to start or stop charging remotely, and cannot dynamically adjust amperage based on the excess energy currently being harvested.

This inspired me to explore automation options for my EV charging, ultimately leading to the development of two automations in Home Assistant tailored to achieve my goals.

While I thoroughly enjoyed going down this rabbit hole, I’d not recommend it to others unless you really enjoy geeking out. Premium vertical solar integrations from Tesla, Span, Enphase, and aftermarket EV smart chargers like Emporia and Wallbox offer reliable and robust smart EV charging solutions compared to the custom setup I’m about to describe in detail. They're worth considering! While they do have some limitations, they provide a hassle-free experience. That said, I wanted to challenge myself to build a custom setup on the cheap and add some functionality they don’t support.

Table of Contents

• Background
• Use Case Overview
  • Energy Flow and Efficiency Challenges
  • About the Automations
• Prerequisites
  • MQTT Broker Configuration
  • Home Assistant Configuration
    • Creating Input Numbers for Thresholds
    • Input Datetime for Tracking
    • Binary Sensors
    • Input Boolean for Manual Charging
• The Automation Workflows
  • Charge Tesla Without Draining Home Battery
  • Charge Tesla from PV Excess
• Custom Dashboard Setup
• Conclusion

Background

When I installed solar panels and batteries, I initially explored upgrading to a smart EV charger, such as the Emporia Level 2 EV Charger with PowerSmart Load Management or the Wallbox Pulsar Plus paired with the required Power Meter.

Both of these solutions can adjust the amperage they supply to an EV based on excess solar production. By dynamically reducing or increasing the charging rate, they ensure efficient use of available solar energy, minimize reliance on the grid, and help avoid overloading the system during periods of lower solar output.

However, their costs range from $600 to $1,200. Moreover, the Emporia charger depends on a cloud provider that could potentially shut down, leaving the unit unusable. Neither option offered integrations that consider home batteries, limiting sourcing options to grid-only, grid and photovoltaic (PV), or PV alone.

For me, it was important to account for both charging and discharging my home battery when charging my electric vehicle (EV). While I’m comfortable using some of my home battery’s stored energy to charge my EV, it's not efficient and I want to ensure there’s always enough reserve for essential household needs and emergencies.

While researching how to integrate my EV charger into my solar setup, I discovered that my inverter features a Smart Loads plug.

Smart Loads are loads that the user wants to intelligently, strategically, and automatically enable and disable for the purposes of Load Shedding and Power Shedding in order to maximize Time of Use savings, Off-Grid operation, or maximize or minimize power sold back to the grid.

Initially, it seemed like a promising solution, offering configurable thresholds and failover scenarios to manage how the grid, batteries, and PV supply power to the plug.

However, further research revealed Smart Loads to be buggy, with unclear logic and poor documentation. My conclusion was that the inverter’s hardware was originally designed as an input plug for generators, and later adapted via software for dual-purpose use as a power output—without fully addressing the hardware requirements for the additional functions that were added in software. I decided I wasn't comfortable relying on a hacky plug for my EV charging.

To address these challenges, I aimed to purpose build a solution using a combination of software tools and low-cost hardware components. The setup described below dynamically adjusts the Tesla’s charging amperage based on real-time solar production, home battery status, and my specific charging requirements.

I chose to use the ESPHome Tesla BLE integration, which communicates with the car via Bluetooth to adjust charging settings,  instead of the Tesla Fleet API for several reasons. By avoiding the Fleet API, I sidestepped potential rate limits and dependency on a hosted cloud service for real-time adjustments. I also anticipated Tesla introducing fees that would make the API prohibitively expensive, a prediction that has since proven accurate.

In a previous post, I explained how I set up ESPHome on an ESP32 chip and integrated it with my Tesla and Home Assistant to optimize solar charging.

In this post, I’ll guide you through automating the system using Home Assistant, ESPHome, Teslamate, Eclipse MQTT, and a EG4 solar inverter. I’ll also show you how to use a dashboard to monitor the automations and adjust parameters.

A quick note: if you decide to use this, proceed at your own risk—I make no guarantees about the reliability of my Rube Goldberg-style charging system.

Use Case Overview

The goal is to dynamically adjust the Tesla's charging amperage based on:

• Excess Solar Production: Utilize surplus solar energy that would otherwise be stored in home batteries or exported to the grid.
• Home Battery Status: Prioritize charging the home battery based on preferred battery reserves.
• Car's Rated Battery Range: Adjust charging priority dynamically for daily use—lowering priority when the range exceeds 120 miles and raising it when the range drops below 99 miles.
• Support for Manual Override: For long trips requiring a full charge, I need the option to activate a highly reliable “one-click” mode to charge the car at maximum amperage using the grid while setting a custom battery discharge threshold to prevent the home battery from depleting to its minimum allowed levels. Although this scenario is infrequent, it is crucial that, once activated, it runs uninterrupted by any other automations during the charging period.

Energy Flow and Efficiency Challenges

I quickly discovered that optimizing energy usage requires a basic understanding of the physics of electrical flow, particularly the interplay between DC (direct current) and AC (alternating current). Solar panels and home batteries typically operate on DC power, while most household appliances use AC. Converting between these forms introduces efficiency losses, and while my solar system can invert in one direction and convert in the other, it cannot perform both functions simultaneously.

In an ideal setup, I would have the flexibility to power my house with excess PV energy during the day while simultaneously charging my home battery and, when needed, discharging the battery to supply power to both my car and home concurrently. Unfortunately, I do not have that option.

To maximize energy efficiency and operate within physical constraints, I discovered that I need to carefully manage power flows, balancing the charging of the home and car batteries during the day with excess solar energy while reserving the battery to power the house at night.

A smart energy management system is essential to address these challenges. It optimizes energy efficiency, fulfills typical daily EV driving requirements, and ensures the home battery remains a dependable power source, reducing reliance on the grid. To achieve this, I developed a few automations.

About the Automations

1. Charge Tesla from PV Excess (Automatic):

• Purpose: Automatically harvest excess solar energy to charge the Tesla, suitable for daily driving needs.
• Operation: This automation runs during daylight hours when solar production is sufficient, dynamically adjusting the EV charging rate based on real-time solar data, the car’s battery range, and home battery thresholds.
• Priority: Lower priority; designed not to interfere with manual charging needs.

2. Charge Tesla Without Draining Home Battery (Manual):

• Purpose: Manually triggered to charge the Tesla at maximum power without fully depleting the home battery. Designed for infrequent usage when the car needs to be fully charged for a long road trip.
• Operation: Temporarily overrides the PV excess automation to prioritize rapid charging, with an adjustable threshold for the battery’s discharge rate. This threshold ensures the home battery contributes without being fully drained and resets to its original setting afterward.
• Priority: Higher priority; it can override the PV excess automation but not vice versa, preventing potential disruptions to important travel plans.

By implementing both automations, it's possible to:

• Optimize Daily Charging: Make the most of solar energy for everyday driving.
• Ensure Readiness for Trips: Quickly charge the car when needed without worrying about home battery levels.

Prerequisites

Brace yourself Jason. To set up this system, you'll need the following:

• Home Assistant instance: To host the automations, integrate all the data sources and expose a real-time dashboard.
• Monitor My Solar HACS Integration with their Dongle: For reading and writing data to an EG4 18kpv solar inverter connected to the grid, batteries, PV panels and an EV charger.
• Teslamate with the Teslamate HA MQTT Integration: For reading the vehicles rated battery range in miles.
• Eclipse MQTT (in bridge mode): To allow Home Assistant to import MQTT data from both the solar inverter Dongle and vehicle stats from Teslamate.
• ESPHome Tesla BLE with an ESP32 Chip: To communicate with the Tesla over Bluetooth to know when the charge flap is open, adjust amperage rates, and manage charging.

MQTT Broker Configuration

Since Home Assistant only allows one MQTT integration, I needed to bridge data from both the solar inverter dongle and Teslamate. I used Eclipse Mosquitto to handle this.

Update your Mosquitto configuration file at /usr/local/etc/mosquitto/mosquitto.conf:

# Default listener for authenticated clients (dongle)
listener 1883 0.0.0.0
allow_anonymous false
password_file /etc/mosquitto/passwd

# Listener for TeslaMate (no authentication required)
listener 1884 0.0.0.0
allow_anonymous true

# Persistence settings
persistence true
persistence_location /usr/local/var/lib/mosquitto/

# Logging settings
log_dest file /usr/local/var/log/mosquitto/mosquitto.log
log_type error
log_type warning
log_type notice
log_type information

# Bridge configuration to ingest TeslaMate data
connection teslamate_bridge
address tesla.yourdomain.com:1883
topic teslamate/# in

Note: Replace tesla.yourdomain.com with your actual Teslamate domain.

Key Details:

• Multiple Listeners: Configured two listeners to handle authenticated (dongle) and unauthenticated (Teslamate) clients.
• Bridging: The connection and topic settings bridge data from Teslamate into the MQTT broker.
• Note: My Teslamate instance is running on my Tailscale network with no open ports, so I’m not using a password. However, you might want to consider setting one!

Home Assistant Configuration

All these YAML configuration files must be added to Home Assistant, and the system needs to be restarted for the changes to take effect.

Add to configuration.yaml

To keep things organized, I included separate YAML files for different configurations. These files will need to be created and live at the same level as your Home Assistant configuration.yaml.

input_number: !include tesla_charging.yaml
input_datetime: !include input_datetime.yaml
input_boolean: !include input_boolean.yaml

Creating Input Numbers for Thresholds

Create tesla_charging.yaml with the following content:

tesla_range_threshold:
  name: Tesla Range Threshold  
  min: 50                             
  max: 200                            
  step: 1                             
  unit_of_measurement: "mi"
  icon: mdi:car-battery        
  mode: box                           
  initial: 120                        

tesla_priority_range_threshold:
  name: Tesla Priority Range Threshold
  min: 50                          
  max: 200                         
  step: 1                          
  unit_of_measurement: "mi"
  icon: mdi:car-electric     
  mode: box                        
  initial: 99                      

tesla_high_battery_threshold:
  name: Home Battery High Threshold
  min: 0                          
  max: 100                        
  step: 1                         
  unit_of_measurement: "%"
  icon: mdi:battery-high    
  mode: box                       
  initial: 65                     

tesla_low_battery_threshold:
  name: Home Battery Low Threshold
  min: 0                  
  max: 100                
  step: 1                
  unit_of_measurement: "%"
  icon: mdi:battery-low   
  mode: box                    
  initial: 50                  

tesla_home_power_buffer:
  name: Home Power Buffer 
  min: 0                       
  max: 2000                       
  step: 100                       
  unit_of_measurement: "W"        
  icon: mdi:home-lightning-bolt
  mode: box                 
  initial: 500                    

tesla_validation_period:
  name: Validation Wait Time
  min: 1                
  max: 60                   
  step: 1                   
  unit_of_measurement: minutes
  icon: mdi:timer-outline
  mode: box    
  initial: 3  # Default wait time

Key Details:

• Thresholds: Define customizable thresholds for car range, battery levels, and power buffer.
• Adjustable Parameters: These inputs allow you to tweak the system behavior directly from a friendly dashboard in Home Assistant so you don't need to dive into code to modify the Charge Tesla from PV Excess automation business logic.

Input Datetime for Tracking

Used to store timestamps for when certain conditions are met.

Create input_datetime.yaml:

tesla_last_below_min_amps:
  name: Last Time Below Min Amps
  has_date: true
  has_time: true

Binary Sensors

Define sensors to monitor the charging status of the car and home battery.

Add to binary_sensor.yaml:

- platform: template
  sensors:
    tesla_charging_status:
      friendly_name: "EV Charging"
      value_template: >-
        {{ is_state('switch.tesla_ble_your_device_id_charger_switch', 'on') }}
      attribute_templates:
        power: >-
          {% if is_state('switch.tesla_ble_your_device_id_charger_switch', 'on') %}
            {% set amps = states('number.tesla_ble_your_device_id_charging_amps') | float %}
            {{ (amps * 240) | round }}
          {% else %}
            0
          {% endif %}

    home_battery_charging_status:
      friendly_name: "Battery Charging"
      value_template: >-
        {% set flow = states('sensor.dongle_device_id_batteryflow_live') | float %}
        {{ flow > 0 }}
      attribute_templates:
        power: >-
          {% set flow = states('sensor.dongle_device_id_batteryflow_live') | float %}
          {{ flow if flow > 0 else 0 }}

Note: To customize code on this page for your own use, you'll need to replace:

• your_device_id with your Tesla BLE device ID (e.g., if your device ID is abc123, use tesla_ble_abc123_charging_amps)
• dongle_device_id with your device ID (e.g., if your dongle ID is dongle-XX:XX:XX:XX:XX:XX, use dongle_XX_XX_XX_XX_XX_XX_soc)

Input Boolean for Manual Charging

To manually control the charging process and prevent automations from interfering.

Create input_boolean.yaml:

tesla_manual_charging_active:
  name: Tesla Manual Charging Active
  initial: off

The Automation Workflows

In Home Assistant, the following two automations run independently: one is manual, and the other is automatic. They are specifically designed to avoid interfering with each other, even if triggered simultaneously. Additionally, they include some mechanisms to recover and resume functionality if Home Assistant is interrupted or restarted.

Charge Tesla Without Draining Home Battery

This automation is triggered manually and is designed to ensure that charging the Tesla doesn't deplete the home battery below desired thresholds. It also includes recovery logic to reset settings if charging is interrupted. Currently, I’m allowing my batteries to help charge the car when I’m in a rush, though this may not be a long-term solution due to efficiency losses—around 3% for DC-to-DC conversion and another 10% for DC-to-AC. My reasoning for doing this now is that I installed the system in winter and won’t start earning credits by selling energy back until summer.

Business Logic

• Manual Activation: This automation is manually triggered when you need to charge the car at maximum power, such as before a long trip.
• Home Battery Protection:
  My home batteries are set to discharge to 10% when connected to the grid.
  • If the home battery's state of charge (SOC) is above 51%, it allows the battery to discharge down to 50%.
  • If the SOC is below 50%, it sets the end of discharge (EOD) to 50% to prevent the battery from draining further. When EV charging is complete the EOD is set back to 10%.
    • Note: I’ve heard that the chips in the EG4 inverter use NOR flash, which may have a write cycle lifespan of 10,000 to 100,000 cycles. To preserve their longevity, I’ve been cautious about minimizing the frequency of register writes.
• Charging Process:
  • Wakes up the car and sets the charging amperage to 32A (maximum).
  • Turns on the charger switch to start charging.
• Monitoring and Adjustment:
  • Checks if the charger is still on and adjusts the EOD based on the home battery SOC.
  • Stops when the car reaches its charging limit or if charging is manually stopped.
• Recovery Logic:
  • If charging is interrupted, the automation resets the home battery EOD to its initial value.
  • Turns off the manual charging indicator to allow other automations to run when complete even if there's a reboot mid process.

Adjustable Parameters

• Home Battery Thresholds:
  • Adjust tesla_high_battery_threshold and tesla_low_battery_threshold to set when the automation should adjust the home battery EOD.
• Car Charging Limit:
  • Set via the car's settings; the automation respects the car's charging limit (e.g. 80%, etc.)

Automation YAML:

alias: Charge Tesla Don't Kill Home Battery
description: >
  Charges Tesla while managing home battery discharge levels with recovery logic.
  Ensures the home battery doesn't drain excessively during car charging.

trigger:
  - platform: event
    event_type: call_service
    event_data:
      domain: automation
      service: trigger
      service_data:
        entity_id: automation.charge_tesla_dont_kill_home_battery
  - platform: homeassistant
    event: start
  - platform: state
    entity_id: switch.tesla_ble_your_device_id_charger_switch
    to: "off"

condition:
  - condition: state
    entity_id: input_boolean.tesla_manual_charging_active
    state: "on"
  - condition: template
    value_template: >
      {{ (states('number.tesla_ble_your_device_id_battery_level') | float) <
      (states('number.tesla_ble_your_device_id_charging_limit') | float) }}

action:
  - service: input_boolean.turn_on
    target:
      entity_id: input_boolean.tesla_manual_charging_active

  - service: switch.turn_on
    target:
      entity_id: switch.tesla_ble_your_device_id_ble_connection

  - delay: "00:00:01"

  - service: button.press
    target:
      entity_id: button.tesla_ble_your_device_id_wake_up

  - delay: "00:00:02"

  - service: number.set_value
    target:
      entity_id: number.tesla_ble_your_device_id_charging_amps
    data:
      value: 32

  - variables:
      initial_eod: "{{ states('number.dongle_device_id_eod') }}"

  - choose:
      - conditions:
          - condition: numeric_state
            entity_id: sensor.dongle_device_id_soc
            above: 51
        sequence:
          - service: number.set_value
            target:
              entity_id: number.dongle_device_id_eod
            data:
              value: 10
      - conditions:
          - condition: numeric_state
            entity_id: sensor.dongle_device_id_soc
            below: 50
        sequence:
          - service: number.set_value
            target:
              entity_id: number.dongle_device_id_eod
            data:
              value: 50

  - service: switch.turn_on
    target:
      entity_id: switch.tesla_ble_your_device_id_charger_switch

  - repeat:
      sequence:
        - condition: state
          entity_id: switch.tesla_ble_your_device_id_charger_switch
          state: "on"
        - choose:
            - conditions:
                - condition: numeric_state
                  entity_id: sensor.dongle_device_id_soc
                  below: 50
              sequence:
                - service: number.set_value
                  target:
                    entity_id: number.dongle_device_id_eod
                  data:
                    value: 50
        - delay: "00:00:30"
        - condition: template
          value_template: >
            {{ (states('number.tesla_ble_your_device_id_battery_level') | float) <
            (states('number.tesla_ble_your_device_id_charging_limit') | float) }}
      until:
        - condition: or
          conditions:
            - condition: template
              value_template: >
                {{ (states('number.tesla_ble_your_device_id_battery_level') | float) >=
                (states('number.tesla_ble_your_device_id_charging_limit') | float) }}
            - condition: state
              entity_id: switch.tesla_ble_your_device_id_charger_switch
              state: "off"

  - service: input_boolean.turn_off
    target:
      entity_id: input_boolean.tesla_manual_charging_active

  - service: number.set_value
    target:
      entity_id: number.dongle_device_id_eod
    data:
      value: "{{ initial_eod }}"

Note: Replace your_device_id with the name of your ESPHome device and dongle_device_id with the name of your dongle device macID.

Key Modifications and Choices:

• Manual Charging Indicator: Uses input_boolean.tesla_manual_charging_active to prevent other automations from interfering.
• Recovery Logic: If charging is interrupted (e.g., charger switch turns off), the automation resets the home battery's EOD to its initial value.
• Dynamic EOD Adjustment: Adjusts the home battery EOD based on its current SOC.
• Repeat Loop with Exit Conditions: Continues to adjust EOD and monitor charging until the car is fully charged or charging stops.

Charge Tesla from PV Excess

This automation is triggered automatically and is designed to dynamically adjust the Tesla's charging amperage based on excess solar production and the state of the home battery.

Business Logic

• Automatic Operation: Runs automatically during daylight hours when the car is plugged in and excess solar power is available.
• Charging Logic:
  • Car Range Priority:
    • If car range is below the priority threshold (e.g., 99 miles), prioritize charging the car with up to 95% of the excess solar power.
    • If car range is between the priority threshold and the general threshold (e.g., 99–120 miles), allocate 50–70% of excess power to the car based on home battery SOC.
    • If car range is above the general threshold (e.g., above 120 miles), allocate less power to the car, prioritizing the home battery.
  • Home Battery SOC:
    • Adjusts the allocation of excess power based on the home battery's SOC.
    • If the home battery is low, more power is allocated to it; if it's high, more power can go to the car.
• Amperage Calculation:
  • Calculates the available amperage for charging based on excess solar power.
  • Applies a safety limit to ensure the amperage stays between 0 and 32A.
• Validation Period:
  • Includes a validation period (e.g., 3 minutes) to ensure that once the amperage falls to zero it is sustainable before attempting re-engage the charger.
  • This is one of the few stopgaps to prevent frequent on/off cycles that could lead to vampire drain.

Adjustable Parameters

• Thresholds:
  • tesla_range_threshold: Above this range, car charging is deprioritized.
  • tesla_priority_range_threshold: Below this range, car charging is prioritized.
  • tesla_high_battery_threshold and tesla_low_battery_threshold: Define the SOC levels for the home battery to adjust power allocation.
• Home Power Buffer:
  • tesla_home_power_buffer: Watts reserved to account for rapid fluctuations in home consumption.
• Validation Period:
  • tesla_validation_period: Time in minutes that the amperage must be above the minimum sustainable level (e.g. zero) before starting charging.

Automation YAML:

alias: 🔌 Charge Tesla From PV Excess
description: >
  Optimizes Tesla charging based on solar production and home battery state.
  Includes a validation period to prevent frequent adjustments.

trigger:
  - platform: state
    entity_id: binary_sensor.tesla_plugged_in
    to: "on"
  - platform: time_pattern
    minutes: "/1"

condition:
  - condition: state
    entity_id: input_boolean.tesla_manual_charging_active
    state: "off"
  - condition: state
    entity_id: binary_sensor.tesla_plugged_in
    state: "on"
  - condition: template
    value_template: >
      {{ states('number.tesla_ble_your_device_id_battery_level') | float < 
      states('number.tesla_ble_your_device_id_charging_limit') | float }}
  - condition: numeric_state
    entity_id: sensor.dongle_device_id_pall
    above: 1000
  - condition: sun
    before: sunset
    after: sunrise
  - condition: template
    value_template: >
      {% set solar_production = states('sensor.dongle_device_id_pall') | float %}
      {% set home_consumption = states('sensor.dongle_device_id_pload') | float %}
      {% set home_buffer_watts = states('input_number.tesla_home_power_buffer') | float %}
      {% set solar_excess = solar_production - home_buffer_watts - home_consumption %}
      {{ solar_excess > 0 }}

action:
  - variables:
      calculated_amps: >
        {# Retrieve thresholds #}
        {% set range_threshold = states('input_number.tesla_range_threshold') | float %}
        {% set priority_range_threshold = states('input_number.tesla_priority_range_threshold') | float %}
        {% set high_battery_threshold = states('input_number.tesla_high_battery_threshold') | float %}
        {% set low_battery_threshold = states('input_number.tesla_low_battery_threshold') | float %}
        {% set home_buffer_watts = states('input_number.tesla_home_power_buffer') | float %}

        {# Calculate available power #}
        {% set solar_production = states('sensor.dongle_device_id_pall') | float %}
        {% set home_consumption = states('sensor.dongle_device_id_pload') | float %}
        {% set solar_excess = solar_production - home_buffer_watts - home_consumption %}
        {% set excess_pv_energy = solar_excess / 240 %}
        {% set car_range = states('sensor.tesla_rated_battery_range_mi') | float %}
        {% set house_battery_soc = states('sensor.dongle_device_id_soc') | float %}

        {# Charging logic #}
        {% if car_range < range_threshold %}
          {# Below range threshold #}
          {% if car_range < priority_range_threshold %}
            {% set max_amps = (excess_pv_energy * 0.95) | int %}
          {% elif house_battery_soc > high_battery_threshold %}
            {% set max_amps = (excess_pv_energy * 0.70) | int %}
          {% else %}
            {% set max_amps = (excess_pv_energy * 0.50) | int %}
          {% endif %}
        {% else %}
          {# Above range threshold #}
          {% if house_battery_soc < low_battery_threshold %}
            {% set max_amps = (excess_pv_energy * 0.30) | int %}
          {% elif house_battery_soc < high_battery_threshold %}
            {% set max_amps = (excess_pv_energy * 0.40) | int %}
          {% else %}
            {% set max_amps = (excess_pv_energy * 0.60) | int %}
          {% endif %}
        {% endif %}

        {# Safety limits #}
        {% if max_amps > 32 %}32{% elif max_amps < 0 %}0{% else %}{{ max_amps }}{% endif %}

  - condition: template
    value_template: >
      {% set current_time = now() %}
      {% set last_below_min = states('input_datetime.tesla_last_below_min_amps') %}
      {% set validation_period_minutes = states('input_number.tesla_validation_period') | float %}
      {% set has_sufficient_amps = calculated_amps | int >= min_sustainable_amps %}

      {% if has_sufficient_amps %}
        {% if not last_below_min %}
          true
        {% else %}
          {% set time_diff = (as_timestamp(current_time) - as_timestamp(last_below_min)) / 60 %}
          {{ time_diff >= validation_period_minutes }}
        {% endif %}
      {% else %}
        false
      {% endif %}

  - choose:
      - conditions:
          - condition: template
            value_template: "{{ calculated_amps | int < min_sustainable_amps }}"
        sequence:
          - service: input_datetime.set_datetime
            target:
              entity_id: input_datetime.tesla_last_below_min_amps
            data:
              timestamp: "{{ now().timestamp() }}"

  - choose:
      - conditions:
          - condition: template
            value_template: "{{ calculated_amps | int >= min_sustainable_amps }}"
        sequence:
          - service: switch.turn_on
            target:
              entity_id: switch.tesla_ble_your_device_id_ble_connection

          - delay: "00:00:01"

          - service: button.press
            target:
              entity_id: button.tesla_ble_your_device_id_wake_up

          - delay: "00:00:02"

          - service: number.set_value
            target:
              entity_id: number.tesla_ble_your_device_id_charging_amps
            data:
              value: "{{ calculated_amps }}"

          - service: switch.turn_on
            target:
              entity_id: switch.tesla_ble_your_device_id_charger_switch

      - conditions:
          - condition: template
            value_template: "{{ calculated_amps | int < min_sustainable_amps }}"
          - condition: state
            entity_id: switch.tesla_ble_your_device_id_charger_switch
            state: "on"
        sequence:
          - service: switch.turn_off
            target:
              entity_id: switch.tesla_ble_your_device_id_charger_switch

variables:
  min_sustainable_amps: 1

mode: single
max_exceeded: silent

Note: Replace your_device_id with the name of your ESPHome device and dongle_device_id with the name of your dongle device macID.

Key Features:

• Dynamic Amperage Calculation: Adjusts charging amperage based on solar excess, car range, and battery SOC.
• Validation Period: Includes a validation period (adjustable via the dashboard) to ensure the charging current remains above a minimum sustainable level before re-engaging the charger.
• Priority Logic: Prioritizes car charging or home battery charging based on defined thresholds.
• Safety Checks: Ensures amperage stays within safe limits (1–32 A).

Key Modifications and Choices:

• Avoiding Frequent BLE Communication: The validation period attempts to reduces the frequency of Bluetooth communications with the car, which can be resource-intensive.
• Manual Charging Override: Checks if manual charging is active to prevent automation conflicts.
• Use of Variables: Improves readability and maintainability by using variables for thresholds and calculations.

Custom Dashboard Setup

I created a custom dashboard in Home Assistant to monitor and adjust the system parameters.

Dashboard YAML Configuration:

title: Tesla PV Charging
views:
  - title: Main
    path: main
    badges: []
    cards:
      - type: markdown
        style: |
          ha-card {
            height: auto;
            min-height: 100px;
            padding: 16px;
            margin: 8px;
            background: var(--card-background-color);
            opacity: 0;
            animation: fadeIn 0.5s ease-in forwards;
            animation-delay: 0.5s;
          }
          @keyframes fadeIn {
            to {
              opacity: 1;
            }
          }
          ha-markdown {
            font-size: 14px !important;
            line-height: 1.8 !important;
            min-height: 400px;
          }
        content: |-
          {% if states('sensor.tesla_rated_battery_range_mi') != 'unavailable' 
             and states('sensor.dongle_device_id_soc') != 'unavailable' %}
            {% set range_threshold = states('input_number.tesla_range_threshold') | float(120) %}
            {% set priority_range_threshold = states('input_number.tesla_priority_range_threshold') | float(100) %}
            {% set high_battery_threshold = states('input_number.tesla_high_battery_threshold') | float(80) %}
            {% set low_battery_threshold = states('input_number.tesla_low_battery_threshold') | float(20) %}
            {% set solar_production = states('sensor.dongle_device_id_pall') | float(0) %}
            {% set home_consumption = states('sensor.dongle_device_id_pload') | float(0) %}
            {% set home_buffer_watts = states('input_number.tesla_home_power_buffer') | float(500) %}
            {% set solar_excess = solar_production - home_buffer_watts - home_consumption %}
            {% set excess_pv_energy = solar_excess / 240 %}
            {% set car_range = states('sensor.tesla_rated_battery_range_mi') | float(0) %}
            {% set house_battery_soc = states('sensor.dongle_device_id_soc') | float(0) %}
            {% set actual_charging_current = states('sensor.tesla_charger_actual_current') | float(0) %}
            🚙 Range: {{ car_range | round(1) }} mi
            🔋 Added: {{ states('sensor.tesla_charge_energy_added') | float(0) | round(1) }} kWh{% if car_range < priority_range_threshold %}
            ⚠️ Car: Priority Charging needed (below {{ priority_range_threshold }}mi){%- elif car_range < range_threshold -%}
            📊 Car: Normal Charging mode (below {{ range_threshold }}mi){% else %}
            ⛽ Car: Conservative Charging (above {{ range_threshold }}mi){% endif %}
            🚗 Set Amps: {{ states('number.tesla_ble_your_device_id_charging_amps') | float(0) }}A{% set manual_charging = is_state('input_boolean.tesla_manual_charging_active', 'on') %}
            ⚡ Manual Grid Charging: {{ "On" if manual_charging else "Off" }}
            👀 EV Charging: {% if actual_charging_current > 0 %}Yes {{ (actual_charging_current * 240) | round }}W{% else %}No{% endif %}

            🏡 Battery: {{ house_battery_soc | round(1) }}%
            🪫 Discharge Level: {{ states('number.dongle_device_id_eod') | float(10) }}%{% if house_battery_soc < low_battery_threshold %}
            ⚠️ House: Prioritizing Home Battery (below {{ low_battery_threshold }}%){% elif house_battery_soc < high_battery_threshold %}
            📊 House: Moderate Charging mode (below {{ high_battery_threshold }}%){% else %}
            ✅ House: Increased Car Charging enabled (above {{ high_battery_threshold }}%){% endif %}
            👀 Battery Charging: {% if is_state('binary_sensor.home_battery_charging_status', 'on') %}Yes {{ state_attr('binary_sensor.home_battery_charging_status', 'power') | float(0) | round }}W{% else %}No{% endif %}

            🌞 Harvest: {{ solar_production | round }}W
            🏠 Use: {{ home_consumption | round }}W
            🛟 Buffer: {{ home_buffer_watts | round }}W
            ➕ Excess: {{ solar_excess | round }}W
            🔌 Available for car: {{ excess_pv_energy | round(1) }}A
          {% else %}
            Loading data...
          {% endif %}
      - type: entities
        title: System Thresholds
        entities:
          - entity: input_number.tesla_range_threshold
            name: Range Threshold
          - entity: input_number.tesla_priority_range_threshold
            name: Priority Range
          - entity: input_number.tesla_high_battery_threshold
            name: High Battery
          - entity: input_number.tesla_low_battery_threshold
            name: Low Battery
          - entity: input_number.tesla_home_power_buffer
            name: Home Power Buffer
          - entity: input_number.tesla_validation_period
            name: Wait Time >= 1A
            control_mode: box
      - type: entities
        entities:
          - type: button
            name: 🔌 Tesla 🚙 Don't Kill 🏡 🔋
            icon: mdi:car-electric-outline
            tap_action:
              action: call-service
              service: automation.trigger
              target:
                entity_id: automation.charge_tesla_dont_kill_home_battery
      - type: horizontal-stack
        cards:
          - type: gauge
            name: Car Range
            entity: sensor.tesla_rated_battery_range_mi
            min: 0
            max: 300
            severity:
              green: 120
              yellow: 99
              red: 0
          - type: gauge
            name: Home Battery
            entity: sensor.dongle_device_id_soc
            unit: '%'
            min: 0
            max: 100
            severity:
              green: 65
              yellow: 50
              red: 0
      - type: history-graph
        title: Power Distribution (24h)
        hours_to_show: 24
        entities:
          - entity: sensor.dongle_device_id_pall
            name: Solar Production
          - entity: sensor.dongle_device_id_pload
            name: Home Consumption
          - entity: number.tesla_ble_your_device_id_charging_amps
            name: Car Charging Rate

Key Features:

• Dynamic Data Display: The markdown card shows real-time data and status messages.
• Adjustable Thresholds: Entities card allows you to adjust system thresholds on the fly.
• Manual Control: A button to manually trigger the "Charge Tesla Without Draining Home Battery" automation.
• Visual Gauges: Quick view of car range and home battery status.
• Historical Graph: Monitor power distribution over the last 24 hours.

Note: Replace your_device_id and dongle_device_id with your actual device IDs in the dashboard configuration.

Conclusion

By integrating data into Home Assistant via MQTT from Teslamate, my solar inverter using the Monitor My Solar dongle, and my Tesla using an ESP32 chip running ESPHome Tesla BLE, I created a dynamic system that optimizes Tesla charging based on real-time solar production and home energy demands.

The customizable dashboard provides monitoring and adjustment of parameters, ensuring efficient management of both the car and home battery. Additionally, when rapid EV charging is needed, the system avoids depleting the home battery.

Although I learned a lot and already had many prerequisites in place, which made the configuration relatively quick, I find the setup fragile and likely to be annoying to maintain. I plan to keep it running and hope it won’t cause too many headaches. However, I intend to be cautious about investing significant additional effort into optimizing it unless the improvements are clearly worthwhile.

Benefits of this setup:

• Energy Efficiency: Maximizes the use of excess solar energy.
• Cost Savings: Reduces reliance on grid electricity, lowering energy bills.
• Environmental Impact: Enhances the use of renewable energy sources.
• Affordability: Extremely budget-friendly, with the ESP32 chip costing $6.
• Customization and Control: Allows you to control the logic and easily tweak the setup to meet specific needs.

I’d love to hear your thoughts, feedback, or experiences if you actually try using this approach. Hopefully, we’ll see simpler aftermarket solutions from vehicle manufacturers integrating this functionality into their chargers in an open and accessible way.

Happy charging!

I set up an ESP32 M5NanoC6 development kit chip with the esphome-tesla-ble project to connect to my Tesla over Bluetooth. This setup allows the chip to communicate with the car when it’s nearby, using the ESPHome native API to share data with Home Assistant over Wi-Fi. With this integration, I can automate tasks like adjusting charging amperage and starting/stopping charging based on surplus solar energy from my inverter. For now, this guide covers flashing the chip and integrating it with Home Assistant. I’ll follow up with a post to automations designed to optimize charging from excess solar.

Thanks

This wouldn't be possible without Yasir Ekinci who created the tesla-ble library for communicating with Tesla vehicles locally via the BLE API. And, for integrating that work into esphome-tesla-ble so that it works with ESPHome and exposes dashboards in Home Assistant.

Background and Objective

This project uses the esphome-tesla-ble library to enable local BLE communication between an ESP32 and a Tesla, providing an offline alternative to the official Tesla API while avoiding rate limits. The goal is to dynamically manage charging by creating Home Assistant automations, such as adjusting amperage or stopping charging based on solar production. Since the car defaults to the mobile wall charger’s maximum of 32 amps, regulating amperage is essential to prevent exceeding available solar capacity and I needed a way to automate that.

Tested Hardware and Environment

1. Hardware: ESP32 M5NanoC6 development kit (other models work, but this is the one I used and can confirm is compatible), Tesla Vehicle Key Card.
2. Environment: Apple Silicon MacBook Pro running macOS Sequoia.
3. Software: ESPHome Tesla BLE repo by Yoziru, local Home Assistant instance, and ESPHome add-on for Home Assistant.

Flashing the ESP32

The ESP32 chip needs to be flashed twice.

About the First Flash: Enable the BLE Listener
The initial flash enables a BLE (Bluetooth Low Energy) listener on the ESP32. This listener’s purpose is to scan for nearby BLE devices and capture the Tesla’s unique BLE MAC ID. The Tesla emits this MAC ID when you place your key card on the car’s designated holder, signaling the car to start broadcasting BLE data. This step is critical because the Tesla’s BLE MAC ID is required to configure the ESP32 as a BLE key. Without discovering this ID, the ESP32 cannot interact with the Tesla via BLE.

About the Second Flash: Configure and Finalize the ESP32
Once the Tesla’s BLE MAC ID is obtained and added to the configuration (secrets.yaml), the BLE listener is no longer needed. The second flash:

1. Disables the BLE listener to stop scanning for devices (which would interfere with normal operations).

2. Configures the ESP32 to use the discovered Tesla BLE MAC ID to authenticate and act as a BLE key.

3. Finalizes the firmware, allowing the ESP32 to communicate with the Tesla and control features such as charging and amperage settings.

The following steps assume you already have Home Assistant set up and have an ESP32 M5NanoC6 chip.

Flashing the chip and integrating it with Home Assistant

1. Set up your Python environment and clone the ESPHome Tesla BLE repository:

# Create a new Python 3.11 virtual environment named 'esphome-tesla-ble'
python3.11 -m venv esphome-tesla-ble

# Change into the newly created virtual environment directory
cd esphome-tesla-ble

# Activate the virtual environment
source bin/activate

# Clone the yoziru/esphome-tesla-ble repository from GitHub
git clone https://github.com/yoziru/esphome-tesla-ble

# Change into the cloned repository directory
cd esphome-tesla-ble

# Install the required Python dependencies from the requirements file
pip install -r requirements.txt

2. Configure secrets.yaml

Before compiling, create and populate a secrets.yaml file at esphome-tesla-ble/esphome-tesla-ble file with your Wi-Fi credentials, an API encryption key, default BLE macID, and your Tesla VIN:

wifi_ssid: "my_wifi"
wifi_password: "my_password"
wifi_hotspot_password: "my_hotspot_password"
ota_password: ""
api_encryption_key: "my_encryption_key" # random key from https://esphome.io/components/api.html#configuration-variables
ble_mac_address: "A0:B1:C2:D3:E4:F5"
tesla_vin: "my_tesla_vin"

3. Enable the BLE Listener

In the tesla-ble-m5stack-nano6.yml configuration file, enable the BLE listener by uncommenting the line so it looks like this:

listener: !include packages/listener.yml

This instructs the ESP32 to run in “listening mode” after the first flash.

4. Compile the Firmware

Run the following command inside esphome-tesla-ble/esphome-tesla-ble to compile the firmware for the M5NanoC6 board:

make compile BOARD=m5stack-nanoc6

This will generate the firmware binary tailored to your ESP32 board with the BLE listener enabled.

Note: If you're using a different chip than me you could try just pointing at the yaml you're using and compile like this esphome compile tesla-ble-esp32-generic.yml

5. Flash the ESP32 the first time

Now upload the compiled firmware to the ESP32 from esphome-tesla-ble/esphome-tesla-ble:

• Connect the ESP32 to your computer via USB.
• Run the upload command

make upload

• When prompted, select the USB port for your ESP32 (e.g., /dev/cu.usbmodem1101).

6. In your terminal note down the ESP32 Device Name Suffix

After flashing, the ESP32 will reboot and appear with a name like tesla-ble-<suffix>. The <suffix> is a unique identifier, such as 5ae9cc. Note this suffix, as you’ll use it to monitor logs in a future step.

7. Locate the ESP32’s IP Address on Your Network

Using a network scanner, or by logging in to your router’s admin interface, check for the ESP32 device on your Wi-Fi network and note its IP Address as you may need it to add the device manually to Home Assistant if it’s not auto-discovered:

• Manufacturer: Espressif Inc.
• MAC Address: May start with 40:4C:CA
• Name: Might appear as tesla-ble-<suffix>.lan (though this may not resolve due to your network config, eg using stuff like Tailscale).

Note: If you end up having to manually add the ESP device by its IP address you might want to consider setting the ESP device with a reserved IP address on your router.

8. Install the ESPHome add-on to Home Assistant

In Home Assistant, I navigated to Settings > Devices & Services, I tapped on Add Integration and searched for and installed the ESPHome addon.

9. Add the ESPHome device to Home Assistant and Configure

My ESP32 immediately appeared as a device ready to be added. If you don't see yours you can add it by its IP Address.

After adding the device, I entered my encryption key when prompted.

Then, I scrolled to the configured devices, selected ESPHome, and enabled debug logging. This allows me to use the logs in Home Assistant to debug but I stuck with my terminal for debugging.

Under the 1 device section, I accessed the diagnostics menu, enabled the BLE Connection, and confirmed that pressing the physical button on the ESP32 temporarily toggled the diagnostics Button status to “On.”

10. Monitor Logs to Discover Tesla BLE MAC ID

Open a new terminal tab. With the ESP32 in listening mode, you can now monitor its logs to find your Tesla’s BLE MAC ID:

• Run the following command in the terminal:

make logs HOST_SUFFIX=-<suffix>

Note: Replace <suffix> with the unique identifier from Step 6 (e.g., mine would be make logs HOST_SUFFIX=-5ae9cc).

11. Take your computer, ESP32, and Tesla key card to your vehicle

Sitting inside the car being sure your chip can get wifi, place your Tesla key card on the armrest holder, and monitor the logs. The Tesla should begin to broadcast its BLE MAC ID, which will be displayed in the terminal output.

[20:04:45][I][tesla_ble_listener:050]: Found Tesla vehicle | Name: [VIN_REDACTED]
MAC: BO:F8:XX:XX:XX

12. Update Secrets.yaml with BLE macID

Update secrets.yaml file at esphome-tesla-ble/esphome-tesla-ble and replace the ble_mac_address field with your macID (eg BO:F8:XX:XX:XX):

ble_mac_address="BO:F8:XX:XX:XX"

13. Disable the BLE Listener

In the tesla-ble-m5stack-nano6.yml configuration file, disable the BLE listener by commenting the line so it looks like this:

# listener: !include packages/listener.yml

This instructs the ESP32 to stop running in “listening mode” since it's no longer necessary.

14. Flash the ESP32 the second time

make clean
make compile BOARD=m5stack-nanoc6
make upload

When prompted, select the USB port for the ESP32 (e.g., /dev/cu.usbmodem1101).

15. Pair the ESP32 as a Tesla Key

• Return to Home Assistant and navigate to the ESPHome diagnostics screen.
  • Settings > Devices & Services, scroll to the configured section and find ESPHome and tap on 1 device

• On the ESPHome diagnostics card tap the text that says Press next to "Pair BLE Key".

• Place your Tesla key card on the armrest again and accept the pairing request from the car. After accepting, rename the key to something memorable like ESPHome Key since it will otherwise be called Unknown device.

16. Confirm integration works in Home Assistant

• On the ESPHome diagnostics screen attempt to adjust the controls such as charging amps and confirm it updates in realtime in the car charging UX.

Results

After completing these steps, the ESP32 successfully connected to Home Assistant and began sending and receiving data from the Tesla. It's now possible to view Tesla sensors and controls in Home Assistant:

• Wake Vehicle
• Set charging amps
• Set charging limit (percent)
• Turn on/off charging
• BLE information sensors
  • Asleep / awake
  • Doors locked / unlocked
  • User present / not present
  • Charging flap open / closed (only when vehicle is awake)
  • BLE signal strength

Next Steps

• Create Automations: Set up Home Assistant automations to dynamically manage Tesla charging based on solar production.
  

Today, my wife returned from a Fatcake ride with something exciting: their new 60 for 60 formula carb sports drink! It turns out Lisa and Richard have started a new company called Hummingbird Fuels, set to launch in January 2025. I couldn't be more thrilled for them.

I absolutely ❤️ this from their site:

We created this product because we saw a gap in the market. Too many brands creating complicated formulas, celebrating “bro science” and promoting the lie that you need to suffer, to be considered an athlete.

THIS IS NOT OUR VIBE.

As my wife rode home with the package sticking out of her jersey, a fellow cyclist noticed it and exclaimed, "You’ve got Hummingbird Fuels?! I love Lisa and Richard!" Clearly, we’re not the only ones excited about their launch. Keep an eye out.

Hummingbird Fuels

Carbohydrate sports drink delivering 60 grams of carbs for 60 minutes of activity. Our 60 for 60 formula makes fueling your activities easy. Swimming, running, cycling, whatever. Drink your fuel. Fuel your fun.

Hummingbird FuelsSkip to Content

Baños’s passion and expertise are well-documented through his publications, The Blackguard Book and The Pinecaster Book, which explore the history and construction of early solid-body electric guitars. His commitment to detail ensures that each guitar he recreates captures the essence of the original instruments, appealing to enthusiasts seeking vintage aesthetics and sound.

To achieve this level of authenticity for the Burst series, Nacho Guitars has developed custom pickguards, pickup rings, nickel-plated brass hardware parts (saddles, thumbwheels, posts), NAF pickups (Nacho Applied For), vintage-spec 500k Nacho-pots, lacquer formulas, and more. Every detail is crafted using their original Gibson collection as a reference, with guidance and support from a board of Gibson Les Paul experts.

Nacho Guitars has attracted fans ranging from Julian Lange to Billy Gibbons of ZZ Top, both of whom have publicly praised their craftsmanship. Gibbons’s endorsement of the Burst series underscores the quality and authenticity of these instruments. In interviews, Gibbons has shared his appreciation for Nacho Guitars and their faithful reproductions of vintage classics.

I can only hope to experience one of these masterpieces in person someday.

1. On your Home Assistant VM create a script to install the weather underground integration:

vi install_wundergroundpws.sh

#!/bin/bash

# Step 1: Create a temporary directory
mkdir -p /tmp/wundergroundpws_install
cd /tmp/wundergroundpws_install

# Step 2: Download the file
wget https://github.com/cytech/Home-Assistant-wundergroundpws/archive/refs/tags/v2.0.9.tar.gz

# Step 3: Extract the tar.gz file
tar -xzf v2.0.9.tar.gz

# Step 4: Move the `wundergroundpws` folder to the target directory
sudo mv Home-Assistant-wundergroundpws-2.0.9/custom_components/wundergroundpws /opt/homeassistant_config/custom_components/

# Step 5: Clean up the temporary directory
cd ~
rm -rf /tmp/wundergroundpws_install

echo "wundergroundpws custom component has been moved to /opt/homeassistant_config/custom_components/"

Note: you will likely need to modify the script to the latest binary and the path to your .homeassistant directory.

2. Make the script executable:

chmod +x install_wundergroundpws.sh

3. Run the script which will download the integration and move it to the correct directory:

./install_wundergroundpws.sh

4. Restart Home Assistant so that it can recognize the new integration.
5. Once rebooted in Home Assistant navigate to Settings > Devices & Services. Then, tap on Add Integration and search for the wundergroundpws integration.

6. Install the integration and when prompted enter your Weather Underground API key and your Station ID.
7. Once configured it's time to create a dashboard to expose the items. Here's a simple stab at creating a view of Todays Weather. Replace YOUR_STATION_ID with yours.

views:
  - title: Weather Station YOUR_STATION_ID
    path: weather
    cards:
      - type: entities
        title: Current Conditions
        entities:
          - entity: sensor.YOUR_STATION_ID_temperature
            name: Temperature
            icon: mdi:thermometer
          - entity: sensor.YOUR_STATION_ID_heat_index
            name: Heat Index
            icon: mdi:thermometer-high
          - entity: sensor.YOUR_STATION_ID_wind_chill
            name: Wind Chill
            icon: mdi:thermometer-low
          - entity: sensor.YOUR_STATION_ID_dewpoint
            name: Dew Point
            icon: mdi:water-percent
          - entity: sensor.YOUR_STATION_ID_relative_humidity
            name: Humidity
            icon: mdi:water-percent
      - type: weather-forecast
        entity: weather.YOUR_STATION_ID
        show_forecast: true
      - type: entities
        title: Precipitation
        entities:
          - entity: sensor.YOUR_STATION_ID_precipitation_rate
            name: Current Rate
            icon: mdi:weather-pouring
          - entity: sensor.YOUR_STATION_ID_precipitation_today
            name: Today's Total
            icon: mdi:weather-rainy
      - type: glance
        title: Wind Conditions
        entities:
          - entity: sensor.YOUR_STATION_ID_wind_speed
            name: Wind Speed
            icon: mdi:weather-windy
          - entity: sensor.YOUR_STATION_ID_wind_gust
            name: Wind Gust
            icon: mdi:weather-windy-variant
          - entity: sensor.YOUR_STATION_ID_wind_direction_cardinal
            name: Direction
            icon: mdi:compass
          - entity: sensor.YOUR_STATION_ID_wind_direction_degrees
            name: Degrees
            icon: mdi:compass-outline
      - type: history-graph
        title: Temperature History
        hours_to_show: 24
        entities:
          - entity: sensor.YOUR_STATION_ID_temperature
            name: Temperature
          - entity: sensor.YOUR_STATION_ID_heat_index
            name: Heat Index
          - entity: sensor.YOUR_STATION_ID_wind_chill
            name: Wind Chill
      - type: history-graph
        title: Wind History
        hours_to_show: 24
        entities:
          - entity: sensor.YOUR_STATION_ID_wind_speed
            name: Wind Speed
          - entity: sensor.YOUR_STATION_ID_wind_gust
            name: Wind Gust
      - type: entities
        title: Station Information
        entities:
          - entity: sensor.YOUR_STATION_ID_pressure
            name: Barometric Pressure
            icon: mdi:gauge
          - entity: sensor.YOUR_STATION_ID_elevation
            name: Elevation
            icon: mdi:elevation-rise
          - entity: sensor.YOUR_STATION_ID_station_id
            name: Station ID
            icon: mdi:weather-cloudy
          - entity: sensor.YOUR_STATION_ID_neighborhood
            name: Location
            icon: mdi:map-marker
          - entity: sensor.YOUR_STATION_ID_local_observation_time
            name: Last Updated
            icon: mdi:clock-outline
      - type: glance
        title: Solar Conditions
        entities:
          - entity: sensor.YOUR_STATION_ID_solar_radiation
            name: Solar Radiation
            icon: mdi:sun-wireless
          - entity: sensor.YOUR_STATION_ID_uv_index
            name: UV Index
            icon: mdi:sun-clock

The above dashboard will look something like this:

8. I decided to enable weather forecasts which is an option in the integration. Here's a simple dashboard focused on exposing those attributes. Replace YOUR_STATION_ID with yours.

views:
  - title: Weather Forecast
    path: weather
    cards:
      - type: entities
        title: Tonight's Forecast
        entities:
          - entity: sensor.YOUR_STATION_ID_weather_summary_0
            name: Forecast
            icon: mdi:weather-night
          - entity: sensor.YOUR_STATION_ID_precipitation_probability_1n
            name: Precipitation Chance
            icon: mdi:weather-rainy
          - entity: sensor.YOUR_STATION_ID_precipitation_amount_1n
            name: Precipitation Amount
            icon: mdi:water
          - entity: sensor.YOUR_STATION_ID_snow_amount_0
            name: Snow Amount
            icon: mdi:snowflake
      - type: entities
        title: Tomorrow's Forecast
        entities:
          - entity: sensor.YOUR_STATION_ID_weather_summary_1
            name: Forecast
            icon: mdi:weather-sunny
          - entity: sensor.YOUR_STATION_ID_precipitation_probability_2d
            name: Precipitation Chance
            icon: mdi:weather-rainy
          - entity: sensor.YOUR_STATION_ID_precipitation_amount_2d
            name: Precipitation Amount
            icon: mdi:water
          - entity: sensor.YOUR_STATION_ID_snow_amount_1
            name: Snow Amount
            icon: mdi:snowflake
      - type: entities
        title: Tomorrow Night's Forecast
        entities:
          - entity: sensor.YOUR_STATION_ID_precipitation_probability_3n
            name: Precipitation Chance
            icon: mdi:weather-rainy
          - entity: sensor.YOUR_STATION_ID_precipitation_amount_3n
            name: Precipitation Amount
            icon: mdi:water
      - type: entities
        title: Extended Forecast - Nights
        entities:
          - type: section
            label: Friday Night
          - entity: sensor.YOUR_STATION_ID_precipitation_probability_5n
            name: Precipitation Chance
          - entity: sensor.YOUR_STATION_ID_precipitation_amount_5n
            name: Precipitation Amount
          - type: section
            label: Saturday Night
          - entity: sensor.YOUR_STATION_ID_precipitation_probability_7n
            name: Precipitation Chance
          - entity: sensor.YOUR_STATION_ID_precipitation_amount_7n
            name: Precipitation Amount
          - type: section
            label: Sunday Night
          - entity: sensor.YOUR_STATION_ID_precipitation_probability_9n
            name: Precipitation Chance
          - entity: sensor.YOUR_STATION_ID_precipitation_amount_9n
            name: Precipitation Amount
      - type: entities
        title: Extended Forecast - Days
        entities:
          - type: section
            label: Friday
          - entity: sensor.YOUR_STATION_ID_weather_summary_2
            name: Forecast
          - entity: sensor.YOUR_STATION_ID_precipitation_probability_4d
            name: Precipitation Chance
          - entity: sensor.YOUR_STATION_ID_precipitation_amount_4d
            name: Precipitation Amount
          - type: section
            label: Saturday
          - entity: sensor.YOUR_STATION_ID_weather_summary_3
            name: Forecast
          - entity: sensor.YOUR_STATION_ID_precipitation_probability_6d
            name: Precipitation Chance
          - entity: sensor.YOUR_STATION_ID_precipitation_amount_6d
            name: Precipitation Amount
          - type: section
            label: Sunday
          - entity: sensor.YOUR_STATION_ID_weather_summary_4
            name: Forecast
          - entity: sensor.YOUR_STATION_ID_precipitation_probability_8d
            name: Precipitation Chance
          - entity: sensor.YOUR_STATION_ID_precipitation_amount_8d
            name: Precipitation Amount
    type: masonry

The above dashboard will look something like this:

Alex Sidebar lets you set up a custom model that the editor can use for generating code. To try this out, I decided to run Alibaba’s Qwen2.5-Coder model locally. This new model developed by Alibaba’s Qwen research team is open-source, Apache 2.0 licensed and optimized for coding tasks.

Here’s how I went about setting it up with Ollama as the local server and ngrok to make it accessible to Alex Sidebar.

Why ngrok?

ngrok is essential here because Alex Sidebar, the client application running alongside Xcode, needs a public URL to interact with a local model server. By default, your local server (Ollama in this case) runs on a private localhost address that’s inaccessible from outside your machine. ngrok solves this by creating a secure tunnel that links your local server to a public-facing URL, making it easy for external applications, like Alex Sidebar, to connect. In the coming weeks, Alex Sidebar will support localhost addresses directly, but for now, all traffic is still routed through their server making this a necessity.

Steps to Set Up Ollama, Qwen2.5-Coder, and ngrok

1. Install Ollama and Pull the Model

To begin, make sure you have Ollama installed, as it will manage and serve the Qwen2.5-Coder model locally.

Download Qwen2.5-Coder:
Once Ollama is installed, pull the model in your terminal using:

ollama pull qwen2.5-coder:32b

This will download the Qwen2.5-Coder model to your machine.

2. Run Ollama Server Locally

With the model downloaded, start up the Ollama server to make it accessible on localhost:

ollama serve

Ollama will begin serving the model at http://localhost:11434, the default port.

3. Install and Configure ngrok

Next, set up ngrok to create a public URL for the Ollama server. This public URL will allow Alex Sidebar to connect to the local model server running on your Mac.

Sign Up and Authenticate ngrok:
Go to ngrok.com to create a (free) account and get an authentication token from the dashboard.

Install ngrok on your machine:

brew install ngrok

Then, authenticate ngrok with your auth token:

ngrok config add-authtoken YOUR_AUTH_TOKEN

Replace YOUR_AUTH_TOKEN with your unique token. This step ensures your ngrok tunnels are secure and linked to your account.

Optional: At this stage if you want to test the Qwen model in interactive mode in your terminal, run:

ollama run qwen2.5-coder:32b

4. Expose the Ollama Server Using ngrok

Now that ngrok is authenticated, expose the Ollama server. Since the server is running on port 11434, run:

ngrok http 11434 --host-header="localhost:11434"

ngrok will generate a public URL, like https://randomsubdomain.ngrok-free.app, which securely tunnels traffic to http://localhost:11434. This URL is what you’ll use in the next step for configuring Alex Sidebar.

5. Configure Alex Sidebar to Use the Public URL

With ngrok up and running, go to Alex Sidebar settings and set up a custom model:

• Model ID: qwen2.5-coder:32b (the name of the model)
• Base URL: Paste the public URL provided by ngrok and append /v1 (e.g., https://randomsubdomain.ngrok-free.app/v1).
• API Key: Paste the authtoken provided by ngrok

This configuration tells Alex Sidebar to route its requests to the ngrok public URL, which then tunnels back to your local Ollama server.

Using Alex Sidebar with Qwen an an M1 Mac

After setting up Alex Sidebar to use the Qwen model, I closed the application. Next, I launched Xcode and created a new Swift iOS app. Then, I reopened Alex Sidebar and asked it to ‘generate a simple login flow in Swift.’

After one more prompt, I integrated the LoginViewController with the SwiftUI ContentView and got it working. The local model is a bit slow, so I’ll likely stick with hosted models, but this is an incredible free option! 🤯

Thanks to Daniel Edrisian, founder of Alex Sidebar, for troubleshooting and answering a few questions via Discord!

Additional Notes on Using ngrox

Free accounts can only have 1 active proxy

• To kill any running tunnels via the web you can use their Dashboard, or
• To kill tunnels via terminal run: pkill ngrok

To validate the Qwen model is being served via the tunnel run the following command in a terminal. Note: update randomsubdomain.ngrok-free.app with the public URL provided by ngrok and replace YOUR_AUTH_TOKEN with the one provided by ngrok.

curl -X POST https://randomsubdomain.ngrok-free.app/api/generate \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer YOUR_AUTH_TOKEN" \
  -d '{
        "model": "qwen2.5-coder:32b",
        "prompt": "build a little webpage"
      }'

First, Zoox’s vehicle design is custom-made. Since it's not sold direct to consumers the vehicle hasn't been evaluated by the NHTSA to determine how it performs in crash tests. While these autonomous taxis will be navigating city streets where speed limits average around 25 mph, it’s worth noting that speeding is common, and vehicles on the road are getting heavier, whether they’re larger SUVs, trucks, or EVs packed with batteries. I’d like to see Zoox consider creating and sharing detailed crash test safety data for added rider assurance.

Additionally, Zoox’s CEO, Aicha Evans, stated that they have “passed all critical safety measures,” but the announcement didn’t link to any specific data or sources. This leaves me wondering whether these are internal safety standards, independent third-party verifications, or a mix of both. It would be helpful to know exactly what “critical safety measures” Zoox vehicles have passed.

I'm probably being a bit cynical but the announcement struck me as somewhat disingenuous, given Zoox’s claim that they want to engage with the community and answer questions. While they express a desire for open dialogue, they haven’t provided any direct means to contact them with questions or concerns. I’d have preferred to share this feedback privately rather than in a public forum.

I’m a strong believer that our roads will become safer with the introduction of more automation. However, a rollout like this would benefit from greater transparency—especially around vehicle safety data, the standards they’re using to evaluate the fleet’s readiness, and an accessible channel for community feedback. After all, we’re all sharing the road, and building trust requires open communication.

I purchased a third-party dongle from monitormy.solar, which gave me direct access to the inverter's data. This dongle gives me control over where I share data:

1. MonitorMy.Solar – a cloud-hosted portal managed by the dongle’s manufacturer
2. EG4 monitoring portal - the inverters official cloud-hosted portal
3. Home Assistant via MQTT Broker - a managed or self-hosted Home Assistant instance. Note: For compatibility reasons you will need to ensure HA is configured to use 24-hour time, MQTT is set up with a username and password, and the MQTT connection does not use SSL. *

I can choose to share data with any, all, or none of these options. For local-only access, the dongle also provides a real-time monitoring portal. This flexibility lets me stop sharing with EG4 or any other platform whenever I want.

My Current Setup

Now, my solar data flows directly to a Home Assistant instance running on a Google Cloud e2-micro instance, where I’ve built a very simple real-time dashboard.

For the dashboard design, I used Dante Winter’s Lux Power Distribution Card in Home Assistant to get an interactive power flow diagram. While the default setup for that Card relies on a LuxpowerTek integration hosted in a private repo by Guy Wells, I discovered this isn’t necessary if you have the monitormy.solar dongle. Instead, the sensor data is accessible via the dongle, though it requires a few minor adjustments to redirect to the dongle sensor data states, which I’ve outlined in my lux.yaml.

If you're curious, the dongle offers extensive access to EG4 sensor data, and I highly recommend it for anyone wanting more control and better monitoring. Below, I’ve included a screenshot of my real-time dashboard, and the full setup instructions are available in my GitHub repository.

Get the Code

You can find my GitHub repository here:

GitHub - danielraffel/luxpower-dashboard: Simple realtime Home Assistant dashboard for monitoring an EG4 18kPV Hybrid Inverter solar power system

Simple realtime Home Assistant dashboard for monitoring an EG4 18kPV Hybrid Inverter solar power system - danielraffel/luxpower-dashboard

GitHubdanielraffel

The dongle has been a game-changer, allowing me to monitor my solar power system reliably and without delays. If you're looking to bypass the laggy portals and gain full control of your solar data, I hope this guide and my dashboard can help you do the same!

Huge thanks to Zak at MonitorMySolar for all his support!

Note: My installer created conduit holes on the side of the EG4, just below the dongle’s attachment point, leaving no room for the antenna. To solve the space issue, I connected the dongle with its antenna to the EG4 using an HDMI cable and a Female-to-Female HDMI adapter, allowing me to place the dongle on top of the EG4 unit.

* The GitHub repository details how I configured my dongle to send data to a local MQTT broker on my Tailscale network. That machine then securely relays the data over Tailscale to the cloud-based Home Assistant VM.

Note: The EG4 uses 24-hour time format, so be sure to set it accordingly—it may not be immediately obvious in the user interface. Otherwise, your data in Home Assistant will be off.

As someone who regularly cycles from San Francisco to Marin, I often found myself unprepared for the weather on the Golden Gate Bridge, where the temperature can be 10-15 degrees cooler by the time I arrive than when I leave home.

To address this, I created a site that offers real-time weather conditions—temperature, wind speed, rain probability, and sunset time—so you can dress accordingly before heading out. It also suggests the two best times for your crossing today.

Given that we’re living in the future, I built the site using Flow to quickly dictate prompts to Cursor, an AI code editor. Flow speeds up writing using voice commands, while Cursor handled the coding. The site is built with HTML5, Tailwind CSS, JavaScript, and Axios, which pulls real-time weather data from the Open-Meteo API. The project is served through GitHub Pages using HTML files.

I previously detailed how I use N8N with Browserless and Playwright. This N8N workflow captures a screenshot of the Golden Gate Bridge webcam every 5 minutes and posts it to the project’s GitHub repo.

Since athletes in SF often leave home, cross the bridge, and continue with a loop through the Headlands or other parts of Marin, the site includes a key feature: the ability to set time offsets. These offsets account for both the time it takes to reach the bridge from home and the time spent on the other side before returning. The personalized offsets are saved in your browser’s local storage, making it easy to align your typical workout routine with real-time weather forecasts. This allows you to quickly check conditions before heading out, ensuring you’re dressed appropriately for both legs of your trip. Additionally, the suggested crossing times highlight the best windows today, providing potential inspiration for your next outing.

Whether you walk, run, or cycle, I hope this tool helps you plan your visit to the Golden Gate Bridge better. As the saying goes, "There’s no bad weather, just bad gear!"

I developed two slightly different versions of the site:

1. The Best Time for Athletes to Cross the Golden Gate Bridge Today is designed for cyclists and runners who want to:
   1. View a real-time image of the bridge
   2. Check the expected weather for their planned crossings
   3. Access a daily forecast
   4. Get recommendations for the best times to cross today
2. Golden Gate Bridge Weather Forecast for Cyclists and Runners is tailored for athletes who know how long it takes to reach the bridge and simply want to:
   1. View a real-time image of the bridge
   2. Check the expected weather for their planned crossings

GitHub - danielraffel/ggb

Contribute to danielraffel/ggb development by creating an account on GitHub.

GitHubdanielraffel

Note: Just after publishing this I made a sister site to identify the best time to swim on the rooftop pool at UCSF Bakar Gym.

GitHub - danielraffel/bakarfitness

Contribute to danielraffel/bakarfitness development by creating an account on GitHub.

GitHubdanielraffel

Compared to the latest motors from Bosch, Pinion, and DJI, I consider the Specialized motor outdated. Marketing a bike as cutting-edge while using stale tech makes me question their commitment to leading the market. I respect Specialized’s effort to develop custom software for their rebranded Brose motors, but I’m not convinced this approach is working, as these motors are not the best in their class and seem to be falling behind in terms of specs.

After watching a video comparing some of the latest eMTB motors, I came away convinced that Pinion has the most future potential, and that Bosch and DJI are setting the bar right now.

If Specialized wants to retain riders like me who want the latest and greatest tech, I think they need to rapidly step up their offerings or embrace partnerships with different industry leaders. Without this, I suspect many of us will be drawn to other bike brands featuring more enticing technology.

Additionally, I’ve heard that Specialized has been putting all sorts of pressure on independent bike shops, making it harder for these local businesses to stay afloat, despite relying on them for sales. The company itself seems to be in some disarray, with three CEOs in two years, and even a lack of clarity on LinkedIn about who's actually in charge right now. I really hope they get things together, because Specialized has an amazing history of making great products—but as the bike world electrifies, they seem to be falling behind.

At the time of writing, these are the company’s three publicly listed CEOs. While LinkedIn profiles may not be the most critical detail to focus on, they do reflect a certain level of attention to detail.

Update November 19, 2024: After reaching out to pr@specialized.com to inquire about the CEO at Specialized and whether they actually had three, it seems they finally did a little LinkedIn profile cleanup. My outsider take is that this is a messy situation. The fact that they've got two folks sharing CEO titles, combined with the founder being the only one with a LinkedIn Pro account, implies to me that things might not be going smoothly over there. How is it possible that they don’t have CEO leadership based out of their HQ in Morgan Hill?! Keep an eye on Specialized—I suspect some housecleaning might be on the horizon.

Back in 2014, I enabled 2-step verification on a secondary Google account, configuring it with both Google Authenticator and a 2-Step Verification phone number to receive verification codes. Unfortunately, sometime in the past decade, I reset the Android device with the Authenticator app that generated verification codes for this account. While I likely received backup codes when I first set up 2FA, it seems I didn’t save them.

Recently, when logging in with my username and password, I received a 2-step code via SMS to my registered phone number. However, when trying to launch a Virtual Machine on Google Cloud, I was prompted for a verification code from Google Authenticator. Without Authenticator, I had no way to generate a code, and I couldn’t remove Authenticator as a verification option. Every attempt to “try another way” only directed me back to Google Authenticator for verification.

At this point, the account is effectively dead to me, as privileged actions require an Authenticator code and I have no way to generate them. While I recognize that my own inaction contributed to this situation—and I’m fortunate it’s not a primary account I rely upon—it’s still frustrating.

I’m certain I received backup codes when I initially set up 2-Step Verification, and it was my own mistake not to save them. Still, I can’t shake the feeling that I’m completely locked out with no way to recover access, and it’s a bit surprising that having a 2FA phone number isn’t even a fallback option. I suppose the reality is that phone numbers are now considered an insecure verification method. Since I learned that SMS codes can’t replace all use cases for Authenticator codes, make sure you save those backup codes!

• Dough prep time: 15 minutes
• Dough rising Time: 1 hour 15 minutes
• Baking time: 20 minutes
• Total time with baking: approximately 2 hours

Ingredients

5 g yeast
255 g water (hot)
315 g all-purpose flour
5 g salt
5 g sugar
20 g olive oil

Directions

1. Dissolve the yeast in hot water in a Pyrex cup, stirring until completely absorbed. In the bowl of a stand mixer, mix the flour, salt, and sugar thoroughly. Next, add the activated yeast, followed by the oil.
2. In a stand mixer:

• Mix on low for 2 minutes, then stop and scrape down the bowl.
• Mix on medium-low for another 2 minutes, scrape down again.
• Mix on medium for 2 more minutes

3. First Rise: Move dough to a large, oiled bowl, and cover it. 

• Proof the dough in an oven set to 100°F for 45 minutes
• Add a generous amount of Extra Virgin Olive Oil (EVOO) on top.

4. Second Rise: Butter the bottom and sides of your 10 × 14 pan, then coat the bottom in a lite amount of EVOO. 

• Spread the dough gently and cover to at least 70% of the pan. Generously oil the top of the dough again. Cover the pan with a towel. 
• Place the covered dough in a warm oven set to 100ºF for 35 minutes.

5. Par-bake: After the second rise, remove the dough being gentle when you set it down to avoid encouraging it to collapse. 

• Preheat your oven to 550ºF with a rack in the middle. 
• Generously coat the top of the dough again with EVOO. 
• Par-bake the dough for 5 minutes once the oven reaches temperature, rotating the pan halfway through. The dough should appear "dry" but not yet golden brown. This step ensures the crust rises well before adding toppings.

6. Top dough with:

• Cheese (0.8 pounds low moisture Mozzarella cut in cubes)
• Sauce

7. Final Bake: Return the pizza to the oven on the middle rack. 

• Bake for 10-15 minutes, until the top turns golden and the cheese and oil are visibly sizzling and bubbling.

8. Let the pizza rest for 5 minutes, or enjoy it later at room temperature.

• To detach the dough from the pan use an offset spatula to gently chip away the crust from the edges going around the entire pie.
• Using a grill turner, slide the pizza lengthwise onto a cutting board. Then slice it with a chef's knife or a pizza wheel.

Adapted from mrgan to better suit the yeast activation process in my kitchen.

I'm a big fan of SyncThing. I use it to seamlessly transfer files across devices. SyncThing's primary selling point for me is its ability to reliably, securely and quickly synchronize keeping cross-platform devices up-to-date without relying on a third-party intermediary. It also offers encryption and the ability to easily ignore specific file patterns. For automating file sync between devices without involving a third party, I have found it to be the most robust solution I've ever used.

While most of my needs only require a one-way sync, there are times when I need two-way sync. Usually that's when I want to download something, move it to another location on a different device and then have that action remove the file from the original, source device. In these cases, I rely on a device that's always on to monitor for new files and then perform actions that ultimately sync back to my iPhone or iPad afterward. For example, when I want to download a filetype on one machine, automate uploading it on another machine and then have that action remove it everywhere. I frequently use Hazel on a Mac mini to monitor folders and automate tasks like moving, uploading and deleting, while SyncThing ensures that the folders stay synchronized across devices.

Years ago, I tried using iCloud to sync devices across my Apple devices, with Hazel managing rules on my Mac mini. Unfortunately, iCloud didn't support always keeping local folders up-to-date, so it just didn't work. I couldn't rely on my Mac mini to actually download the file I put in a shared iCloud folder like Downloads. Frankly, I found it ridiculous. Years ago I worked around this by using a selective sync extension for macOS but even that eventually stopped working.

Thankfully, this has finally been remedied with Sequoia macOS 15 and iOS 18. Now, you can automatically keep your files and folders in iCloud up-to-date on iOS and macOS.

This made me realize I can finally stop using SyncThing for scenarios where I want to share files across my iPhone and iPad. I can now download items to my iCloud Downloads folder on my iPhone, iPad, and Mac, and let Hazel monitor the folder and perform actions which orchestrate keeping everything in sync.

The timing couldn’t be better, as iOS currently has a bug that makes using the third party SyncThing app almost impossible. Safari refuses to reliably save files to a custom local folder, and the SyncThing AppStore app is unable to monitor the iCloud Downloads folder. No matter how many times I change Safari’s download folder settings on iOS, it keeps reverting to a different location—maddening!

Anyways, as a result of switching to using iCloud Drive for some basic two way sync, I no longer need to use the SyncThing app. I've disabled background app refresh for it on my iPhone and iPad, and hope for a little better battery life. All of this is to say that with iCloud Drive, I can finally sync and monitor my folders the way it should have worked from the beginning.

danielraffel’s Music Profile | Last.fm

Listen to music from danielraffel’s library (40,255 tracks played). danielraffel’s top artists: Ludovico Einaudi, Max Richter, Wim Mertens. Get your own music profile at Last.fm, the world’s largest social music platform.

Last.fm

Last.fm hasn’t been maintaining all their integrations, so I had to cobble together several methods to scrobble music from all the surfaces where I listen to music.

• On iOS, I’m using Finale, an open-source app that scrobbles everything played in the Apple Music app.
• For streaming services, I connected my Spotify account to Last.fm.
• On macOS, the only app that worked with the Apple Music desktop app for me was Scrobbles.

At some point, I'll pull my scrobble data into my journal.

Initially, everything went smoothly—I began with smaller projects and saw quick wins using tools like ChatGPT and Claude. But as I took on more complex challenges, I started hitting roadblocks. After hitting snafus and abandoning some projects prematurely, I realized I needed to revisit my approach.

Stepping back I concluded that my main problem, outside of being a better developer, was inefficient workflows. I had grown far too reliant on copying and pasting between different windows, and I wasn’t more regularly using version control or creating branches. This meant that when things went awry, I had no simple way to backtrack or return to a stable state. I ended up abandoning projects when they went off course and felt like they required too much effort to get back on track.

After a conversation with a friend (thanks, Carl!) who shared his workflow, I decided to step back and reassess my own approach. By incorporating a few best practices, such as regularly versioning my code and adopting tools like GitHub Desktop and Cursor Pro, I’ve already noticed significant improvements. While it’s still early days, this new structure is helping me manage more complex projects with greater ease, and I feel much more confident about taking on bigger challenges without burning out. In this post, I’ll walk through the various changes I’ve adopted over the past week.

Streamlining Development with Branches and Frequent Small Commits in GitHub

One of the first changes I implemented was to stop working directly on the main branch of my projects. Instead, I now create a dev branch where I commit more frequently, keeping changes smaller and more manageable. For specific features, I create dedicated branches, merging into the main branch only when I’m confident everything is in good shape. This approach helps me preserve my progress when things get messy. If I don’t want to merge all the changes from a branch, I squash and merge only the relevant commits.

Switching to using the GitHub Desktop client has also been helpful. It provides me with a much clearer overview of the changes I’m about to commit compared to the built-in source control tools in Cursor or my terminal. While the IDE’s tools are fine for quick commits or branch switching, for larger changes, I prefer the enhanced visibility that GitHub Desktop offers.

Development Planning and Spec Creation with ChatGPT

For more complex tasks, I now start by mapping them out in ChatGPT before diving into coding. This approach ensures that I start coding with a clear sequence of steps and starting direction even if the plan changes. It also helps me offer more focused guidance to the coding assistant I'm using.

After outlining a plan, I either start working directly on the dev branch for smaller changes or, for larger tasks, I create one or more GitHub issues where I add my spec and set up a dedicated branch. This approach lets me switch tasks or step away without losing track of important details. Keeping tasks organized and tied to specific branches makes it much easier to pick up where I left off after a break.

I have found creating specs using o1-preview is particularly effective when engaging in refactoring complex sections of code. When I aim to enhance or expand an MVP with new features and capabilities, having a detailed, step-by-step plan not only streamlines the refactor but also uncovers insights I hadn’t anticipated. Following those steps and committing incremental changes leads to noticeably improved outcomes.

Transitioning from Web Chat Tools to Cursor for Coding

The hardest adjustment for me was shifting to doing all of my coding in an IDE, rather than relying on regularly copy-pasting between the IDE and web-based chat tools. Fortunately, a course on using Cursor by Mckay Wrigley made the transition quick and easy.

To ease into this new approach, I started using web-based chat assistants for strategic planning—figuring out how to approach a problem—and relying on Cursor’s coding assistant for tactical execution. This separation of tasks allows me to use each tool in a more focused manner. While it’s not strictly necessary to work this way, it has been a helpful way for me to transition to spending more of my time in Cursor.

The end result is a more efficient workflow where I can develop a clear, opinionated approach outside the IDE and use that output to guide how I work in Cursor. In turn, Cursor enables me to write higher quality code in an environment that tracks both code changes and chat history that contributed to development.

Why Cursor is a Game Changer for Me

Implementing best practices like using Git, tracking issues, and creating specs has been valuable, but adopting Cursor has been the real game changer for me. Although I enjoyed using Copilot in VS Code, I still found myself regularly leaving the IDE for additional coding assistance. Cursor, on the other hand, provides a range of features that enable me to complete my work without ever needing to leave the editor.

Cursor’s built-in chat assistant supports multiple models, allowing me to switch between the best-suited ones for different tasks. I can also integrate third-party API keys for added flexibility. By indexing my entire codebase, Cursor makes it much easier to integrate new features or libraries and apply suggested changes efficiently. Additionally, with the ability to @mention files, folders, web resources, or even my entire codebase, I can quickly reference the latest documentation for APIs, SDKs, or languages. Cursor is bundled with shortcuts to success.

Key Features

Cursor offers several features that significantly enhance the coding experience.

Codebase Indexing

Codebase indexing generates embeddings for each file in my codebase, improving the accuracy of code suggestions. The index stays in sync with my latest changes, ensuring responses are always up-to-date and relevant.

Long-Context Chat

Codebase indexing shines when combined with long-context chat. Models with support for larger context windows allow me to include entire folders in conversations, enabling Cursor to offer comprehensive feedback based on broader sections of my codebase.

@Mentions and Chat History

What convinced me to switch to Cursor was the ability to reference specific files, folders, and code directly in chats. By @mentioning them within the IDE, I stay in the flow without unnecessary interruptions. No more copying and pasting between windows. Plus, the chat history is stored in the IDE, providing a central place to track past discussions and changes.

Adding Docs

One major advantage of using AI coding assistants is no longer needing to search through third-party docs when integrating new tools. Cursor has many third-party libraries indexed, accessible via mentioning them in chat with @Docs. For documentation that hasn’t been indexed yet, I can easily add it by pasting a URL to the support materials, and Cursor will index it for use in prompts.

Apply Feature

The apply feature is another favorite of mine, allowing me to quickly integrate code suggestions from the chat. After applying, I can review the diffs and choose to accept or reject the changes.

Occasionally, I notice that this feature suggests applying the correct changes to the wrong file. Thankfully, it’s easy to spot when this happens, and I can either manually fix it by copying and pasting the code into the right file or ask the assistant to correct it.

Numerous features in Cursor require hands-on use to get a proper feel for them. Sometimes this is due to their non-deterministic behavior, while other times it's because they are a bit buggy or just slow. For example, I initially thought the apply feature wasn’t working because it takes a few moments to generate changes in local files, but I was simply being impatient with it. I’ve learned to give certain features in Cursor more than one try to work correctly.

Cursor Tab

Cursor Tab is a powerful autocomplete tool that goes beyond simple suggestions. It predicts entire edits based on your recent changes and codebase knowledge, suggesting edits across multiple lines and even fixing your mistakes.

AI Rules

A handy feature is the ability to add custom AI rules, tailoring the assistant’s responses to fit my specific workflow. This ensures it focuses on the most helpful actions and avoids less useful suggestions. Apparently, there's a third party directory of suggestions but I currently use this one.

Markdown Files

Since large language models (LLMs) are trained on extensive markdown (.MD) content and have well-structured knowledge, MD files work great with assistants in Cursor to provide actionable, step-by-step instructions. Coding chat assistants can generate relevant context that can be easily acted upon. For example, whenever you save changes to a note in Cursor, you can reference them in Chat. Here's how:

• Create a markdown file in cursor reference it in the chat.
• By mentioning the markdown file in the chat assistant it can use that as context and even act upon it.

For instance, Imran realized you could make a markdown file that requests a visual component, uses the assistant to generate a suitable prompt, sends that prompt to v0.dev, and returns a link to view the visual component. If that's unclear what an example of it in action here.

This method also works for managing projects in Composer and directing chats to update project status once things are implemented. You can watch how markdown works in Composer.

Composer

Composer is a feature that lets you use natural language prompts to create new projects from scratch, enhance existing ones, or generate code snippets. With Composer Projects, it takes the functionality even further, offering a huge time-saving advantage when starting a project. You can see Composer in action here.

Final Thoughts

Although I still have plenty of room to grow as a developer, the changes I’ve adopted this past week have already improved my productivity. Compared to my previous workflow, taking on ambitious projects now feels both simpler and more enjoyable, and I believe it will enable me to see more projects through to completion.

macOS 15 Sequoia

Tiling tips

You can arrange windows for a pixel-perfect fit in macOS 15. Here’s a quick rundown of how to tile windows:

1. Hold down the Option (⌥) key while dragging to start tiling. Drag the window to the screen edges:
   • Top Center edge: maximizes the window.
   • Top Left or Right edges: split the screen in half.
   • Bottom Corners: fills the respective bottom quarters of the screen.
2. Hover over the green button in the top-left corner for a point-and-click tiling menu.

3. By default, tiled windows have a small gutter around them, which you can disable in System Settings > Desktop & Dock:
   • Scroll to the “Windows” section and uncheck Tiled windows have margins. That gutter was driving me crazy! Had to turn it off immediately.

Messenges Tapback Shortcut

Right-click a text message bubble (or press ⌘T) and you can Tapback with any emoji, not just the default six.

Voice Memo Audio Transcriptions

In the Voice Memos app, you can now transcribe recorded conversations by tapping the transcription icon—it turns blue when enabled.

New Passwords App

I decided to export my passwords from 1Password using a CSV file and imported them into the new Passwords app. I was hoping to have a more up-to-date backup in case I get locked out of 1Password. However, the CSV import wasn't comprehensive, as only the 1Password Unencrypted Export (.1pux) format supports custom fields like security questions, linked items, linked apps, and two-factor authentication backup codes. It seems like .1pux is proprietary to 1Password, and I couldn’t find an easy way to automate importing the data from that file. So much for trying to create a full backup.

Reminders in Calendar

It feels a bit slower than using the Reminders app, but apparently, I can now create reminders directly in the Calendar app.

iPhone Mirroring

I found this feature really useful—sometimes when I’m working on my Mac, I want to stream music from my iPhone to my AirPlay speakers. Now, I can do it right from my Mac without needing to pick up my phone.

Xcode 16

I can't open Xcode 15 and expected to see Xcode 16 in the macOS AppStore. Odder yet, I can't download the update on the Apple Dev Site. Now, available as a macOS AppStore update.

iOS 18

Safari

Safari Tools is now accessible as an icon in the top left menu bar, and tapping it reveals options, including the ability to listen to a webpage.

There are other Safari features, like Distraction Control, that are less useful to me since I use AdGuard Home, but you never know when you gotta block an annoying element on a webpage.

Disable Tinted Icons

I'm not a fan of the new tinted icons in iOS 18. To disable them, long-press anywhere on the Home Screen, tap "Edit" in the top left corner, then select "Customize" and choose "Light."

AppStore

To view all reviews for a specific App and sort them by recent or other options, you now need to tap on the "Ratings & Reviews" section header. This is definitely less obvious than it used to be, which benefits apps with a lot of recent negative reviews.

View electricity usage and rates in Home.app

You can now monitor your home’s electricity usage in the Home app and easily track your consumption over time. Learn how to connect your utility.

We made eye contact, I extended my hand out to the side, shared a brief smile, and as our paths crossed, we connected with a high-five. Little did I know that this would become a move on future rides. 🤣✋🚴‍♂️

A few weeks back, while climbing up to the peak of Tahoe Donner, someone cheered me on, and as I approached, I couldn’t resist saying, "Can I get a high five?" They ran over, and we connected. I’ve noticed that after every high-five, I gain a little burst of energy, and my cadence picks up.

I’ve started jokingly measuring my rides by the number of high-fives I collect. On a good day, I can easily rack up 3 (e.g., a 15-ride!). Of course, not every ride is high-five-worthy, but when those opportunistic moments materialize, it’s rare to be left hanging.

Occasionally, the people I ask for a high-five are those standing next to their cars, either admiring the scenery or getting ready to take photos. Part of me feels like extending a connection to drivers on the road is my way of saying, "Hey, bicyclists are your friends," while subversively implying, "Thanks for watching out for your pals next time you drive past one."

I don’t know if what I’m feeling is what some describe as universal energy, but in the moment, it sure feels like there’s a shared understanding that we’re all in this together.

I recently joined UCSF Bakar Gym in San Francisco. While they offer physical ID cards for check-in, most people are directed to use the mobile app to display a static UPC barcode for entry. Knowing this could get cumbersome for me, I decided to set up an Apple Shortcut that automatically displays a screenshot of my gym ID when I arrive within 200 meters of the gym.

I'm not sure how many others might find this useful, but here's a guide on setting up an automation to easily access a location-triggered screenshot of your photo ID.

Step 1: Download the Shortcut

You can download my shortcut here. The Apple shortcut performs two simple actions.

• Accesses the photo file: It retrieves the saved image of your gym ID (in this case, UCSF_GYM_ID.jpg) from your iPhone’s storage. Note: Be sure to update the path to your image since it won't find mine. 😉
• Displays the ID in Quick Look: It opens a preview of the image so you can quickly show your ID at the gym.

Step 2: Set Up the Automation

While the Apple Shortcut app doesn't allow sharing automations, I can walk you through how to configure it.

1. Location Trigger:

• Open the Shortcuts app and navigate to the Automation tab.
• Set the trigger to activate when you arrive at the gym's location (in my case, 1675 Owens St, SF, CA).
• Choose a proximity radius (I set mine to 200 meters which is the smallest radius iOS allows) to ensure it triggers only when near the gym.

2. Action:

• Choose the "UCSF Gym ID" shortcut as the action to run when you arrive at the location.

3. Run Confirmation:

• Make sure to keep the "Run After Confirmation" setting enabled. This way, you’ll receive a notification asking if you want to run the shortcut when you arrive.

Once set up, every time you arrive near the gym, you’ll get a notification on your phone. When you confirm the action, the screenshot of your gym ID will appear in Quick Look, ready to be scanned for entry. For me, I no longer have to manually open the gym's app (and wait for it to load) or search for the screenshot in my photo library, and the image can be easily dismissed after showing it to the staff.

After setting it up, I realized that I had an environment capable of executing Browserless API calls and running Playwright scripts. This opened the door to advanced web automation tasks like generating PDFs, capturing screenshots, and more—all integrated seamlessly with n8n.

Why Integrate ChangeDetection.io, Browserless, Playwright and n8n?

• ChangeDetection.io provides a simple frontend for monitoring website changes.
• Browserless offers a hosted browser solution, enabling headless Chrome automation.
• Playwright is a powerful library for automating browser interactions.
• n8n is a workflow automation tool that connects various services and APIs.

By integrating these tools, it's trivial to have a self-hosted system for web monitoring and automation.

Setting Up ChangeDetection.io with Browserless and Playwright

I stumbled upon a Reddit post that linked to this Gist containing a useful docker-compose.yml file. This configuration integrates Browserless with Playwright, making it easy to get started.

Securing Your Setup with a Custom Token

Security is important when exposing services like Browserless and Playwright. I modified the Docker Compose file to include a custom token for authentication. Here's how you can do it:

1. Generate a Token: Create a secure token that you'll use for authentication.
2. Update docker-compose.yml: Replace YOUR_PLAYWRIGHT_TOKEN with your generated token in the environment variables.

Docker Compose Configuration

Below is the modified docker-compose.yml file with a with a Custom Token:

changedetection:
    image: ghcr.io/dgtlmoon/changedetection.io:latest
    container_name: changedetection
    hostname: changedetection
    volumes:
      - /home/path/files:/datastore  # Update path to your data volume
    environment:
      - PORT=20400  # Port for changedetection
      - PUID=1000  # Preferred user ID (avoid root/0 unless necessary in a managed environment)
      - PGID=1000  # Preferred group ID (avoid root/0 unless necessary in a managed environment)
      - PLAYWRIGHT_DRIVER_URL=ws://playwright-chrome:3000/chrome?token=YOUR_PLAYWRIGHT_TOKEN&launch={"headless":false}  # WebSocket connection for Playwright
    ports:
      - 20400:20400  # Port mapping for changedetection
    restart: unless-stopped
    depends_on:
      - playwright-chrome

  playwright-chrome:
    hostname: playwright-chrome
    image: ghcr.io/browserless/chrome
    restart: unless-stopped
    environment:
      - TOKEN=YOUR_PLAYWRIGHT_TOKEN # Update using a secure token
      - SCREEN_WIDTH=1920
      - SCREEN_HEIGHT=1024
      - SCREEN_DEPTH=16
      - ENABLE_DEBUGGER=true
      - TIMEOUT=600000
      - CONCURRENT=15
    ports:
      - 20450:3000  # Port mapping for Playwright WebSocket connection

Exploring Browserless API Capabilities

With Browserless and Playwright set up, I explored the Browserless API documentation to see what was possible. Here are some of the key endpoints and their capabilities:

• Load and Render HTML: Use /content to load a URL or HTML content and retrieve the fully rendered HTML after JavaScript execution.
• Download Files: Use /download to execute browser interactions and download files.
• Execute Code in Browser: Use /function to run custom Playwright code in a browser context, perfect for web scraping tasks.
• Generate PDFs: Use /pdf to create PDF documents from URLs or HTML content with customizable options.
• Capture Screenshots: Use /screenshot to take screenshots of webpages, supporting full-page captures and customizations.
• Scrape Data: Use /scrape to extract specific data using CSS or XPath selectors.

Integrating with n8n for Workflow Automation

In a previous post, I detailed how to self-host n8n on Google Cloud. Building on that, I connected n8n with a self-hosted Browserless and Playwright setup to automate web tasks.

Setting Up Credentials in n8n

To authenticate with your Browserless instance in n8n:

1. Create New Credentials:
   • Go to Credentials in n8n.
   • Choose Header Auth.
   • Set the name to Authorization and the value to YOUR_PLAYWRIGHT_TOKEN.
2. Use Credentials in Workflows:
   • In your HTTP Request nodes, select the Browserless credentials you just created.

Example n8n Workflows

I've created several workflows utilizing different Browserless API endpoints:

• Screenshotting: Capture a screenshot of a URL.
• PDF Generation: Convert a web page into a PDF.
• Content Retrieval: Extract the HTML content from a specific URL.
• Downloading Files: Download files (e.g., ZIPs) from provided links.
• Scraping: Extract elements using CSS or XPath selectors.

You can copy and paste the following workflow template to import all the examples into your n8n instance (also shared on the n8n forum).

{
	"name": "Browserless Examples [Shared]",
	"nodes": [
		{
			"parameters": {
				"content": "## /Screenshot URL\nhttps://docs.browserless.io/HTTP-APIs/screenshot\n\nHardcoded URL Example.com\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\nPassing URL Example.com as a variable",
				"height": 552.0382521592817,
				"width": 414.07950814059393
			},
			"id": "3b89c6bb-b9cd-4bcd-8958-4dfbf87e39aa",
			"name": "Sticky Note1",
			"type": "n8n-nodes-base.stickyNote",
			"typeVersion": 1,
			"position": [
				-53.09026656387687,
				-60
			]
		},
		{
			"parameters": {
				"content": "## /content return HTML\nhttps://docs.browserless.io/HTTP-APIs/content\n\nHardcoded URL Example.com\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\nPassing URL Example.com as a variable",
				"height": 549.8248303020775,
				"width": 415.7157914610786
			},
			"id": "e069f9c9-a524-4da0-b0e7-9ddb8f7f2317",
			"name": "Sticky Note",
			"type": "n8n-nodes-base.stickyNote",
			"typeVersion": 1,
			"position": [
				400,
				-60
			]
		},
		{
			"parameters": {
				"content": "## /download example\n\nHardcoded URL https://getsamplefiles.com/sample-archive-files/zip and downloads the first ZIP file\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\nPassing URL, file type and first/last/all as a variable",
				"height": 543.2718166583338,
				"width": 436.9874746273785
			},
			"id": "5b5bef89-7cb2-4932-86cf-1cb695e1e46c",
			"name": "Sticky Note2",
			"type": "n8n-nodes-base.stickyNote",
			"typeVersion": 1,
			"position": [
				860,
				-60
			]
		},
		{
			"parameters": {
				"content": "## /function examples",
				"height": 543.1338634894774,
				"width": 404.2618082176863
			},
			"id": "f2a40685-047a-4a71-b314-7409ac83cfa3",
			"name": "Sticky Note3",
			"type": "n8n-nodes-base.stickyNote",
			"typeVersion": 1,
			"position": [
				-56.54071590859172,
				580
			]
		},
		{
			"parameters": {
				"content": "## /scrape example\nhttps://docs.browserless.io/HTTP-APIs/scrape\n\nHardcoded URL Example.com\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\nPassing URL Example.com as a variable",
				"height": 549.7523374008159,
				"width": 454.9865911527092
			},
			"id": "1bbb57a1-87cc-48bb-8aa4-e7705d6d434f",
			"name": "Sticky Note5",
			"type": "n8n-nodes-base.stickyNote",
			"typeVersion": 1,
			"position": [
				860,
				580
			]
		},
		{
			"parameters": {
				"method": "POST",
				"url": "http://yourdomain:port/chrome/function",
				"authentication": "genericCredentialType",
				"genericAuthType": "httpHeaderAuth",
				"sendHeaders": true,
				"headerParameters": {
					"parameters": [
						{
							"name": "Content-Type",
							"value": "application/json"
						}
					]
				},
				"sendBody": true,
				"contentType": "raw",
				"rawContentType": "application/json",
				"body": "{\n  \"code\": \"export default async function ({ page }) {\\n    try {\\n      await page.goto('https://www.example.com', { \\n        waitUntil: 'networkidle2',\\n        timeout: 60000 // 60 seconds timeout\\n      });\\n      const screenshot = await page.screenshot({ fullPage: true });\\n      return {\\n        data: screenshot.toString('base64'),\\n        type: 'image/png'\\n      };\\n    } catch (error) {\\n      console.error('Error:', error);\\n      return {\\n        data: `Error: ${error.message}`,\\n        type: 'text/plain'\\n      };\\n    }\\n  }\\n\"\n}",
				"options": {
				}
			},
			"id": "8a91be2b-03f6-4060-93c7-bcd4e3c0e06f",
			"name": "HTTP Request5",
			"type": "n8n-nodes-base.httpRequest",
			"typeVersion": 4.2,
			"position": [
				120,
				860
			],
			"credentials": {
				"httpHeaderAuth": {
					"id": "NXo0Bj93cIusdtnD",
					"name": "Browserless: Header Auth Account"
				}
			}
		},
		{
			"parameters": {
				"jsCode": "// Set the URL in a variable\nconst url = 'https://www.example.com';\n\n// Loop over input items and add the URL to the JSON of each one\nfor (const item of $input.all()) {\n  item.json.url = url;\n}\n\n// Return the updated items\nreturn $input.all();"
			},
			"id": "1233d7c8-6218-4e3c-92ad-b3ed33fde0ba",
			"name": "Code",
			"type": "n8n-nodes-base.code",
			"typeVersion": 2,
			"position": [
				0,
				320
			]
		},
		{
			"parameters": {
				"jsCode": "// Set the URL in a variable\nconst url = 'https://www.example.com';\n\n// Loop over input items and add the URL to the JSON of each one\nfor (const item of $input.all()) {\n  item.json.url = url;\n}\n\n// Return the updated items\nreturn $input.all();"
			},
			"id": "be478e2d-0964-416d-9641-9deda9d92dfb",
			"name": "Code1",
			"type": "n8n-nodes-base.code",
			"typeVersion": 2,
			"position": [
				440,
				320
			]
		},
		{
			"parameters": {
				"jsCode": "// Set the URL in a variable\nconst url = 'https://www.example.com/';\n\n// Loop over input items and add the URL to the JSON of each one\nfor (const item of $input.all()) {\n  item.json.url = url;\n}\n\n// Return the updated items\nreturn $input.all();"
			},
			"id": "cc78803b-e207-4fd1-b650-1ff8f92054f1",
			"name": "Set URL",
			"type": "n8n-nodes-base.code",
			"typeVersion": 2,
			"position": [
				920,
				960
			]
		},
		{
			"parameters": {
				"jsCode": "// Set the URL in a variable\nconst url = 'https://www.example.com';\n\n// Loop over input items and add the URL to the JSON of each one\nfor (const item of $input.all()) {\n  item.json.url = url;\n}\n\n// Return the updated items\nreturn $input.all();"
			},
			"id": "31a1b79b-b10f-48c4-8f43-c30658976ae8",
			"name": "Set URL1",
			"type": "n8n-nodes-base.code",
			"typeVersion": 2,
			"position": [
				420,
				960
			]
		},
		{
			"parameters": {
				"content": "## /pdf example\nhttps://docs.browserless.io/HTTP-APIs/pdf\n\nHardcoded URL Example.com\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\nPassing URL Example.com as a variable",
				"height": 549.7523374008159,
				"width": 454.9865911527092
			},
			"id": "5bd19d9b-258b-4a9d-9664-f648d9cbb8af",
			"name": "Sticky Note6",
			"type": "n8n-nodes-base.stickyNote",
			"typeVersion": 1,
			"position": [
				380,
				580
			]
		},
		{
			"parameters": {
				"method": "POST",
				"url": "http://yourdomain:port/chrome/screenshot",
				"authentication": "genericCredentialType",
				"genericAuthType": "httpHeaderAuth",
				"sendHeaders": true,
				"headerParameters": {
					"parameters": [
						{
							"name": "Content-Type",
							"value": "application/json"
						}
					]
				},
				"sendBody": true,
				"contentType": "raw",
				"rawContentType": "application/json",
				"body": "{   \"url\": \"https://www.example.com\",   \"options\": {     \"fullPage\": true   } }",
				"options": {
				}
			},
			"id": "48668f58-fed4-4a74-8b50-57d8dec68eef",
			"name": "HTTP Request: Screenshot",
			"type": "n8n-nodes-base.httpRequest",
			"typeVersion": 4.2,
			"position": [
				0,
				80
			],
			"credentials": {
				"httpHeaderAuth": {
					"id": "NXo0Bj93cIusdtnD",
					"name": "Browserless: Header Auth Account"
				}
			}
		},
		{
			"parameters": {
				"method": "POST",
				"url": "http://yourdomain:port/chrome/content",
				"authentication": "genericCredentialType",
				"genericAuthType": "httpHeaderAuth",
				"sendHeaders": true,
				"headerParameters": {
					"parameters": [
						{
							"name": "Content-Type",
							"value": "application/json"
						}
					]
				},
				"sendBody": true,
				"contentType": "raw",
				"rawContentType": "application/json",
				"body": "{\n  \"url\": \"https://www.example.com\"\n}",
				"options": {
				}
			},
			"id": "c473afb5-3b38-4d8a-9bee-4fbb95584a26",
			"name": "HTTP Request: Content",
			"type": "n8n-nodes-base.httpRequest",
			"typeVersion": 4.2,
			"position": [
				440,
				80
			],
			"credentials": {
				"httpHeaderAuth": {
					"id": "NXo0Bj93cIusdtnD",
					"name": "Browserless: Header Auth Account"
				}
			}
		},
		{
			"parameters": {
				"method": "POST",
				"url": "http://yourdomain:port/chrome/download",
				"authentication": "genericCredentialType",
				"genericAuthType": "httpHeaderAuth",
				"sendHeaders": true,
				"headerParameters": {
					"parameters": [
						{
							"name": "Content-Type",
							"value": "application/json"
						}
					]
				},
				"sendBody": true,
				"contentType": "raw",
				"rawContentType": "application/json",
				"body": "{\n  \"code\": \"export default async function ({ page }) {\\n  try {\\n    await page.goto('https://getsamplefiles.com/sample-archive-files/zip', { waitUntil: 'networkidle2', timeout: 120000 });\\n    console.log('Page loaded successfully');\\n    const zipLink = await page.$eval('a[href$=\\\\\\\".zip\\\\\\\"]', link => link.href);\\n    console.log(`Processing first ZIP link: ${zipLink}`);\\n    const response = await page.goto(zipLink, { waitUntil: 'networkidle2', timeout: 120000 });\\n    if (response.ok()) {\\n      const buffer = await response.buffer();\\n      return [{\\n        filename: zipLink.split('/').pop(),\\n        data: buffer.toString('base64'),\\n        type: 'application/zip'\\n      }];\\n    } else {\\n      console.error(`Failed to download: ${response.status()} ${response.statusText()}`);\\n      return {\\\"error\\\": `Failed to download: ${response.status()} ${response.statusText()}` };\\n    }\\n  } catch (error) {\\n    console.error('No matching ZIP file found or an error occurred:', error);\\n    return {\\\"error\\\": 'No matching ZIP file found or an error occurred' };\\n  }\\n}\\n\",\n  \"context\": {}\n}",
				"options": {
				}
			},
			"id": "15cf6c0b-458c-4a7a-8fc3-6f7cb666b307",
			"name": "HTTP Request: Download",
			"type": "n8n-nodes-base.httpRequest",
			"typeVersion": 4.2,
			"position": [
				920,
				80
			],
			"credentials": {
				"httpHeaderAuth": {
					"id": "NXo0Bj93cIusdtnD",
					"name": "Browserless: Header Auth Account"
				}
			}
		},
		{
			"parameters": {
				"method": "POST",
				"url": "http://yourdomain:port/chrome/function",
				"authentication": "genericCredentialType",
				"genericAuthType": "httpHeaderAuth",
				"sendHeaders": true,
				"headerParameters": {
					"parameters": [
						{
							"name": "Content-Type",
							"value": "application/json"
						}
					]
				},
				"sendBody": true,
				"contentType": "raw",
				"rawContentType": "application/json",
				"body": "{\n  \"code\": \"export default async function ({ page }) {\\n  try {\\n    const response = await page.goto('https://www.dundeecity.gov.uk/sites/default/files/publications/civic_renewal_forms.zip', { \\n      waitUntil: 'networkidle2',\\n      timeout: 60000 // 60 seconds timeout\\n    });\\n\\n    if (response.ok()) {\\n      const buffer = await response.buffer();\\n      return {\\n        data: buffer.toString('base64'),\\n        type: 'application/zip'\\n      };\\n    } else {\\n      throw new Error(`Failed to download: ${response.status()} ${response.statusText()}`);\\n    }\\n  } catch (error) {\\n    console.error('Error:', error);\\n    return {\\n      data: `Error: ${error.message}`,\\n      type: 'text/plain'\\n    };\\n  }\\n}\\n\"\n}",
				"options": {
				}
			},
			"id": "92c67358-e23b-4954-bd21-01430b255183",
			"name": "HTTP Request: Function",
			"type": "n8n-nodes-base.httpRequest",
			"typeVersion": 4.2,
			"position": [
				120,
				680
			],
			"credentials": {
				"httpHeaderAuth": {
					"id": "NXo0Bj93cIusdtnD",
					"name": "Browserless: Header Auth Account"
				}
			}
		},
		{
			"parameters": {
				"method": "POST",
				"url": "http://yourdomain:port/chrome/pdf",
				"authentication": "genericCredentialType",
				"genericAuthType": "httpHeaderAuth",
				"sendHeaders": true,
				"headerParameters": {
					"parameters": [
						{
							"name": "Content-Type",
							"value": "application/json"
						}
					]
				},
				"sendBody": true,
				"contentType": "raw",
				"rawContentType": "application/json",
				"body": "{\n  \"url\": \"https://www.example.com\",\n  \"options\": {\n    \"displayHeaderFooter\": true,\n    \"printBackground\": false,\n    \"format\": \"A4\"\n  }\n}",
				"options": {
				}
			},
			"id": "2996a1d2-70c1-469f-8610-c122f0cfc95c",
			"name": "HTTP Request: PDF",
			"type": "n8n-nodes-base.httpRequest",
			"typeVersion": 4.2,
			"position": [
				420,
				720
			],
			"credentials": {
				"httpHeaderAuth": {
					"id": "NXo0Bj93cIusdtnD",
					"name": "Browserless: Header Auth Account"
				}
			}
		},
		{
			"parameters": {
				"method": "POST",
				"url": "http://yourdomain:port/chrome/scrape",
				"authentication": "genericCredentialType",
				"genericAuthType": "httpHeaderAuth",
				"sendHeaders": true,
				"headerParameters": {
					"parameters": [
						{
							"name": "Content-Type",
							"value": "application/json"
						}
					]
				},
				"sendBody": true,
				"contentType": "raw",
				"rawContentType": "application/json",
				"body": "{\n  \"url\": \"https://www.example.com/\",\n  \"elements\": [\n    { \"selector\": \"h1\" }\n  ],\n  \"gotoOptions\": {\n    \"timeout\": 10000,\n    \"waitUntil\": \"networkidle2\"\n  }\n}",
				"options": {
				}
			},
			"id": "e6b2daae-b3ba-4cc4-b1f5-b58577c3b4f3",
			"name": "HTTP Request: Scrape",
			"type": "n8n-nodes-base.httpRequest",
			"typeVersion": 4.2,
			"position": [
				920,
				720
			],
			"credentials": {
				"httpHeaderAuth": {
					"id": "NXo0Bj93cIusdtnD",
					"name": "Browserless: Header Auth Account"
				}
			}
		},
		{
			"parameters": {
				"method": "POST",
				"url": "http://yourdomain:port/chrome/screenshot",
				"authentication": "genericCredentialType",
				"genericAuthType": "httpHeaderAuth",
				"sendHeaders": true,
				"headerParameters": {
					"parameters": [
						{
							"name": "Content-Type",
							"value": "application/json"
						}
					]
				},
				"sendBody": true,
				"contentType": "raw",
				"rawContentType": "application/json",
				"body": "={\n  \"url\": \"{{$json[\"url\"]}}\",\n  \"options\": { \"fullPage\": true }\n}",
				"options": {
				}
			},
			"id": "9513a03e-e37c-4d4d-80cb-076e212fcdb9",
			"name": "HTTP Request: Screenshot1",
			"type": "n8n-nodes-base.httpRequest",
			"typeVersion": 4.2,
			"position": [
				160,
				320
			],
			"credentials": {
				"httpHeaderAuth": {
					"id": "NXo0Bj93cIusdtnD",
					"name": "Browserless: Header Auth Account"
				}
			}
		},
		{
			"parameters": {
				"method": "POST",
				"url": "http://yourdomain:port/chrome/pdf",
				"authentication": "genericCredentialType",
				"genericAuthType": "httpHeaderAuth",
				"sendHeaders": true,
				"headerParameters": {
					"parameters": [
						{
							"name": "Content-Type",
							"value": "application/json"
						}
					]
				},
				"sendBody": true,
				"contentType": "raw",
				"rawContentType": "application/json",
				"body": "={\n  \"url\": \"{{$json[\"url\"]}}\",\n  \"options\": {\n    \"displayHeaderFooter\": true,\n    \"printBackground\": false,\n    \"format\": \"A4\"\n  }\n}",
				"options": {
				}
			},
			"id": "4bed427f-0c4e-4c5e-8fb5-611f483e86ed",
			"name": "HTTP Request: PDF1",
			"type": "n8n-nodes-base.httpRequest",
			"typeVersion": 4.2,
			"position": [
				580,
				960
			],
			"credentials": {
				"httpHeaderAuth": {
					"id": "NXo0Bj93cIusdtnD",
					"name": "Browserless: Header Auth Account"
				}
			}
		},
		{
			"parameters": {
				"method": "POST",
				"url": "http://yourdomain:port/chrome/content",
				"authentication": "genericCredentialType",
				"genericAuthType": "httpHeaderAuth",
				"sendHeaders": true,
				"headerParameters": {
					"parameters": [
						{
							"name": "Content-Type",
							"value": "application/json"
						}
					]
				},
				"sendBody": true,
				"contentType": "raw",
				"rawContentType": "application/json",
				"body": "={\n  \"url\": \"{{$json[\"url\"]}}\"\n}",
				"options": {
				}
			},
			"id": "73836d1e-638c-4937-a89a-b0c923bbcd52",
			"name": "HTTP Request: Content1",
			"type": "n8n-nodes-base.httpRequest",
			"typeVersion": 4.2,
			"position": [
				600,
				320
			],
			"credentials": {
				"httpHeaderAuth": {
					"id": "NXo0Bj93cIusdtnD",
					"name": "Browserless: Header Auth Account"
				}
			}
		},
		{
			"parameters": {
				"method": "POST",
				"url": "http://yourdomain:port/chrome/scrape",
				"authentication": "genericCredentialType",
				"genericAuthType": "httpHeaderAuth",
				"sendHeaders": true,
				"headerParameters": {
					"parameters": [
						{
							"name": "Content-Type",
							"value": "application/json"
						}
					]
				},
				"sendBody": true,
				"contentType": "raw",
				"rawContentType": "application/json",
				"body": "={\n  \"url\": \"{{$json[\"url\"]}}\",\n  \"elements\": [\n    { \"selector\": \"h1\" }\n  ],\n  \"gotoOptions\": {\n    \"timeout\": 10000,\n    \"waitUntil\": \"networkidle2\"\n  }\n}",
				"options": {
				}
			},
			"id": "bd0e9889-68d5-4ae0-95b1-96fb937b592d",
			"name": "HTTP Request: Scrape1",
			"type": "n8n-nodes-base.httpRequest",
			"typeVersion": 4.2,
			"position": [
				1080,
				960
			],
			"credentials": {
				"httpHeaderAuth": {
					"id": "NXo0Bj93cIusdtnD",
					"name": "Browserless: Header Auth Account"
				}
			}
		},
		{
			"parameters": {
				"method": "POST",
				"url": "http://yourdomain:port/chrome/download",
				"authentication": "genericCredentialType",
				"genericAuthType": "httpHeaderAuth",
				"sendHeaders": true,
				"headerParameters": {
					"parameters": [
						{
							"name": "Content-Type",
							"value": "application/json"
						}
					]
				},
				"sendBody": true,
				"contentType": "raw",
				"rawContentType": "application/json",
				"body": "={\n  \"code\": \"export default async function ({ page }) {\\n  try {\\n    await page.goto('{{ $json[\"url\"] }}', { waitUntil: 'networkidle2', timeout: 120000 });\\n    console.log('Page loaded successfully');\\n    const links = await page.$eval('a[href$=\\\\\\\".{{ $json[\"fileType\"] }}\\\\\\\"]', links => links.map(link => link.href));\\n    let selectedLinks = [];\\n    if ('{{ $json[\"downloadOption\"] }}' === 'all') {\\n      selectedLinks = links;\\n    } else if ('{{ $json[\"downloadOption\"] }}' === 'first') {\\n      selectedLinks = links.length > 0 ? [links[0]] : [];\\n    } else if ('{{ $json[\"downloadOption\"] }}' === 'last') {\\n      selectedLinks = links.length > 0 ? [links[links.length - 1]] : [];\\n    }\\n    const results = [];\\n    for (const zipLink of selectedLinks) {\\n      console.log(`Processing ${zipLink}`);\\n      const response = await page.goto(zipLink, { waitUntil: 'networkidle2', timeout: 120000 });\\n      if (response.ok()) {\\n        const buffer = await response.buffer();\\n        results.push({\\n          filename: zipLink.split('/').pop(),\\n          data: buffer.toString('base64'),\\n          type: 'application/{{ $json[\"fileType\"] }}'\\n        });\\n      } else {\\n        console.error(`Failed to download: ${response.status()} ${response.statusText()}`);\\n        results.push({\\\"error\\\": `Failed to download: ${response.status()} ${response.statusText()}` });\\n      }\\n    }\\n    return results;\\n  } catch (error) {\\n    console.error('No matching {{ $json[\"fileType\"] }} file found or an error occurred:', error);\\n    return {\\\"error\\\": 'No matching {{ $json[\"fileType\"] }} file found or an error occurred' };\\n  }\\n}\\n\",\n  \"context\": {}\n}",
				"options": {
				}
			},
			"name": "HTTP Request: Download4",
			"type": "n8n-nodes-base.httpRequest",
			"typeVersion": 4.2,
			"position": [
				1120,
				320
			],
			"id": "8ba0010f-fa97-45cd-928e-01751688705d",
			"credentials": {
				"httpHeaderAuth": {
					"id": "NXo0Bj93cIusdtnD",
					"name": "Browserless: Header Auth Account"
				}
			}
		},
		{
			"parameters": {
				"jsCode": "return [\n  {\n    json: {\n      url: 'https://getsamplefiles.com/sample-archive-files/zip',\n      fileType: 'zip',\n      downloadOption: 'first' // Options: 'all', 'first', 'last'\n    }\n  }\n];"
			},
			"id": "8ecdcfac-2d65-45ec-a604-5f49ae66383f",
			"name": "Code4",
			"type": "n8n-nodes-base.code",
			"typeVersion": 2,
			"position": [
				920,
				320
			]
		},
		{
			"parameters": {
				"content": "## Note about the URL field\nReplace yourdomain:port with your actual domain.com:portt# like something.com:24000",
				"height": 80,
				"width": 1341.4849931447006
			},
			"id": "e4e9705d-4b08-447c-85fa-57d260697ad8",
			"name": "Sticky Note4",
			"type": "n8n-nodes-base.stickyNote",
			"typeVersion": 1,
			"position": [
				-60,
				-180
			]
		},
		{
			"parameters": {
			},
			"id": "2e4045a9-cb47-4a65-af34-aabaa47ba16c",
			"name": "When clicking ‘Test workflow’",
			"type": "n8n-nodes-base.manualTrigger",
			"typeVersion": 1,
			"position": [
				1440,
				940
			]
		}
	],
	"pinData": {
	},
	"connections": {
		"Code": {
			"main": [
				[
					{
						"node": "HTTP Request: Screenshot1",
						"type": "main",
						"index": 0
					}
				]
			]
		},
		"Code1": {
			"main": [
				[
					{
						"node": "HTTP Request: Content1",
						"type": "main",
						"index": 0
					}
				]
			]
		},
		"Set URL": {
			"main": [
				[
					{
						"node": "HTTP Request: Scrape1",
						"type": "main",
						"index": 0
					}
				]
			]
		},
		"Set URL1": {
			"main": [
				[
					{
						"node": "HTTP Request: PDF1",
						"type": "main",
						"index": 0
					}
				]
			]
		},
		"Code4": {
			"main": [
				[
					{
						"node": "HTTP Request: Download4",
						"type": "main",
						"index": 0
					}
				]
			]
		}
	},
	"active": false,
	"settings": {
		"executionOrder": "v1"
	},
	"versionId": "186e16fa-c115-441f-8517-1ce16f3f2695",
	"meta": {
		"templateCredsSetupCompleted": true,
		"instanceId": "84c8cadeffb0e45ffb93507bd03ee1ba65b1274dc2bab04cc058f9e6a2a130e1"
	},
	"id": "cqCiCDGyUb37qXGd",
	"tags": [

	]
}

Note: Aside from adding your header authentication credentials, the only other change you’ll need to make to the above workflow is to update the domain and port of your Changedetection.io (or Browserless/Playwright) instance in each node, as mentioned in the sticky note within the template.

Benefits of This Setup

For those relying on third-party services for web automation tasks, this setup offers a self-hosted, cost-effective solution to capture screenshots, generate PDFs, extract HTML content, automate file downloads, and scrape elements from web pages, reducing reliance on third-party services. I hope these tips are helpful for others looking to automate mundane tasks possible with Browserless, Playwright, and n8n.

While exploring the Home tab, I noticed a Books tab next to the Research Papers section, featuring audio examples from public domain works like Leo Tolstoy's War and Peace. Although you can't upload your own Books, which obviously raises intellectual property concerns, this feature seems far more useful than limiting the service to scientific papers.

Interestingly, the Books feature isn't mentioned anywhere in the help section which I've copy/pasted down below. It feels like the Books feature was quietly slipped in without much explanation or a clear strategy, perhaps to avoid drawing attention—but it certainly highlights how challenging it seems to launch truly compelling products at Google these days.

One of the reasons I was initially excited about working at Google was their bold innovation across tech, product, legal and business in the early 2000s. When I see Google unveiling promising new technology restricted by an unfinished experiment that avoids taking risks, I can’t help but predict that services like Illuminate will soon be discontinued due to product limitations that prevent it from attracting a substantial user base.

Perhaps another team will eventually find a purpose for the technology and help it succeed, but I can’t help but wonder why its full potential isn't embraced now and allowed to stand on its own. Google’s leadership seems more inclined toward a cautious, measured approach, rather than launching bold initiatives that carry some risk. I hope this mindset shifts, as I’d love to see projects like Illuminate reach their full potential, with Google fully backing the ambitious visions its talented employees likely envision but struggle to get executive support for.

Via the "How to use Illuminate" help page which I can't link to:

What is Illuminate
Illuminate is an experimental technology that uses AI to adapt content to your learning preferences. After you select one or more published papers, Illuminate will generate audio with two AI-generated voices in conversation, discussing the key points of the selected papers. Illuminate is currently optimized for published computer science academic papers.

Selecting papers and generating an audio discussion

Once signed in, you can either search for a topic or a paper in arxiv.org or directly paste in the URL of a PDF from arxiv.org. Currently, users are permitted up to 5 audio generations per day.

Search:
Type the topic you are interested in the search box
- Tap on the search icon
- Select the paper you want Illuminate to use with the checkbox next to the title
- When your list is ready tap Add
- Press Generate

PDF URL:
- Paste the URL of a paper you want Illuminate to use
- Tap Add
- Repeat the same process if you want to add more papers
- When your list is ready press Generate

Depending on traffic and length of the selected papers, audio generation may take a few minutes or longer. In case you close the tab or lose connectivity during audio generation, the process will continue, and you can return to the generated audio conversation when you reload Illuminate.

When generation has completed, you can press the play button to listen to the new generated audio conversation. Tap the save button to save the generated audio conversation to your personal library. Generated audio conversations are deleted after 30 days unless you save them to your personal library.

Library
You can access the Library by tapping the Library button. The Library contains two sections:

Personal
Here you can find and manage all the audio conversations you generated with Illuminate and saved. Audio conversations you generate can be removed from your personal library by tapping Delete in the overflow menu.

Public
In this section, you can listen to a selection of publicly available generated audio conversations.

Sources
In the Library, each generated audio conversation is based on a published academic paper from arxiv.org. Tap Source to access the original paper and view its details, including title and author.

Listening to audio discussions
Tap Play to start listening to the generated audio conversation. You can control the playback speed as well as provide feedback on the quality of the generated content by tapping the thumbs-up/thumbs-down icons.

Feedback
During audio playback, you can use the thumbs-up and thumb-down buttons to rate the quality of the content. This is optional. If you choose to tap the thumbs-up or thumbs-down, we will ask you to fill out a follow up questionnaire to clarify your feedback. As an experimental product, know that we are continually iterating on the user experience. Providing feedback is important to help us improve the quality of Illuminate for all our users and we thank you for taking the time to share your experience with us.

Terms and Policies
Terms

When you use Illuminate, you are subject to the Google Terms of Service, including the Generative AI Prohibited Use Policy.

Privacy
Our privacy policy describes how Google handles your data when you interact with Illuminate. Please review it carefully.

Policies
Respect copyright laws. Do not share copyrighted content without authorization or provide links to sites where people can obtain unauthorized downloads of copyrighted content. It is our policy to respond to clear notices of alleged copyright infringement. Repeated infringement of intellectual property rights, including copyright, will result in account termination.

If you hear content in a generated audio conversation from Illuminate that you believe violates our policies, the law or your rights, let us know via this direct link.

If someone sends you a calendar invite but you don’t receive it, it’s very likely a very particular problem with a not-so-obvious solution. You likely have an iCloud account but you do not have iCloud Calendar enabled on your devices. When the sender sends an invite from their own iCloud calendar, Apple’s system sees that you (the recipient) is also on iCloud so instead of sending you an email Apple puts the invite right in your Calendar program. It’s very convenient if you are using iCloud Calendar. The problem is, if you don’t use iCloud Calendar (Maybe you’re using Google Calendar or Yahoo Calendar instead) that invite never gets to you and just hangs out in your iCloud account.

That sounds like exactly what happened to me. My friend shared a screenshot that showed they had created an invite in Apple Calendar using my Gmail address. Since I have an iCloud account associated with that Gmail address but don’t actively use iCloud Calendar, I am left to presume that the invite got "stuck in iCloud" and never found its way to my Google Calendar.

To resolve this, I followed the instructions in the post and adjusted my iCloud Calendar settings to ensure I receive email notifications for invitations and updates. Hopefully, this will prevent any future mix-ups. The Apple iCloud Calendar interface has evolved slightly since that original post, but the solution is still largely the same:

1. Visit iCloud Calendar from a web browser and log in with your iCloud account.
2. Click the three-dot (overflow) menu in the top left corner, and when the popup appears, choose Settings.

3. In the Settings window, select Accounts and choose to have your invites delivered via Email instead of via In-app Notifications. I happen to have a few emails associated with my Apple iCloud account which is why there are several listed below.

This will hopefully help avoid any further issues with missing invites. Thanks to Jimmy Obomsawin for the tip.

To be fair, Harmony Hub discontinued their remote products in 2021. However, as of the time of this post, they clearly state on their website that they will continue to support these products and their integrations with Alexa and Google.

I use my Harmony with Alexa and Google, will the integrations with 3rd parties change? 

This decision only impacts the manufacturing of new Harmony remotes. We plan to continue to offer service and support.

My Harmony Hub uses IR to turn on my living room TV, set it to the correct HDMI port, turn on my amp, and set it to the correct input setting and volume level. I also use it to turn off these devices. For listening to music, I use it to turn on my amp and set it to the right input setting, and I use it to turn off the amp as well.

Having been a product lead that helped launch Google Assistant, home automation integrations, and routines, I have numerous smart home devices and Google speakers. Back in 2015, one of the first smart home integrations I enabled was the command, "Hey Google, turn on the TV," which coordinated actions across multiple devices. When this doesn't work, it's always been a nuisance to debug.

My household primarily relies on Apple devices and services. Since leaving Google, I've transitioned to using HomeKit and the Apple Home app for my smart home needs. However, I still depend on Google Assistant for a few custom voice commands because I have Google speakers and smart displays in every room in my house.

Since the Harmony Hub integration with Apple HomeKit is functioning properly, I decided to explore how to connect HomeKit to Google Assistant. My goal was to use Google Assistant voice commands to control devices linked to HomeKit. Here’s the process I followed to make it work.

Pre-requisites

• Harmony Hub configured with the desired activities for voice command triggers.
• Homebridge server connected to Apple HomeKit.
• Harmony Hub connected via Homebridge using homebridge-harmony.
• An account set up with the Google Home App.
• Device(s) that can respond to Hey Google voice commands.

This post explains how to:

• Configure these additional Homebridge plugins:
  • Dummy Switches
  • Homebridge Google Smart Home
• Create some Apple Automations to trigger several Harmony activities.
• Set up some Personal Routines in the Google Home app to use voice commands to trigger various Apple Home automations.

Homebridge Server Dummy Switch Plugin Configuration

I already run a Homebridge server and have been using the Dummy Switches plugin for other purposes, which I found useful in this situation.

I configured two stateful Dummy Switches on Homebridge: one called DSwitch - TV and the other DSwitch - Stereo.

Apple Home App Automation Configuration

I already have my Harmony Hub connected to the Apple Home app via Homebridge using homebridge-harmony. I imported a few Harmony Hub activities to the Apple Home app to switch on the TV and listen to music.

Next, I configured a few accessory-controlled automations in the Apple Home app.

When DSwitch - TV is turned on, it triggers the Harmony Hub's TV-Switch activity, which powers on my TV and amp.

When DSwitch - TV is turned off, it triggers the Harmony Hub to turn off the TV-Switch (which turns off my TV and Amp).

When DSwitch - Stereo is turned on, it triggers the Harmony Hub to turn on the listen to music switch (which turns on my Amp).

When DSwitch - Stereo is turned off, it triggers the Harmony Hub to turn off the listen to music switch (which turns off my Amp).

Homebridge Server Google Smart Home Plugin Configuration

The Homebridge Google Smart Home (GSH) plugin allows adding devices from HomeKit to Google Assistant in the Google Home app. I followed these instructions to configure the GSH plugin.

It's mentioned in the instructions but it's crucial to first configure this plugin and then add the connection to Homebridge in the Google Home app after setting up the Homebridge Dummy Switches and Apple Home app automations.

Google Home App HomeBridge Configuration

After setting up the Dummy Switches in Homebridge, configuring the automations in the Apple Home app, and installing the GSH plugin in Homebridge, I followed the GSH Wiki instructions to add Homebridge as a connection in the Google Home app. After connecting, I imported the two new Dummy Switches I created.

I believe I had to repeat the Homebridge setup process in the Google Home app to import the second Dummy Switch. On the Add devices screen, I needed to long press on the Homebridge integration and select Check for new devices to access the flow for selecting more devices to import.

Google Home App Routines Configuration

Once the Dummy Switches appeared in the Google Home app, I moved them to my Living Room and created a few Google Personal routines with specific voice commands.

When I say to Google Assistant, "Hey Google, turn on the TV," it triggers the DSwitch - Living Room TV dummy switch in Homebridge (which triggers the Apple Home automation, turning on my TV and Amp).

When I say to Google Assistant, "Hey Google, turn off the TV," it triggers the DSwitch - Living Room TV dummy switch in Homebridge (which triggers the Apple Home automation, turning off my TV and Amp).

When I say to Google Assistant, "Hey Google, turn on the Stereo," it triggers the DSwitch - Stereo dummy switch in Homebridge (which triggers the Apple Home automation, turning on my Amp).

When I say to Google Assistant, "Hey Google, turn off the Stereo," it triggers the DSwitch - Stereo dummy switch in Homebridge (which triggers the Apple Home automation, turning off my Amp).

Conclusion

Although this setup is definitely brittle, it succeeds at connecting Google Assistant to HomeKit. My Harmony Hub now responds to Google Assistant voice commands as it did before the Harmony integration with Google Home stopped working.

As you turn the adjustment bolt, it clicks, changing the tension one step at a time, with four clicks per turn. This allows you to fine-tune the spring force to achieve the optimal cleat holding tension for releasing the cleats from the bindings. To ensure equal spring tension on both pedals, you can refer to the tension indicators and count the number of turns of the adjustment bolts.

The Shimano website provides further insights into the benefits of higher vs. lower tension settings:

Why Opt for More Spring Tension? 

A higher pedal spring tension will provide the most secure connection between your cleat and the SPD-SL pedal. This ensures maximum power transfer and a "locked-in" feel for aggressive and explosive riding. Think riders looking to get every iota of efficiency out of their bikes as they seek ultimate speed.

Keep in mind a higher spring tension will require better ankle mobility and strength to turn the foot and disengage from the pedal. More experienced riders who have lots of practice getting in and out of clipless pedals will often opt for this firmer spring tension.

Ultimately, you’ll most likely find the higher spring tension settings in WorldTour road races and the fastest local group rides. This is where the pros and racers prize absolute connectivity and efficiency above all else, especially during explosive power outputs. 

Why Opt for Less Spring Tension? 

A lower SPD-SL spring tension still provides a connected feel between rider and bike but allows for easier disengagement with less effort. These settings are perfect for those who are new to clipless technology or who are gaining confidence with clipping in and out.

The reduced effort to clip out means riders with less strength or mobility in their ankles will appreciate a lighter spring setting, even those with years of riding experience. Ultimately, this lower SPD-SL spring tension is well-suited for riders whose pedaling dynamics remain consistent without great bursts of power.  

The dealers manual for Shimano pedals includes a helpful graphic that clearly explains how the adjustment mechanism works.

Now that I'm up-to-date on pedal tension adjustments, I plan to follow Shimano's tips for shoe fitting and cleat placement.

While setting this up, I encountered several issues. The ConnectIQ app on my iOS device wouldn't allow me to update a few third-party apps I had installed, showing them as listed in my "Download Queue" no matter how many times I successfully synced.

I eventually worked around the stuck ConnectIQ apps by unpairing my Edge device from both the Garmin app on iOS and my Bluetooth settings, then repairing the Edge device via the Garmin app. After completing the pairing process, I force quit the ConnectIQ iOS app and was finally able to successfully sync and update the queued third party apps using the Connect app.

Before this, I had tried syncing on macOS using the Garmin Express app, even unpairing my Edge device, removing device data from the Express "RegisteredDevices" folder, emptying the trash with the Edge device connected to my Mac, and then repairing, but that didn’t work. It appears that the issue is specific to the phone and needs to be addressed there.

Garmin software has significant room for improvement. Throughout this process I encountered 500 errors on their website, sync issues in the Express macOS software that they are aware of but haven’t fixed, and various other sync issues on their devices. After chatting with support, they advised me to ignore many of these issues.

Anyway, I’ve got it working again. Time to get out and ride.

Below are screenshots of the other errors I encountered. Despite this, Garmin System Status indicates everything is functioning normally. This poor quality makes it challenging to recommend Garmin bike computers.

Today, I searched my YouTube history for a video I watched on my iPad and couldn't find it. I realized that even after tapping the "Turn o...incognito" button to disable Incognito, none of the videos I watched since were saved to my history. This appears to indicate that there might be two bugs:

1. The call-to-action text to disable Incognito is truncated.
2. Once Incognito is disabled, the app continues to behave as if it's still in Incognito by not saving watched videos on that device to the users history.

Software bugs are common, and teams often ship unintentional mistakes. If you're experiencing this issue, and found this via search, it's not you.

That doesn't change the fact that I am disappointed that one of the most popular and highest-grossing apps in the App Store hasn't properly implemented a privacy feature. It reflects a disregard for user experience and attention to detail. Given that I pay $23 per month for a YouTube family plan, this leaves a sour taste in my mouth.

I reported these issues via email to an iOS tech lead at YouTube, hoping they are aware and planning to fix them, as the second issue also occurs on iOS. As someone who has steadily reduced my reliance on Google products, I hope they make it a priority to deliver higher quality experiences to the Apple ecosystem one day.

Update 7/16/2024: I think I have a better understanding of why my watch history on iOS/iPadOS isn't updating.

I'm using AdGuard Home, and it turns out that s.youtube.com is being blocked by a filter. This blockage prevents YouTube's video history from updating on iOS devices. I confirmed this by disabling AdGuard, watching a YouTube video on the iPad app (making sure I wasn't in incognito mode), and seeing that the watch history updated as expected. When I re-enabled AdGuard, the videos I watched no longer appeared in the watch history.

Interestingly, watching a video on youtube.com in my browser on macOS with AdGuard enabled updates the watch history correctly. It seems YouTube's API implementation for propagating watch history may differ across platforms, causing unexpected behavior for those who modify their DNS rules. Given that up to 27% of people use some form of ad blocker, YouTube might have millions of impacted users. FWIW I suspect the % of ad block users is higher on desktop devices and significantly lower on mobile devices.

The truncated text on the iPad is still a bug. However, upon further investigation, it’s difficult to classify the watch history issue as a bug. Instead, the inconsistency in watch history propagation could potentially be improved by using a consistent API/domain across platforms, if that’s not already the case. If the API and domain are indeed consistent across macOS/iOS, it might be worth YouTube investigating whether the API calls made when enabling and disabling incognito mode on iOS are performing unique actions that could be getting blocked by network filters, such as making a call to something like s.youtube.com. Maybe the web behaves differently. I’ve shared this update with folks at YouTube and wanted to also reflect what I learned in this post in case others encounter perplexing watch history behavior on iOS.

I recently visited a winery in Valpolicella, Veneto, in northeastern Italy, renowned for their Amarone. During the tour, I learned that the region has been experiencing significantly more rain in recent years. This increased rainfall has led to widespread outbreaks of the plasmopara viticola fungus, which attacks grapevines' leaves and fruits, causing downy mildew. This has devastated vines in many Italian regions and has led to a double-digit reduction in wine production nationwide in recent years.

To combat this fungus and protect their harvests, I was told that many organic wineries in the Valpolicella region have attempted to use organically certified copper fungicides. However, overuse of these fungicides has apparently resulted in soil accumulation, harming beneficial organisms and stressing the vines, which in turn affects grape quality and flavor. Additionally, overuse of copper has led to residues ending up in the wine when the grapes are pressed, rendering it unsuitable for consumption.

The winery I visited, while very supportive of organic and biodynamic winemaking, mentioned that after trying numerous organic techniques, they felt they had to switch to non-organic pest and fungus management strategies to mitigate these risks and maintain the health of their grapevines. They also noted that most of the region is moving away from organic farming and is unlikely to switch back.

Hearing this story was the first time I truly considered the impact of climate change on agricultural practices and its implications for the future of organic certification.

While writing this, I was sitting at a hotel pool 6,000 miles from home. It reminded me of advice I have given friends who are starting new companies: choose endeavors you'd be excited to share with someone you just met at a hotel pool.

If you’re working on something you'd be enthusiastic to discuss with a stranger while on vacation, there's a good chance you’re oriented in the right direction.

Reflecting on when I have offered this advice, it's usually because I sense someone might be pursuing an idea that makes sense on paper and that they can sell, but doesn't truly resonate with them.

Being excited about your work enhances performance, positively influences outcomes, and inspires others. When you’re passionate about a vision you are committed to realizing, vacations can recharge your energy, but they can't fix a lack of genuine enthusiasm.

Like others, I'm reading about the alleged Apple and OpenAI deal. Reflecting on Apple's past, particularly a rumored $1 billion deal with Nuance for a perpetual license to self-host and privately fork their speech technology for Siri's iOS launch, a pattern emerges. When Apple needed to quickly catch up, they licensed and integrated advanced technologies. This strategy allowed them to provide a cutting-edge assistant with voice recognition and speech synthesis to iPhone users. Given this history, it wouldn't be surprising if Apple is taking a similar approach with OpenAI to offer cloud based AI offerings. In the lead-up to WWDC announcements, it would be in character for Apple to have negotiated a perpetual license to self-host and fork as much OpenAI software as possible and to potentially license custom models.

6/11/2024 Update: According to The Information my original post seems to be wrong:

The features OpenAI is powering for Apple are running exclusively on Microsoft's Azure cloud, so we aren't sure which of Apple’s AI features will run on Apple’s own "private cloud," which Federighi said would handle tasks requiring bigger Apple AI models than the ones that will reside on Apple devices themselves. Apple is staying mum about which features are going to be processed in those cloud servers, using Apple’s custom chips. 

For OpenAI-powered features, Apple said the startup (and presumably Microsoft) won't have visibility into which Apple customer is making a request and won't be able to keep a record of the query either. So OpenAI may not be able to improve its tech from Apple customers’ queries the way it can from customers of ChatGPT.

My understanding is that disabling my primary line in my home country deactivates my phone number registered with iMessage, and in my case, my phone number can only be re-registered with iMessage when I re-enable my primary line and reconnect to my carrier in my home country. The trick seems to be to keep my primary line active but disable data roaming, set the data plan to my travel eSIM and disable carrier switching.

To receive inbound messages in iMessage sent to your primary phone number and to make and receive phone calls over Wi-Fi while abroad using a data eSIM without incurring data overages on your primary line, follow these steps.

Before Leaving Home Country

Keep your primary line enabled DO NOT DISABLE IT however…

• To prevent international cellular data use while abroad disable data roaming on your primary line in Settings > Cellular > Primary
• To prevent accidental cellular data use on your primary line while roaming abroad disable cellular data switching in Settings > Cellular > Cellular data
• To allow Wi-Fi calling on your primary line while abroad you must enable “Wi-Fi Calling on This iPhone” before leaving your home country in Settings > Cellular > Primary > Wi-Fi Calling
• To use Wi-Fi Calling when you connect to Wi-Fi abroad using your primary line you must enable "Prefer Wifi When Roaming" in Settings > Cellular > Primary > Wi-Fi Calling
• To prevent accidental costs abroad from sending SMS messages disable SMS in Settings > Messages turn off 'Send as SMS' 

Upon Arriving in New Country 

• Enable your new eSIM (by scanning a QR code, etc) this often requires being on Wi-Fi
• To use your international cellular data plan enable cellular data access in Settings > Cellular Data >  select the name of your Travel eSIM (your primary network must NOT be selected)
• To use data roaming on your international data plan enable Data Roaming in Settings > Cellular >  select the name of your Travel eSIM 

Upon Returning Home

• Enable data roaming on your primary line in Settings > Cellular > Primary
• Enable SMS sending in Settings > Messages turn on 'Send as SMS' 
• Delete secondary line in Settings > Cellular > name of your Travel eSIM