For years Karabiner has been the tool I've used for remapping keys and modifying input on OSX. The past few months I've been playing with kanata. Karabiner is still the simplest and best way to handle simple modifications, but if you want to track the configuration in git or do something more complex like homerow mods, kanata is better.

My kanata config is a nix module. It mostly installs kanata and just the karabiner-driver so that it can do input monitoring on OSX. It also adds a convenience script for switching layouts (so I can disable homerow mods if I wanted to play Factorio, for instance.)

I used AI quite a bit to build my layout. I pointed it at my zmk-config folder, and told it I wanted the homerow mods as a kanata layout, and after a little fixing, it was pretty much done. (I'm still flirting with an entire 5x3_2 layout on a macbook pro, using r and u has home keys. Wild!)

All of this has been working very well for a while, and I'm very pleased.

When there's an update to nix, it all breaks. The running kanata executable is no longer symlinked to the exact same location in the Nix store. I then just have to:

1. In the terminal: open /run/current-system/sw/bin/, select kanata and ⌘-C.
2. go to Settings → Input Monitoring and remove Kanata, click the plus for Add, and ⌘-V to paste the correct new link. Do the same for Settings → Accessibility.
3. In the terminal: sudo launchctl kickstart -k system/org.kanata

You are fine till the next time it breaks. 🤷

After Reeder was pushed to Reeder Classic and he's focused on the new app, I've felt a little abandoned. Nothing has scratched that itch…

But I recently tried NetNewsWire, and I'm loving it. I was drawn by that retirement post that many of you read, but what has kept me is the sheer speed of the sync. I also really love the simple UI, and on mobile the "next unread article" button is 🧑‍🍳👌.

I do miss some things: I wish that I could watch the youtube subscriptions in app, I miss a quick shortcut share to Instapaper… and my fingers miss the keyboard shortcuts I've been using for nearly two decades. I also really wish that the list of RSS feeds had a search filter. I have 1000+ feeds and treat some of them as bookmarks.

NetNewsWire just works and answers my particular use case so well, I think it's just going to stick.

I'm tired of my "open a tab to the 'front page of the internet'" behavior. When I first used the internet, I had a rich set of bookmarks that turned into RSS feeds. I used the internet like a library, not a tabloid. Now I just open up the "front page" and scarf down whatever tripe I'm served and I'm grateful for it. 🤮

So I've gone back to redirecting reddit and twitter to localhost.

Have any of you successfully dismantled your "one stop shop of slop" habits? How did you go about it?

I have toddlers. This resonates with me.

It's also freeing. The patient, wise, "example parent" of Proverbs is resting in God's promises for his children, and patiently repeating and providing instruction in the hope of it taking hold. Even better, it's a generational story. At this moment the father in this story is recounting his own story, reminding his son that he too was once young man needing instructed. There's humility there.

I could use that attitude today.

There are several other similar nix-based dev-ex systems, but (so far that I can see) devenv is the only one that insists on using nix to configure it. So many others try to give you nix without making you write nix… which is a nice idea but in my limited experience is a handicap.

When you just devenv init and check in the resulting files, devenv works great. What I've been working through is "what if you don't want to impose devenv on your whole team?" As a contractor I don't really want to foist my development preferences on everyone else.

I can .git/info/exclude the devenv files. However last few projects I've been working are complex. Four or more repositories, env variables shared between two or three but not all, separate languages, constant motion… not tracking the dev environment in git loses a large part of why to use a tool like devenv in the first place.

Here's what I'm currently doing: I'm working a contract with a team that isn't using nix or devenv. Because I want to track the configuration in git and not just .git/info/exclude the important devenv files, I've been:

1. Make a git repo to store the configurations in a sibling folder. I'll call this the Configuration Repo.
   1. devenv init in a sibling folder and tracking with git.
   2. Defining all the repos/projects for my contract as profiles…

{
  pkgs,
  lib,
  config,
  ...
}:
{

  packages = [
    pkgs.acli
  ];

  env = {
    CLAUDE_CONFIG_DIR = "../.claude";
    AWS_CONFIG_FILE = "../.aws/config";
    AWS_SHARED_CREDENTIALS_FILE = "../.aws/credentials";
    ENABLE_LSP_TOOL = 1;
  };

  profiles = {
    frontend.module = {
      languages = {
        javascript = {
          enable = true;
        };
      };

      hosts = {
        "local.fake-company-name.com" = "127.0.0.1";
      };
    };

    backend.module = {
      languages = {
        javascript = {
          enable = true;
          package = pkgs.nodejs_24;
          npm.enable = true;
          lsp.enable = true;
        };
      };

      packages = [
        pkgs.vscode-js-debug
      ];

      certificates = [ "local.fake-company-name.com" ];

      aws-vault = {
        enable = true;
        profile = "fake-company-name";
      };
    };
}

2. In the "real" Project Repo folder:
   1. devenv init and git excluding all files.
   2. Deleting everything out of devenv.nix so that it's a "bare" file.
   3. Then I setup the inputs and imports in devenv.yaml:

# yaml-language-server: $schema=https://devenv.sh/devenv.schema.json
inputs:
  nixpkgs:
    url: github:cachix/devenv-nixpkgs/rolling
  fake-company-name:
    url: path:../fake-company-name-devenv/
    flake: false
profile: frontend
allowUnfree: true
imports:
  - fake-company-name

I used to trigger this using direnv with an .envrc, I'm currently playing with using devenv's shell hook and devenv allow. This makes it clearer where the ENV variables should live… now they all are forced into a devenv.nix. If they need to be secret I can still use my .envrc or I can use devenv's new secrets system.

This works… but I've noticed a couple problems: I think that devenv treats the .devenv cache in the Project Repo as a source of truth, so when I update the Configuration Repo I often don't see changes until I rm -rf .devenv in the Configuration Repo.

I'm currently chatting in the discord to see if there's a better way to achieve what I want. So far… it's the best way… but it leaves something to be desired. While it stands up reliably and just works, it's resistant to change because of that local Project Repo cache. If I find something better I'll post it.

In my last post on Obsidian I talked about the problem of getting an inbox to obsidian on mobile. What I haven't covered is processing and writing those captures.

While the reason to use Drafts.app is the quick capture, an underappreciated aspect is to have one location for all my "in progress" thoughts. So often in the years that Drafts was in my iOS dock a half-baked shower thought would progress into a blog post over the following weeks.

As I shifted to using Obsidian for all my mobile writing/note-taking I used the folder of time-stamped drafts for holding the thoughts, but getting to them and processing them wasn't very easy. I had a simple dataviewjs thing for viewing the folder in a Inbox.md:

const files = app.vault.getFiles()
  .filter(f => f.path.startsWith("inbox/"))
  .sort((a, b) => b.stat.ctime - a.stat.ctime);

const items = await Promise.all(files.map(async f => {
  const content = await app.vault.read(f);
  const preview = content.replace(/^---[\s\S]*?---/, "").trim().slice(0, 120);
  return { file: f, preview };
}));

const dl = dv.el("dl", "");
for (const { file, preview } of items) {
  const dt = dl.createEl("dt");
  dt.createEl("a", { text: file.name, href: file.path, cls: "internal-link" });
  dl.createEl("dd", { text: preview + "…" });
}

I'd just open the links in new tabs, review them, and had some shortcuts for deleting/moving them. Not great.

This past week, Notebook Navigator has replaced this dataview hack and made my Obsidian inbox a comfy place that is very Drafts.app-esque.

Notebook Navigator is a rather extensive plugin and does way more than what I'm using it for… but for me just enabling it and disabling the built in Obsidian Files plugin has made a world of difference.

Now on mobile when I swipe over to the left sidebar, I typically see a list of recent documents. That's 95% usually one touch to the thing I'm looking for, but if not I can view the inbox folder as a list with previews.

Notebook Navigator (with some configuration) can support my journaling structure.

The Notebook Navigator Calendar feature is a really nice interface on mobile with quick access to my incrementally abstract journaling notes.

The author of Notebook Navigator updates it frequently, with recent updates focusing on helping folks write long form work like Scrivener. If you've been wrestling with navigating your wiki, especially on mobile, give it a try.

I know that OBS saves it's settings to ~/Library/Application Support/obs-studio and I could backup my settings, but I have not yet done that, and so I have had to re-set up my settings lots of times.

Here is how I typically set up my OBS for simple screen shares:

1. Add sources:
   1. Video Capture Device for iPhone Continuity Camera
   2. Desktop Share (separate MacOS Screen Capture sources for laptop monitor than desk monitor!)
      1. Settings for Desktop Share: Hide OBS from Capture ☑️
2. Adjust gain to match either AirPods or my lavalier.
3. Set canvas to size of biggest monitor: Settings → Video → Base (Canvas) Resolution → 3480x2160
4. Duplicate the default scene to create two scenes.
   • Share: Full screen screen share with small camera in bottom right
   • Talk: Full screen camera view
5. Set Talk be full-screen camera by reordering sources and adjusting size.
6. Set auto switch: Tools → Automatic Scene Switcher:
   • When no window matches: Switch to Share
   • When OBS: Talk
7. Settings → Output → Recording → Recording Quality: Indistingushable, Large File Size

I think that’s it! I'll adjust this as I find the other settings. 😂

I've always been a huge of Drafts. It is the best Apple ecosystem note taking tool. However I have two problems: I want to not be 100% beholden to the apple ecosystem, and I want to work in Obsidian. While I used Drafts as my inbox to Obsidian, I pretty much ended up doing all my writing in Drafts because it was so convenient, and therefore missed out on links and research.

I've tried a number of quick capture options:

• Widgets for Obsidian
• Obsidian Quick Capture
• Shortcuts

In the end, the two paths available are:

• use a obsidian URL-scheme (requires the app to boot, ensures that the note syncs)
• save to a file (fast, but won't sync until the next app launch)

I've used all three of the above apps, the are all decent, but none of them are Drafts. I usually choose to use those apps to save individual notes to an inbox folder named by a timestamp, and use other workflows/tools to merge/move the notes to a place. I was just appending to Daily note, but I often found that if sync didn't catch it, I'd lose notes in a merge.

Honestly, if I could guarantee that every Draft was synced to a folder in iCloud, and that folder was the inbox folder in my wiki, I'd probably do that.

For now, the lack of decent digital capture means that I have spent more time capturing in my bullet journal, and honestly that's not a bad thing at all. All roads may rotate back to the hipster PDA at the end.

After writing about the alternatives to the Zen, I kept looking at the Ferris Sweep. Having spent a lot of time using the Kyria and Atreus keyboards, the finger arch on the Corne felt kinda shallow. I fight to find a comfy angle: either my thumb or my pinky always feels a little stretched. Tenting helps a lot, but it's not quite right.

Prior to the purchase I experimented with dropping a thumb key on the zen to match the 3x5_2 that the Ferris uses, mostly using combos to handle the roles the outer thumb keys had managed. I found it pretty natural, so I pulled the trigger and waited to build the kit.

It wasn't a particulary difficult build now that I've built a few of these, but it was the first time I'd dealt with the LiPo batteries.

I of course slapped some of my magsafe stickers on it, and I've been enjoying ever since.

I started with Darryl's LDSA caps which were very nice.

I recently added the KLP Lame profile switches from 3dkeycap, and it does give a great "dish" feel that makes the keys seem even closer together and very comfortable.

While the Zen is very solid and feels more premium, I really love the finger curve and placement of the Ferris. I don't feel like I need to adjust the angle throughout the day, it's lovely.

The Problems

I had accumulated several problems that I wanted to solve:

• My blog repo had ballooned to 2GB, which meant checking it out on my phone to edit was tedious.
• I wanted to compose/think/write in my plaintext wiki, which means I can use nvim on desktop and Obsidian on mobile.
• I write in a networked wiki, but publish isolated posts.
• I just like Elixir. 🤷

I started thinking about this a long time ago. Some of y'all helped me write a script to export my blog posts (and their git history) and merge it into my wiki repo.

But I just didn't have all the solutions yet.

Finding Tableau

For years, I considered writing my own static site generator. I wanted something that used the libgraph module, and had a similar system to Phoenix's plugs. Then I found Tableau. 😍

With all the pieces ready…

1. I made a quick images repo and deployed to cloudflare R2. Lots of space savings: it doesn't need the history.
2. I ported over the layout from .erb to .eex. I spent some time trying .heex but got stuck.
3. I modified the merge script I had written earlier, tested it against a folder in wiki, and started fixing bugs.

But now I had a huge list of custom features that I've accumulated over the years, and Tableau has the answer.

Tableau Extensions

Every single feature in Tableau is actually an Extension. Pages, Posts, RSS… all using the same Extensions API.

Here's an example of an Extension that waits for Tableau.PostExtension to push a posts object into the graph, then generates my Series pages:

defmodule Travers.SeriesExtension do
  @moduledoc """
  Creates an list pages for series
  """
  use Tableau.Extension, key: :series, priority: 300

  import Travers
  require Travers.Article

  # token = the "graph" object
  # get every post out of the graph, find the series
  # save them back as a new entry in that %{Map}
  @impl Tableau.Extension
  def pre_build(token) do
    series =
      token.posts
      |> Enum.filter(&Map.has_key?(&1, :series))
      |> Enum.group_by(fn post ->
        post.series
      end)
      # returns { :series_key, [list_of_matching_posts ]}

    {
      :ok,
      Map.put(token, :series, series)
    }
  end

  # For every series, make a %Tableau.Page and insert it into the graph
  @impl Tableau.Extension
  def pre_render(token) do
    pages =
      token.series
      |> Enum.map(fn {name, posts} ->
        %Tableau.Page{
          parent: Travers.PageLayout,
          permalink: "/articles/series/#{Slug.slugify(name)}",
          template: fn assigns ->
            ~H"""
            <%= Travers.Article.series_header(@page.title) %>
            <ul class="article__list  h-feed">
              <%= for post <- Enum.sort_by(@page.posts, & &1.date, {:desc, Date}) do %>
                <li>
                  <div class="h-entry">
                    <%= Travers.Article.header(post, list: true) %>
                  </div>
                </li>
              <% end %>
            </ul>
            """
          end,
          opts:
            %{
              title: name,
              posts: Travers.public_posts(posts),
              permalink: "/articles/series/#{Slug.slugify(name)}",
            },
        }
      end)

    graph = Tableau.Graph.insert(token.graph, pages)

    {:ok, Map.put(token, :graph, graph)}
  end
end

Working with Opencode and Claude¹, I implemented:

• Calendar pages for Years and Months of articles.
• RSS Enrichment Extension to decorate certain articles.
• Series for grouping sequences of articles
• Git changelog for getting the history of changes to an article (preserved across repos thanks to y'all!)
• Wiki (more on this in a moment.)

I also made a couple custom plugins to MDEx for my youtube and admonition shortcodes².

Publishing the Graph

Every blog post is actually a small network of notes and thoughts. We draw a circle around the scope of what we want to discuss, and try to arrange the thoughts into something readable.

For years I've composed in one note, and included related notes as footnotes, or sometimes rearranged notes as series of posts, but it never works quite right. Worse yet, I now have a duplicate note in the blog and wiki. As an ugly solution, I've just "deprecated" the wiki note and it's now an empty note with a bare link to the published post.

Not anymore!

I wrote a Tableau.Extension and MDEx plugin to together create my dream publishing system. The Wiki extension crawls my wiki for files marked post: true or with an arbitrary permalink: frontmatter. Then it follows those rules! The MDEx plugin "cleans" the document of broken links, and if there's a published page, it replaces the [[wikilink]] with the real link.

Under this design I have so much freedom. I can post an individual idea as a blog post, that auto updates and changelogs as I think. I can publish a subgraph of thoughts together to any permalink I want. I eventually want something like Maggie Appleton's amazing garden, but one step at a time.

For now I am content to re-absorb my published notes into my wiki and dreaming of what I can do.

Writing

All this means I can pick up writing where I left off from a phone or a computer at any point. (Something I've enjoyed while writing this post!) Previously I had kept post drafts on Drafts.app for this same "easy pick up," and now I can use Obsidian for the same. This is wonderful… before I would constantly be app-switching between my thinking/research in Obsidian and my writing in Drafts… now it's all one space. 🙌

Deployment

Even with all those new features (and with parsing my wiki repo's insane 6800+ files!) Tableau is still a speed-up:

❯ scripts/compare_builds.sh --html-only
[..] Building Tableau in /Users/evantravers/src/github.com/evantravers/travers
[OK] Tableau build completed in 12.79s
[..] Building Middleman in /Users/evantravers/src/github.com/evantravers/evantravers.com
[OK] Middleman build completed in 34.06s

I am using nix in GitHub CI, and that's pretty fast too. The slowest thing right now is standing up the devenv shell, it takes 70% of the total pipeline. I'll likely rewrite it as a simple flake and cache it.

Next

I'm pretty excited about what this unlocks. I've wanted to make a bookshelf for book reviews, and I can do that easily. There's a few things I want to do: I need to make the Github CI action a lot faster. I might try to contribute a faster dev server for Tableau. I also need to implement a cross-repo message so that changing my wiki pushes to the blog. Lots of fun things to do!

Last night amidst a hacking-cough hackathon… I pushed a version of this blog running on a completely new Tableau-based repo and a new architecture. I'm still writing up the whole rewrite and why, but if you loyal RSS-friends notice anything odd, please contact me? 🙏

The absorb command will do a lot of this for you by identifying which downstream mutable commit each line or hunk of your current commit belong in and automatically squashing them down for you.

I. Did. Not. Know. This.

I have been using this today because I have a Claude Skill I'm building and a feature upon which I'm testing it. Using the jj new <feature-change> <skill-change> I can make this "megamerge" commit, and all day I've been working on that change and jj absorb has magically pushed all the changes to the skill to the right tree and all the changes to the feature to it's tree.

Another example!

I'm working on a blog rewrite, and I'm keeping the "posts" from the old blog out of it for a bit, but I have a change where I've imported them all. Before, I'd work like this: I'd keep a change with all the posts, develop on top, use jj arrange to place it behind the to-be-abandoned post change, and then advance the bookmark.

❯ jj
@  ykrxvkkm evantravers@gmail.com 2026-04-22 09:08:32 1ded0f62
│  (empty) (no description set)
○  umpkkzsz evantravers@gmail.com 2026-04-22 09:08:21 758024da
│  ABANDON posts
○  wvvpwtmo evantravers@gmail.com 2026-04-22 09:08:21 0b2f1caa
│  Cleaning up and moving pages
◆  pzvsmozt evantravers@gmail.com 2026-04-21 17:09:58 main 252dc606
│  Move over pages from our proposal day
~

Now I can use the merge strat, and never have to do that little jj arrange dance!

❯ jj
@    nzywloxl evantravers@gmail.com 2026-04-22 17:50:41 0281b2e6
├─╮  (empty) (no description set)
│ ○  umpkkzsz evantravers@gmail.com 2026-04-22 17:50:35 bbca7bfc
│ │  ABANDON posts
○ │  wvvpwtmo evantravers@gmail.com 2026-04-22 09:08:21 0b2f1caa
├─╯  Cleaning up and moving pages
◆  pzvsmozt evantravers@gmail.com 2026-04-21 17:09:58 main 252dc606
│  Move over pages from our proposal day
~

Any time I make a change, I can jj absorb it down, or do it manually with a jj split followed by a new "megamerge." Mega cool.

Jujutsu Megamerges for Fun and Profit - isaaccorbrey.com

• bundle update
• nix flake update
• npm format

You get the idea.

I had opencode whip up a simple fish command that mimicks what ⌥-p already does: takes the current prompt line and wraps it in <prompt> %| less -R. If the current prompt is empty, it uses the previous command. This is exactly what I wanted!

function jj_desc_wrap --description="Wrap previous token or history command in jj desc -m """
    set -l tokens (commandline -pc)
    set -l token $tokens[-1]
    if test -z "$token"
        set token (history --max=1 | head -1)
    end
    if test -z "$token"
        commandline -i "jj desc -m \"\" "
        commandline -C 12
    else
        commandline -r -- "jj desc -m \"$token\""
        commandline -C 12
    end
    commandline -f repaint
end

I have this bound to ⌥-o for now, because I think there's no conflicts.

Already this has been such a pleasant little UX change to my daily work.

Theological evaluation begins and ends with the sovereignty of God. A technology is more than a tool, more than a technique, more than a telos. It is all three, and all three must be asked together. The maker is an image-bearer under a mandate. The method is stewardship under a standard. The end is the glory of God and the flourishing of all He made.

Starting from Augustine's twin cities serving two masters, Randy starts to build a framework for technology.

Every tool serves a calling, every technique serves a standard, and every telos either honors God or rivals Him.

I really like this framing, and I'm very excited to see what Mr. Caldejon writes next. (Bonus points for the Bavinck reference!)

A Theological Understanding of Technology - Tool, Technique, and Telos - www.decalogue.ai

Spiritual Life

I've been keeping track of prayer requests this year. As of this writing I have recorded sixty-one specific answers to prayer this year. Praise the Lord for his provision!

I added kneeling prayer once a day to my habits… targeting the time I'm usually most tired and prone to irritability. I think that's helped. My personal quiet time has been very fractured and infrequent. I've been a little more consistent at having family worship at the table.

That being said, I have felt the Lord's hand and protection through the big waves. In so many ways this year has been a dark mirror of 2020: political unrest, job change, pregnancy, much discussion and stress… but rather than being pulled away from the Lord and pulled apart in marriage, we have been strengthened and upheld.

Relationships

Because of chaos and baby, we didn't take too many trips this year… just three wild trips to the beach.

We've had a lot of folks in our home for board games and dinner, and that's been a big joy that we want to do more of next year.

Another big answer to prayer is that we are both enjoying our kids more than ever. They haven't been easier to deal with, I have just been granted more grace to enjoy them.

Health

Equal victories and defeats here.

After a short weight loss before baby arrived, I've shot up to 180lb and stayed there since June. Some of that was post-birth weight gain, but some of that has been some re-building of new muscle. I bought my first t-shirt in size L this year, and it's because of my shoulders not because of my gut. 💪

I tapered off Zyrtec, and have been six months or so without my daily dose. Doesn't seem to have affected my sinuses at all.

My skin stuff and gut owing to stress has continued to be a problem, but not as bad as previous years. I think that the smartwatch's input on my sleep has been a good lag metric to help me stay healthy.

My Morton's Neuroma hasn't really improved in a year of PT. I'd say I'm about 70% faithful to do the physical therapy, but I hoped to be farther along. I am starting to consider surgery… mobility is a big deal. I was really sad that for the first time in five years I was unable to run the 8k race near my house. I really have to get that fixed.

Creating

I only published 20 blog posts, less than half of last year.

My writing habit got severely curtailed by both the birth of a child, loss of a job, and pursuit of a new one. I still have written a fair amount (I've created 1100+ files in my wiki!) it just hasn't made it's way out to the blog.

Scrolling through the list of wiki notes… there's a lot of thinking about work, about personal growth, about people that I'm praying for, and of course, AI.

(I have a couple larger essays stuck in my system again… maybe I'll get a chance to polish them up over the break, or at least find a format where I'm ok with publishing them imperfect.)

I did spend some time updating the blog itself… adding slashpages and updating some old ones. The /blogroll and /uses get updated relatively often, and I usually update /now when I switch books.

I've continued to double down on nix as a strategy and am loving it. It was a huge blessing to have that tool in my arsenal when I wound up consulting as a software engineer for ~6 months. The fact I could update my computer without fear of destroying a project's configuration… wonderful.

While I use AI a good bit for work, I still try to write my prose and code by hand. No good reason. Just sharpening a tool, and hopefully my mind.

Sketchnoting

I continue to sketchnote weekly sermon entries. I also did sketchnotes for the dev track of a local tech conference. Looking back at this year I realized that I've relied a bit too much on speechbubbles, and I'd like to do more diagrams and visual storytelling.

I've also started (very recently) a weekly sketching habit. I've not been utterly faithful to it, but it's been nice to sit and just see for thirty minutes. I'm super thrilled that my kids sit with me and show me their results.

Reading

This year I changed my lead indicator of reading to "books I have started" to try and allow myself to drop a book that "gets stuck." By this metric, I started 26 books, finishing 21.

Some highlights:

• Polostan by Neal Stephenson: In a world of change, spies navigate the rising power of communism and the new science of the atomic age.
• Teach Them Diligently by Lou Priolo: A look at raising children through the light of 2 Timothy 4:2.
• Consider The Lilies by Jonny Ardavanis: Extinguishing anxiety by looking into the overwhelming goodness of our Father God.
• Piranesi by Susanna Clarke: Wandering a strange house, an optimistic journal ponders the most important questions.
• How to Lead Your Family by Joel Beeke: Exhorting men to pattern our lives after Christ in his roles as prophet, priest, and king in our homes.

My new Boox Palma has really helped… I really love KOReader.

I've listened to less podcasts over the year… in part because of realizing how vulnerable my mind is to words. Some standouts from my subscriptions:

• Gospelbound has been a great source of books for my queue.
• Dwarkesh has kept me apprised of AI thought, although I find myself disagreeing with his positions more over the year. (I find his comparisons of baby's learning styles to LLM training sequences utterly ridiculous, and I fundamentally disagree with his concept of what is knowledge.) I do really admire his curiosity and tenacity.
• I don't listen to every episode of Presbycast, but I do listen to every episode of their Fathers and Brothers collection.

I've been continuing to use Refocus to block all social media, shopping, and distractions for much of the year. That has contributed to the growth of my /blogroll.

Work

Ironically, I had set this year's theme as "Look for Work," and boy did that hit with a vengeance.

The original meaning for me was partly about finding my next job, but also about just avoiding laziness: to have a mindset that always looks for the next thing to do… but when the layoff struck it collapsed down to finding a paycheck.

Even before the layoff, I've been beset with the eternal question of "what do I want to do when I grow up?" UX or programming? Management or IC? How does AI change any of this?

I'm still working on that. 🤷

2026

I'm hoping to spend some time with my wife planning the next year… at the moment the time has been coming too fast and furious so I haven't set a good Theme for 2026.

One thing is for sure, I know that the Lord will display his infinite faithfulness and love even more fully in this year than the last. Happy new year!

When you’re going to the moon, you’re assigned a camera with a 60mm lens that gets strapped to your chest to document samples, experiments, and the lunar terrain. Both astronauts get their own, clearly labeled with a sticker on the side: “CDR” for commander and “LMP” for lunar module pilot, but they weren’t mutually exclusive, often being swapped throughout the mission based on what film they were shooting with.

I love websites dedicated to a single purpose… a lifetime of attention to detail. This is such a treasure hunt. Also the stickers from their store are awesome.

Finding Gene Cernan's Missing Moon Camera — Space Camera Co. - www.spacecamera.co

Since I deleted my microphone and light off my desk to just use an iPhone, I've wondered if there was a small microphone system that could slightly upgrade my setup. I have seen the small fuzzy mics held by YouTube personalities, but they were just a little too expensive.

After seeing the tags on David's private post I've been trialing the Hollyland Lark M2S microphone. I've been using it pretty much daily since April.

The biggest advantage of doing this is higher incoming audio quality coming from my Airpods Pro. There are better audio-specific reviews out there on youtube, and the Hollyland Lark M2S does perform very well, but the sheer advantage of getting more bits when someone has a bad connection or a hard audio environment… I'm finding myself reaching to plug in the USB-C dongle for the Larks as soon as I've asked someone to repeat themselves.

My only complaint was that the USB-C dongle blocks one of my precious ports, but it at least sports a charging pass-thru, so I haven't suffered too much.

The small USB-C charging case also fits perfectly in my office in a bag, which is of course a requirement. 🙌

Previously I was generating my blogroll semi-regularly from a tag in my Feeds.opml, but I kind of missed the ability to introduce the source and point out some favorites, so now the /blogroll is written by hand from a YML file and updated when I find stuff to send.

Just because a source is listed doesn't mean I agree with every jot and tiddle, just that I have either found joy or interesting thoughts from something there. Most of them are also independent creators who are living the indieweb life, and some are personal friends. I'll keep tweaking it.

Part of jj's whole deal is that it collapses many Git concepts (stashes, staging, fixups, in-progress rebases, conflicts) into a single unified model of working with history, which then lets you use the same tools to do all of those things.

👏👏👏

Extremely good explanation. I've been programming for a living for the past few months and using jj anywhere that doesn't use git-lfs and just loving it.

Tech Notes: Understanding Jujutsu bookmarks - neugierig.org

He argues that our rigor and formal methods must extend beyond the code and into the human systems that the code models:

Software is both the artifact that produces the program and the running program in the real world. If we miss either of those, we will end up in a really confused place. And by the same token, if we want to make our software good, we have to tackle both parts.

He then discusses how wisdom and discernment (which he calls mētis) is critical when working in the complex systems we are often called upon to model and improve… and how in the pursuit of "high engineering" (my phrase) we flatten a messy complex world in our code, and therefore have overly simplistic and incorrect models of the real world and therefore… bad software.

Fantastic talk. It's still sinking into my brain.

Seeing Like a Programmer (LambdaConf 2024) — Sympolymathesy, by Chris Krycho - v5.chriskrycho.com

The section that I found most interesting had David speaking on the non-verbal interactions between orchestra and conductor.

One such gem was this: be there waiting when your team looks up.

The funny thing is, every single individual in an orchestra looks up at a different time. It’s totally personal. […] One of the challenges for a conductor is, as quickly as possible with a group you don’t know, to try and actually memorize when everybody looks up…

What a joyful and insightful thought. How often I assume all the other players "look up" when I would look up. This concept has really challenged me in parenting the past few weeks. As a parent if I get the desired behavior from my kids, my first thought is to turn from them to the next problem to solve. If I take the conductor's wisdom, then I want to be there waiting when they look up.

For those of us who aren't sure, David has a confident assurance as to at least one moment where we should be waiting to communicate: right after the action.

But the thing that no one will tell you, and that the players themselves don’t often realize, is that instinctively, and I think subconsciously, almost every player looks up after they’ve finished playing something. I think it’s to just check in to see, “Am I in the right place?”

That is a personal moment, where the orchestra is thinking about what’s coming. They’re not thinking about what’s behind because you’re constantly in the present and the future, but that’s your moment to send a message to somebody which can be, “Oh wow, that was incredible.” That sense of “Maestro came to my house” is really one of the things that I think helps build this kind of communication and trust between the players.

Even though I am relatively illiterate when it comes to modern classical music, David is full of useful insights on performance, teamwork, and leadership. Enjoy the whole engaging interview below.

David Robertson on Conducting, Pierre Boulez, and Musical Interpretation (Ep.248) - conversationswithtyler.com

I just finished up two days of Sloss Tech, mostly attending the Developer and Engineer track at the McWane Center. The BASE crew did a fantastic job facilitating the event, and as someone who entered the tech industry at Barcamp events long ago, I really enjoyed it.

There was a strong emphasis on (surprise!) generative AI. While my previous opinions have not changed greatly, I felt both excited to try new things and daunted by the organizational and cultural changes that will come with these new tools.

Here are the sketchnotes, along with a small takeaway that resonated with me.

Thursday

Friday

For those who want to keep a copy of my notes from their talk, you can download a PDF here.

Thank you to Nibuild who sent me, it was real treat. 🙏

While listening to Derek Sivers on Focused I was struck by two things: how much I owe to Sivers for some indieweb accomplishments and generally celebrating plaintext… and how jealous I am of his incredible sive.rs domain name.

And now trave.rs is mine!

I've wanted it for quite a long time, but up to this point there's been a high price. The Serbian TLD used to require a local business license, but sometime while I wasn't paying attention that changed.

I'm definitely going to setup some emails for myself and my family using that domain. What I'm wrestling with now is whether I should make it this website's main TLD. It's been evantravers.com for thirteen years. Is trave.rs rad enough to warrant a change? I'd certainly have redirects to prevent linkrot, but I dunno. I'll sleep on it. 🤷

What do y'all think, should I make the big change?!

It should be the people closest to us, the ones we say we love the most.

But it's not.

Historically the voices that built our worldview, exposing us to new ideas and cementing patterns of thought, were the voices physically nearest to us.¹

While this physical limitation has been slowly eroding since the printing press, the shift in influence has accelerated dramatically since we put iPods in our pockets.

For the first time in human history, two entire generations of people have grown to adulthood where voices outside our immediate community are the absolute primary force in forging our minds.

(The back half of my life is inside that window.)

I've taken a stab at mapping my life into seasons marked by the "voice most heard." I'm not talking about emotional impact, I'm not talking about person who means the most to me, I'm talking about raw audio hours. It looks something like this:

I am ashamed of this.

It's not that these particular external voices are bad. I'm very grateful for what I've learned from them. I'm ashamed of the sheer hours, the sheer a-mused² exposure that this (admittedly hasty and unscientific!) exercise reveals.

This simplistic map of my listening hours reveals far more about me than I care to admit.

When I look over the map, I see the ghosts of past selves. Versions of me with different goals, algorithmic filter bubbles³, even different accents.

The first time I became aware of this force, my parents asked me why I was talking strangely. I realized that I had subconsciously acquired Merlin Mann's humor… and his vocal ticks… through endless hours of Macbreak Weekly and other podcasts.

Regardless of who I claim to be my hero, my influences, my preachers… what I've learned is that whoever I allow to speak the most has the most influence on my life.

In a Girardian sense… these voices mediate my desires and mold me into what I aspire to be. This can be a good thing, and this can be a bad thing. Terrifyingly, this is a very invisible thing. If the hours spent listening don't have a huge emotional impact, we can be quietly shaped without even feeling the water boil around us.

It’s said that we are the cross section of our five closest friends… I’d rephrase that to say our five most listened to humans. I challenge you to take a similar exercise: working backwards from today, whose voice have you heard the most in each year? Not the most "impactful," we are looking for sheer count of hours.

I'm still processing the suddent deletion of half my brain, but I am confident that it's the right moment and I'm excited about what will come next. I'm contemplating what skillset in which I wish to invest in this new stage of my career: do I stay in UX/Product, or re-visit my software engineering roots?

At this point, I want to work on meaningful products with nice people. 🤷 If you've been reading this for any length of time, you probably have a good idea of what drives me… probably better than the portfolio and resume that I ought to be updating right now.

If you have advice for handling this season, resume tips and tricks, or potential opportunities, I'd love to hear from you. Please shoot me an email.

Jujutsu is a new VCS built on-top of git. It's worth looking into if you…

• craft careful commits to form a good story because you know spelunking is hard.
• manage long-running dev branches, -rerere rebases, or octopus merges.
• are curious about what might come after git.
• just like neat things 🤷
• are a rustacean. 🦀

I'm not yet a rustacean, but all the others have been part of my life for more than a decade (except octopus merges. I've only had to do that once or twice!)

While I'm reeling from deleting some of the aliases that formed that git muscle memory (and learning new things while I do!) I've been learning about Jujutsu. Jujutsu first came to my attention when my git mentor Tom Miller raved about it¹. It came back when Chris Krycho posted his amazing writeup and also emailed me that it could solve some of my stranger git problems.

I played with it a year ago, and I immediately hated what it did to my local git repo:

…avers.com ! via  v3.2.1 via  impure (nix-shell-env) 󱗆 wtno | Working on the article took 13s
❯ git log --all --graph --oneline
* 86395da2 Working on the article
| * 5f73e7af
|/
| * 46a1cdba
|/
| * 50a93636
|/
* 0e9cb805 (HEAD, origin/draft) Drafting Wrestling with Jujutsu
| * cb863a74
|/
| * 3dee836c
|/
| * 7544ddc8
|/
* c0d593aa (origin/master, origin/HEAD, master) Remove lfs from actions
* c87a0994 unlfs
| * 2da3e478
|/
| * 2c58fe5f
|/
* ba8fec6b Remove lfs
* f9beb3fc Disable watcher so I don't have to type that again
| * 27e3fab0
|/
| * 2488ea80
|/
* a100e216 Typos

The reason for all these anonymous commits is jj's amazing jj undo. Every operation can be completely undone, and you can do even more with jj op.

Here's what jj log displays:

@  wtnowmoz evantravers@gmail.com 2025-05-04 17:32:28 86395da2
│  Working on the article
◆  zorywspm evantravers@gmail.com 2025-05-04 13:11:22 draft@origin git_head() 0e9cb805
│  Drafting Wrestling with Jujutsu
◆  wzonpurk evantravers@gmail.com 2025-05-04 09:05:35 master c0d593aa
│  Remove lfs from actions
~

jj log's default behavior is to only show you currently mutable working trees… which are basically various heads you have available. Everything else is considered immutable. You can rewrite it easily, but it's hidden from you to prevent you causing conflicts with other remote branches.

After some prompting I've been easing back into it and am really enjoying it this time. Playing with jujutsu feels very similar to playing with Helix: the muscle memory changes make "easy" actions frustrating, but the new mental model makes "impossible" tasks super easy.

All that to say, I'm having a grand time.

There are amazing resources out there for anyone interested in learning more, but here's a few tips that helped me as a novice wrestler:

• as I said before, jj log by default only shows you "mutable" changes, which if you have no outstanding branches is basically just your current git staging². These changes are essentially your current "workbench," so as you work with the tool it feels more natural and git's "full history" feels heavy-handed, but it's confusing at first.
• jj describe is available at point in your development workflow. You can jj describe your intention at the start of a change, or jj describe what you actually wrote at the end. Very forgiving, especially with jj split letting you take a patch and move it to a new change³.

…

I'm enjoying the learning process and using it daily on my blog and dotfiles the past week or so. As an individual software craftsperson, I like the freedom to explore the problem and not feel the pressure "oh I can't handle that in this commit, I'll need to handle it in another commit" because I can just jj split.

If I was doing release management, I'd really like its revision/merge management for handling complex rebases. I think it'd be really nice for some of the problems I used to face running long development branches.

Check it out!

References

• jj init - Chris Krycho
• Steve's Jujutsu Tutorial - Steve Klabnik
• What I've Learned From Jujutsu - zerowidth
• jj Tips and Tricks

Years ago, I worked in advertising. In those days, it was common to have six to ten projects "open" at once—two in active development but others in a constant stream of small post-launch tweaks.

To keep things organized, I had a little bash script called tspace. I'm fairly certain Tom wrote it, but it used fasd to navigate to a directory, run tspace, and be set up.

In jobs following, I either worked on only one repo, or none at all. I haven't needed robust tmux session management for years, but the number of my personal repos has crept up to where I found myself frustrated at how often I ran the following commands:

1. Make new session
2. Navigate to highly used folder
3. Name session after folder

I had started using zoxide for "smart cd" (fasd is no longer in development) but I still wanted to close the gap.

I found two solutions: tmux-session-wizard is a one-click solution that adds almost no bulk to your config. Dead simple.

I'm presently trying sesh. Sesh is wildly configurable… but I'm using none of it. Sesh has the extra power of multiple interfaces (even a Raycast plugin!) and the ability to run commands on workspace launch… but I don't need that at the moment. direnv currently sets up the environment in the folder.

For many of you, this is old hat… but for anyone who hasn't set up a script like this: it's really pleasant.

I had been feeling some friction: my folder/file organization smelled bad. There was a bunch of ../.././config… style paths that felt gross. I had files in folders by themselves like nvim/default.nix that made it hard to file find and was weird. Most importantly, I didn't really feel like I understood how it actually worked.

@mitchellh is very smart.

I found github:mitchellh/nixos-config I spent a fair amount of time reading through his config… pretty much assuming that the author of ghostty made all decisions intentionally and wisely. (It was a good assumption! He's been writing nix for long time.) His config is simple and clear. I did learn quite a bit, and accepted a lot of his decisions. I don't think I was using the home-manager settings for global and user packages before, I think that's speeding up builds.

Friendship ended with git reset --soft Now git commit --fixup is my best friend

While rewriting my WIP pile to be intelligent commits using my trusty git reset <sha> --soft I discovered a wonderful git tool I didn't know about: git commit --fixup=<sha> and git rebase --autosquash <sha>^1 lets you take the current staged change and effectively git commit --amend anywhere back in history. Y'all. The number of times I've git reset --soft HEAD^3 just to add something to previous commit #2? Oh my goodness. 🙌

vibe-coding works… inexplicably... until it doesn't

I tried a lot of vibe-coding via claude.ai. I used a snippet I found on stackoverflow of tail -n +1 **/*.nix | pbcopy to throw every nix file into a chat, and that produced much more effective results than my previous attempts of pasting isolated snippets. I got successfully running code… that was unreadable, not concise, and downright wrong in some places. I mostly used AI to get the code compiling, then while untangling the syntax jungle I would read the docs and find the right way to do it.

After vibing and copying from @mitchellh, I finally felt I can read and understand my nix config except for three dastardly lines. Originally, @mitchellh was using:

home-manager.users.${user} = import userHMConfig {
    isWSL = isWSL;
    inputs = inputs;
};

But that threw errors with my darwin-nix config… I imagine because I'm using more features in mine? Unsure.

Claude's vibe-coding suggested conflicting solutions.To fix nix-darwin not having inputs, claude suggested this.

home-manager.extraSpecialArgs = { inherit inputs; };

That worked for darwin, but broke nixos. Nixos's home-manager complained about not seeing lib, so Claude suggested this crazy thing:

home-manager.users.${user} = { pkgs, lib, ... }: import userHMConfig {
    inherit pkgs lib inputs isWSL;
};

(I'm having a hard time reading that… a function that takes pkgs, lib, etc., and imports my home-manager file, passing an attribute set that inherits pkgs, lib, inputs, isWSL from the surrounding scope? Is that needed?)

We vibing. 🤷

Voltroning the two solutions together worked, but I don't know why. It smelled bad. Eventually I read home-manager's documentation, understood that it only wants parameters passed through extraSpecialArgs and wrote:

home-manager.users.${user} = import userHMConfig;
home-manager.extraSpecialArgs = { inherit inputs; };

Vibe coding works… yes? Was it mostest correct? No.

How about speed? I ran three runs on each commit, trying to make sure I filled any caching systems and minimized network costs.

Before (git checkout c06716e, changing wsl.defaultUser to avoid exploding my system again):

dotfiles on  HEAD (c06716e) ! took 7s
❯ time sudo nixos-rebuild switch --flake ./
warning: Git tree '/home/evantravers/src/github.com/evantravers/dotfiles' is dirty
building the system configuration...
warning: Git tree '/home/evantravers/src/github.com/evantravers/dotfiles' is dirty
activating the configuration...
setting up /run/booted-system...
setting up /etc...
setting up /bin...
setting up /bin/login...
setting up /sbin/init shim...
reloading user units for root...
reloading user units for evantravers...
restarting sysinit-reactivation.target
Done. The new configuration is /nix/store/3rasc0zq4vbkhy5iajs150ihlbd4mlwh-nixos-system-nixos-25.05.20250403.2bfc080

________________________________________________________
Executed in    7.21 secs      fish           external
   usr time    1.28 millis  188.00 micros    1.09 millis
   sys time    6.80 millis  188.00 micros    6.61 millis

After:

dotfiles
❯ time sudo nixos-rebuild switch --flake ./#wsl
building the system configuration...
activating the configuration...
setting up /run/booted-system...
setting up /etc...
setting up /bin...
setting up /bin/login...
setting up /sbin/init shim...
reloading user units for root...
reloading user units for evantravers...
restarting sysinit-reactivation.target

________________________________________________________
Executed in    1.73 secs      fish           external
   usr time    4.30 millis  149.00 micros    4.15 millis
   sys time    0.02 millis   19.00 micros    0.00 millis

Not bad! I haven't done any A/B testing, but I'm willing to bet most of that is the home-manager.useGlobalPkgs = true and home-manager.useUserPackages = true settings my previous setup was ignoring. The speed is great, but the real win is learning more about the nix language and how it all fits together... if only by fixing vibed code.

I rather think much of my code career going forward is going to have "improving vibecode" as a theme.

Random Stuff:

• If you change your wsl.defaultUser on the system that you are developing on, and run that nixos-rebuild switch, you are going to have A Bad Time(TM). I had some flashbacks to trying Ubuntu for the first time when I was a kid. I wanted that compiz wobbly windows stuff so bad and jacked up my graphics settings so many times. Probably the reason that I'm willing to put up with Nix now.
• I discovered that my wezterm -> tmux setup on WSL was reliant on some .terminfo file I'd downloaded long ago. While reading through the wezterm nix code, I discovered that wezterm helpfully passes it's terminfo as a passthru so you can just use pkgs.wezterm.terminfo. I'm using that on wsl because ghostty isn't on windows yet. 

This is all very funny and plays to Sherlock's vanity, but Lestrade has an actual job to do. Lestrade is not here for the joy of the sport… he actually has to collar the criminal in the conclusion.

I want to be Sherlock, but I often find myself playing the role of Lestrade. Like Lestrade I straddle the double diamond² of problem definition (evaluating the crime scene) and execution (arresting the murderer.) If your work domain connects definition and execution you are liable to become a Lestrade.

Whether in the gaslit streets of Victorian London or in a remote office, handoffs are costly. I see the Lestrade Effect often in emergency or experimental product design: When UX is not in the room in for early customer conversations where user needs are discovered then stakeholders (often Product and Marketing) can hand off User Stories to the UX team. The UX practitioners now must play Lestrade: repeating the same questions, making the same discoveries: who is the customer, what is the value of this decision, why did we decide this, etc.

If your friendly neighborhood UX practitioner is asking you questions that you (frustratingly!) have already asked and answered… it is possible that you have inadvertently cast them as Lestrade and not included them in the first analysis.

Be insightful as Sherlock, but be considerate like Watson. Include everyone in the room when the problem is being discovered… or risk leaving colleagues trailing behind.

I've wanted to use my keyboards outside for a little bit. The seed of the idea was struggling to work with my mobile office in a "workspace" at an airbnb with only a couple inches of countertop at a very uncomfy height.

What if I could just bring my desk with me?

I experimented with just buying a laptop/projector tray and sticking it on a lightstand I had lying around. Very wobbly.

I eventually found the Intention Design Tripod Table. While there are other options¹, the Intention Design offering is a pretty safe bet for those who want to stand outside and work on their computer.

I'm pretty sure that the tripod Intention Uses is 99% identical to this smallrig option on amazon. If you are mechanically inclined, you could install a tripod socket in a butcher block or cutting board and build your own for about 50% the cost.

Intention offers a keyboard tray, but I opted to build a weird little arm thing using SmallRig parts:

• SmallRig Super Clamp to attach to the tripod body
• NiceyRig 2.5" rod for a little bit of standoff
• 2x SmallRig Universal Magic Arms with Small Ballhead creating articulation between 2.5" rod and Cheeseplate, and articulation between Cheeseplate and Magsafe disks
• SmallRig Cheese Plate mounting to space out the split keyboard sides
• SmallRig 1/4" to 1/4" adapters for the rods
• Minifocus Magsafe Adapter to mount to my existing Magsafe Enabled keyboards

Mounting the keyboard at a tented neutral arm position does create a little bounce in the laptop, but not much more than a normal-ish desk. I've thought about putting some hanging weights to counter this motion, but haven't played with it yet.

I honestly haven't figured out a good pointing device solution here yet. I will likely buy a cheap trackpad and put a magsafe disk on the back. I'd like to tripod mount my Bitra Trackball, but as they seem to have stopped making them, I don't want to risk destroying it. For now I'm using a combo of Homerow.app and ZMK's pointing devices, I already have a lot of practice just using the keyboard.. I can't really design on it, but it's a great focus writing setup.

The formwork and the concrete pour both require skills and craft. Both are connected to the final bridge.

therpf.com¹ is a community obsessed with the production design of objects inhabiting the worlds of film. Screen-used Lightsabers, Voight-Kampff tests, Tricorders and more are studied, screengrabbed, and discussed. Screen-used props are divided into two categories: incredibly detailed "hero props" for closeups, and rubberized stunt props for action sequences.

The hero prop sets up the world, the stunt version sells the story.

Brad Frost has talked about Minimum Viable Artifact for a while: Minimum Viable Artifacts are the least amount of work required to communicate.

The plywood formwork is a Minimum Viable Artifact. So is the stunt prop. The hero prop has far more detail, but just enough to tell the story. The lightsaber hilt, made of microphone mounts and greebles, can't actually cut through metal… but we believe that Luke is a jedi.

A Minimum Viable Artifact carries enough detail and craft to serve the outcome: a pour for a bridge, or a close-up of the hero's armament… and no more². While there is a joy to craft and skill, it should be in service of a goal.

Otherwise we spend our life on expensive artisanal plywood forms and build no bridges.

Last month Jesse texted me:

After invoking the mode Raycast Focus provides a lovely little timer with your stated goal and uses Screentime to block apps and websites in every browser.

It's almost exactly what I built as Hammerspoon Headspace. only missing the Toggl timer integration and the ability to save preset "focus" presets. I had been working on my version of this, but their implementation is so good.

I think it's possible that with their arguments system you might be able to pass presets to the Focus system, and that would let me integrated it into my shortcut-based Headspaces. I just haven't decoded their JSON yet.

As it is, if you are the kind of person who was interested in Headspace but really only wanted one focus mode for your deep work: this is an amazing free tool that you really should try.

I wanted a calm device to reduce my screentime. A "calm device" for me means minimal notifications, no hyper stimulant applications, and even no browser. Simply reading and writing.

There have been a wealth of new e-ink devices¹ in the past year. While I would like to replace my distracting iPhone outright, I use my phone for my webcam. As the new Boox Palma 2 has just released, I bought a used refurbished Palma on ebay for just over the price of a Kindle.

The Palma works ok out of the box but it only shines after nerding out on configuration. There is a whole custom subsystem just for handling how monochrome e-ink renders the underlying colors. Some apps display such that you can't see the scroll bar on Android 14, so they are very hard to configure. It is not an easy software package to love.

But I do.

Here's what I did to set up my Palma:

Niagara Launcher

For maximum minimalism: bigger sans-serif font, minimal icons, hiding status and notifications bar.

Gboard

The default keyboard is good, Gboard is much better: swipe to type, great dictation support. I am really liking dictating notes while I read physical books.

Obsidian

Let's be honest, I just wanted a kindle that ran Obsidian.

I've got the light mode theme of Minimal Theme set to their e-ink setting, and it works well. I do wish that I could set the theme or theme settings per device easily.

Kindle

The Kindle.app just works. The only wrinkle is that unlike all the other apps, you need to set the hardware buttons to be volume buttons, and use Kindle's settings to turn the page with the volume keys.

Olive Tree

I have set Olive Tree to scroll the page using the physical buttons. There's an in-app setting to keep the device from sleeping while up front, which means I never have to do the "stay awake" tap during the whole sermon.

Bible by Youversion

I don't love the social network aspects, but it's the best for reading plans, and I'm enjoying going through a reading plan with my small group.

KOReader

I don't have much content to read here, but there's a system that allows it to sync to a calibre library over wifi and that's nifty.

Instapaper

I switched back² to the first read later app I ever loved, and it's still great. I abandoned it only because I believed I wanted unlimited API access.

The device is comfy to hold. Not too heavy. The screen is clear enough, I tend to run it 100% warm and with the lowest backlight. I get a couple days battery life out of it. Maybe a week.

The official folio case is not amazing. The magnetic clasp is right in the way of the volume buttons that I use for "turn page," and once a day the cover jams the button and flips madly through the book like a runaway train. I actually like that it's too big for a pocket - this forces me to put it down. It certainly does not hurt that I can prop it up for writerdeck roles.

Since buying the device, I've already finished two digital books and 70% of a physical book, so the experiment is a success. Turns out having a reading-specific device is increasing my reading, imagine that.

Thanks to Matt's post, I think I've finally got webmentions automated, which is lovely. Thanks Matt!

This blog's comments are powered by Webmentions - steele.blue

When something precious to us is threatened we impulsively check on it. Some scriptures trigger that reflex on our most precious possession: our salvation.

Hebrews 6:4-8 triggers this reaction in me especially the words "who [...] have tasted the heavenly gift, and have shared in the Holy Spirit, [...] and then have fallen away." (Hebrews 6:4-8, ESV, emphasis mine)

This passage summons disquieting emotions. However, that instinctual "have I still got it?" is but a confirmation of the preciousness of the salvation which we already have been given. The tourist pats his pocket because there is something precious within.

If we had nothing to treasure, if we were still dead in our sins… we would not have the instinct to check and protect. Be encouraged.

For the past month, and through the last quarterly review and planning of 2025, I've been using Obsidian Tasks instead of my trusty Things.app, and I am very happy.

Obsidian Tasks lets me manage my tasks in the context of my work. It lets me fully customize how and where tasks are stored and presented, allowing for flexible and focused workflows.

It's also very nerdy.

I was hard pressed to choose a successor to Things. For me it came down to taskwarrior, Todoist, Bullet Journal, and Obsidian Tasks.

I chose Obsidian Tasks for a few reasons:

• I do all my writing and thinking, journaling and rituals in Obsidian. I found myself constantly linking back and forth from Things to Obsidian, or wrestling with where to store the notes and context.
• I have become project-list focused during my workday. I wanted a kanban to manage lots of projects, and I can easily do that in Obsidian.

There are downsides I'm willing to accept:

• Slower performance. It's honestly surprising how fast it is considering what it is doing, but sluggish compared to Things.app. I do notice it especially in search.
• It's yet another task format, when there is already orgmode, todo.txt, and taskpaper. I believe I understand the Dataview-driven decision, but I do wish it used a known format for attributes.
• I don't think I'll be able to easily put time blocked tasks on my calendar like I can with Reminders or Todoist. Since I tend to assign a project to a day, this is ok.
• Push Notifications with Obsidian are hard or impossible. I don't rely on as many notifications and nudges¹ for project work. For general scheduling, I have my Daily Note.

A quick overview of what I've done since I began thinking about it a year ago:

1. I investigated Obsidian Tasks, choosing plaintext over emoji, and seeing if it had the ability to do what I wanted.
2. I removed old instances of - [ ] from my markdown repo to "clean it up".
3. Six months ago, I disabled the quick capture shortcut from my phone and started just using Drafts for all capture.
4. 3 months ago I developed a Things -> Obsidian Tasks export, first in Shortcuts and then thankfully in ruby.
5. I hacked on Obsidian Tasks queries to mirror the screens in Things.app that ran my life.
6. Two month ago, I moved the Nudges to Reminders, and finally the Things and Obsidian experience converged.
7. One month ago, I ran the export for the last time, changed my keyboard shortcuts for capture to a new custom shortcut, and since then I've been 100% using Obsidian for tasks.
8. I've continued to write some new views, merge my ritual documents with their datasources, and discover new powerful workflows.

Configuration and Import

I tried writing this in Shortcuts, but I ended up with the structure I had written for orgmode and taskwarrior and just used JXA. Much easier.

There are a lot of different ways you could configure Obsidian Tasks, but I made a couple executive decisions:

• I prefer readable plaintext. I chose the Dataview format rather than the default Emoji format.
• I imported files that corresponded to the Areas and Projects lists in Things into projects folder.
• I wrote conversions to let tags import well.

I also spent some time going through my wiki repo, cleaning up wherever - [ ] appeared. I chose to represent every - [ ] checkbox as a task, and not use the - [ ] #task form. I like the simplicity.

While I was trialing the import I developed Obsidian "views" that corresponded to the screens in Things. I kept tweaking them until they consistently matched their corresponding Things.app views.

Obsidian Templates

Obsidian Tasks lets you create custom blocks using either a SQL-style language or javascript. Assuming you've made similar configuration decisions in your repo, here are the Things.app-style queries that drive my current Task Management system, although it's still evolving:

Inbox

(Literally just a file named Inbox. 🤷)

Today

I used to visit Today daily to see what I had assigned for that day.

> [!warning]+ Overdue
> ```tasks
> not done
> ((starts before tomorrow) AND (has start date)) OR (due before today)
> ```

```tasks
not done
((scheduled on today) OR (scheduled before today)) OR ((starts before tomorrow) AND (has start date)) OR (due today)
```

I am finding that I use Today less as I have pushed some of the actions I once performed on it into Daily Plan.

Tomorrow

```tasks
not done
scheduled before tomorrow
```

Workday Todos

> [!error]- High Energy
> ```tasks
> not done
> tags include High
> filter by function task.file.property('tags').includes('#Areas/Work')
> filter by function !task.file.hasProperty('status') || task.file.property('status') == "In Progress"
> ```

> [!tip]- Low Energy
> ```tasks
> not done
> tags include Low
> filter by function task.file.property('tags').includes('#Areas/Work')
> filter by function !task.file.hasProperty('status') || task.file.property('status') == "In Progress"
> ```

> [!attention]- Long Estimates
> ```tasks
> not done
> tags include 4h
> filter by function task.file.property('tags').includes('#Areas/Work')
> filter by function !task.file.hasProperty('status') || task.file.property('status') == "In Progress"
> ```

> [!todo]- Quick Wins
> ```tasks
> not done
> tags include 30m
> filter by function task.file.property('tags').includes('#Areas/Work')
> ```
```tasks
not done
filter by function task.file.property('tags').includes('#Areas/Work')
filter by function !task.file.hasProperty('status') || task.file.property('status') == "In Progress"
group by function task.filename
path does not include Wishlist
```

Upcoming

```tasks
not done
has scheduled date
group by function task.scheduled.format("MMM Y")
sort by scheduled date
```

Deadlines

```tasks
not done
has due date
group by function task.due.format("MMMM")
sort by due date
```

Anytime

```tasks
not done
no scheduled date
no due date
filter by function task.file.property('status') == "In Progress"
folder does not include booknotes
group by path
```

Someday

```tasks
not done
group by path
tag include Someday
```

Quick Capture

While I thought I had weaned myself from using Things.app'a quick capture, I quickly missed having that power. So I whipped up a custom Shortcut and bound it to the same keys. It's not as good… but in some ways it's better.

I used Claude.ai to generate some of the AppleScript blocks, then I fixed them in Script Editor.

Firefox is the bane of my Quick Capture existence. I may try running Hammerspoon Lua eventually.

Obsidian Kanban to Obsidian Projects

<figcaption>
    <p>
        All a "project" is a note with the tag `#project`. So I can have
        lists of tasks, a home repair, or an upcoming essay or blog post.
    </p>
</figcaption>

I started² using Obsidian Projects because it lets me populate the board's based on a tag. Think of it as a pre-made fancy Dataview view, it's not a real file. This causes some inconsistencies in the system, but it serves my needs well. I do wish it was just plaintext, but I don't see how.

I have mine set to be columns based a status property. When I drag between columns, it updates the property.

I like Kanban as a way to visualize the intensity of my commitments. I missed that in Things.app, and it's part of what drove me to try this experiment.³

Neat Things I Didn't Expect

Dedicated "Views"

I built a custom view for workday tasks:

> [!error]- High Energy
> ```tasks
> not done
> tags include High
> filter by function task.file.property('tags').includes('#Areas/Work')
> filter by function !task.file.hasProperty('status') || task.file.property('status') == "In Progress"
> ```

> [!tip]- Low Energy
> ```tasks
> not done
> tags include Low
> filter by function task.file.property('tags').includes('#Areas/Work')
> filter by function !task.file.hasProperty('status') || task.file.property('status') == "In Progress"
> ```

> [!attention]- Long Estimates
> ```tasks
> not done
> tags include 4h
> filter by function task.file.property('tags').includes('#Areas/Work')
> filter by function !task.file.hasProperty('status') || task.file.property('status') == "In Progress"
> ```

> [!todo]- Quick Wins
> ```tasks
> not done
> tags include 30m
> filter by function task.file.property('tags').includes('#Areas/Work')
> ```

```tasks
not done
filter by function task.file.property('tags').includes('#Areas/Work')
filter by function !task.file.hasProperty('status') || task.file.property('status') == "In Progress"
group by function task.filename
path does not include Wishlist
```

This only shows tasks for In Progress projects because of the line task.file.property('status') == "In Progress". If I drag the parent Project to "Done" or "Blocked," child tasks disappear like magic. I love this.

In Things.app, the closest thing I had to dedicated Views was to save a URL that contained tags I wanted to search for: Work and High Focus. Obsidian Tasks lets me dataview query all kinds of interesting and custom views.

One neat one (inspired by bookworm) is "action items from books I've read":

Another is being able to show child projects of an "Area" style project:

Obsidian's tooling and plugins allows for even more creative custom UIs… I could embed a set of views into a Canvas for a productivity dashboard if I wanted to!

Reducing Ritual Friction

I've been using this same power in my daily rituals.

<figcaption>
    <p>
        Here, the question of "protect the essential" tasks of the day is made easier by filtering today's list to just `#Focus/High` and tasks with elevated priority.
    </p>
    <p>
        I've been abusing Obisidan's <a href="https://help.obsidian.md/Editing+and+formatting/Callouts">callouts</a> system to hide the extra filters so it's not overwhelming.
    </p>
</figcaption>

My rituals are typically prompts and questions like "what projects have we scheduled for this month" or "what questions should you ask your spouse?" Before, I'd read the prompt and then go find the answer in the system by searching projects by scheduled date or tasks tagged "Wife." With Obsidian Tasks, I can embed those custom views right into the ritual.

- ❓ Any questions to answer?

> [!question]- Questions for Wife
> ```tasks
> not done
> tags includes Family
> group by path
> ```

This has been a game-changer… much less app-switching when I'm trying to just plan the week with my wife.

Power of Plaintext

Because Obsidian Tasks is all plaintext… there's just so much that's possible:

• You can search for todos natively in Obsidian using task:<string> or even task-todo:<string> for uncompleted todos.
• I can filter tasks to only projects marked "In Progress" in my kanban: filter by function !task.file.hasProperty('status') || task.file.property('status') == "In Progress"
• Any note can become a project on the Kanban… this blog post is a project right now.
• I can leave # FIXME style tasks on any writing project anywhere in my notes, and they show up in my task lists. This post had - [ ] tasks all over it while I worked on it.
• I love being able to combine documentation and todos. I now have documents for my vehicles containing both a log of repairs, and tasks for what to do next.

Some useful plugins that I've found helpful:

• TextTransporter let's me push a line to another file. It's not as good as orgmode's refile action, but it's close. Super handy for processing the Inbox into project lists. I have some of the TT actions under Leader Key plugin under ⌘+.
• Outliner has some shortcuts for moving around bullet points that makes reordering a task nice
• Omnisearch makes searching much faster.

…

Obsidian Tasks is definitely not for everybody, but it is for me. Who else might it be for?

• spiritual folks who want to include quotes among their task system to remember a higher calling.
• writers who spend a lot of times deep in a document, and want their tasks to link to a place in that document.
• people who stare longingly at orgmode and want something approachable and mobile friendly.

I'm delighted. I have a system that is free and flexible, on all my devices. It lives among my writing and my work, and can be summoned to appear magically among my rituals documents for minimal friction. I can make custom and detailed overviews. And it's still growing.

Recently someone at work said "people around here use the ellipsis a lot." (I smiled, and nodded, knowing that that almost certainly meant me.)

Then they added… "and to me an ellipsis always means stress and anger."

I was horrified.

I've used an ellipsis… (steps away to count using rg and vim) 1,317 times on my blog. Have I been threatening y'all?!

I honestly don't know what to do. I have always loved the ellipsis as a pause, to represent my internal self-conscious search for the right words.¹ I believe that I picked this up from dialog in novels I loved². (I'll probably dig into my bookshelf to see which ones used the device.) It was there that I picked up the belief that … meant a gap in racing thoughts, a self-conscious and humble admission that the right words do not come easy to me.

The wikipedia article calls using an ellipsis at the end of a sentence as Aposiopesis as "is the use of an ellipsis to trail off into silence." It's associated with strong emotion like fury or modesty.

For me it's mostly been modesty.

Now I find that my intended humility is read as… dismissive. It's very associated with boomers and older.³

For those to whom I have miscommunicated since I discovered that ⌥-; sends the … character: please forgive me. It was done unintentionally.

I'm probably going to attempt to erase it from my daily work text communication. I'm not going to stop using it in my personal writing. It's become part of my voice that I like… and it'd be hard to erase that.

So…

Chad reflects on his own journey through sin and exile, how he previously upheld a standard of perfection through choosy reading of the OT, and how he learned to see God at the center of redemption, not his own repentance or penance.

This honestly heartbreaking and uplifting personal story was one of the books the Lord used in my heart this year to help me understand forgiveness, and how I foolishly refuse to accept it.

Stepping Up by Dennis Rainey

Using examples from history and scripture, Rainey argues that the masculine virtue is courage and walks through a man's life examining the areas where we are tempted to retreat vs. the Godly calling to step up.

The mentality of taking initiative, of "stepping up" is very convicting to me. Rainey argues successfully that it's the essential godly masculine trait, and one I fail at constantly. I need to revisit the ten questions from the Courage chapter. While I would have preferred less movie-references and more scripture, this book did leave a mark on my thoughts.

Slow Productivity by Cal Newport

Aligning himself with a larger movement, Cal argues for a historically-based and more intentional method of productivity: work at a natural pace. Don't succumb to the cult of busyness.

I've read and heard so much about the arguments of this book that it wasn't as revolutionary to me, but I do want all my future managers to be familiar with the ideas. I've been thinking a lot about how I could construct a "Pull Work" environment for my team.

Rejoice and Tremble by Michael Reeves

Dismantling unbiblical perspectives on the Fear of God, Reeves works through scripture and Puritan writings to show that Godly fear is indeed fear of the beauty and goodness of God, knowing him as creator and redeemer.

If Isaiah 11:3 represents Jesus as having the Fear of the Lord, then it can neither mean "being afraid" nor can this fear be the opposite of love… then what is it?

Excellent book. I will reread this year most likely.

The Demon of Unrest by Erik Larson

Chronicling the time between Lincoln's election and the Firing on Fort Sumpter, Larson weaves together different diaries and letters to show how miscommunication and lack of leadership laid the fuel for the fire of Civil War.

I love most of Larson's works, and this is no exception. There are some broken men and women in this story, and hard facts of history. Larson himself admits not being impartial here, and honestly loathes aspects of southern culture, including religion, that makes some of his judgements hard to swallow. Still a good read.

Brave New Words by Salman Khan

As a lifelong tutor, Khan makes the techno-optimist case that Generative AI could be prompted to be the tutor for every student in the world.

Admitting his The Diamond Age influence, Khan discusses and "demos" his Khanmigo tutor for everybody. At the very end he stops assuming Dewey-istic mass education and rethinks how education could work with such tech, but most of the book is about band-aiding existing educational problems rather than other approaches. A must-read for anyone in ed-tech.

Moonbound by Robin Sloan

A boy feels that his life must be more than his humble village, under neath the dragon's moon.

Imaginative and joyful. An interesting take on intelligence and story.

The Common Rule by Justin Whitmel Earley

If our habits our build our lives, then distinctly Christian lives should have distinctly Christian habits.

Working from personal experience with Burnout, Justin presents 8 habits to create margin, and a different way of living.

Nearly the same origin story as How To Calm Your Mind by Chris Bailey, but from a christian perspective. Just argues eloquently that habits form our hearts, so we should choose our habits wisely. I love the Habit of Failure and Formation: How we "get back up" is more important than how we fall.

Continued logically to children in Habits of The Household.

Just Enough Research by Erika Hall

Collection of useful advice for practical research.

I was convicted at some of the areas where I fall short here. One practical and simple one that kicked me hard was: use finite words for problem statements. Don't say "understand" or "explore," instead try "describe" or "identify."

A Neglected Grace by Jason Helopoulos3

Family worship follows the Regulative Principle and ideally should include the word, prayer, and singing. It falls upon the father as a joyful responsibility.

This inspired me to start reading through whole books of the Bible, and to try singing some hymns with the kids.

Personal Socrates by Marc Champagne

An interviewer profiles curious humans and the central questions that drove their lives.

While I struggled with some of the profiles (I'm not a fan of astrology) some of the questions hit me hard. I've broken them out into a file that I can revisit periodically during my rituals.

A Swim in a Pond in the Rain by George Saunders

A writing instructor condenses his favorite class on Russian short-literature sharing some thoughts on how to craft fiction, and how it in turn transforms us.

This is not an easy read, but worthy. Some of the exercises Saunders takes the reader through causes a greater awareness of how reading fiction affects us, and the intuition and science of writing, including one of my favorite descriptions:

We can reduce all of writing to this: we read a line, have a reaction to it, trust (accept) that reaction, and do something in response, instantaneously, by intuition.

That's it. Over and over.

A System for Writing by Bob Doto

A zettelkasten tinkerer summarizes constructing and using a zettelkasten as a creativity system.

A concise and helpful description of a proper analog or digital zettelkasten. While I was familiar with much of the language, this finally helped it all click. The power of Doto's arguments is such that I'm tempted to try folgezettel alphanumeric IDs, I'm envious of the dimensions of proximity and depth that it adds.

The theme going into 2024 was "Own Up." In 2023 "Wake Up" was part of revealing some areas that needed improving, and Own Up represented taking ownership of that and being intentional. It's largely guided my headspace and has been helpful.

Spiritual Life

While this is always an area I feel I could improve, the real story is not what I have done, but what God is doing in me.

Through a series of messages, books, conversations, and counseling God has been quietly dismantling my legalistic heart into one that quietly abides. When I am trusting in my own righteousness I refuse to be comforted, and feel like I have to "get back on the path" in my own strength. This never ends well. Jesus showed me a little of what it means to be loved from before I even sinned, and that feeling of His love has lasted. There is still much to wrestle through, but I know He will carry to completion what He has began.

I sporadically journaled my QT reading and praying, and that brought a little more intentionality and structure to my quiet time. I'm also trying to put another moment of prayer and the Word in the afternoon. Toddler-filled mornings often swallow my morning quiet-time. This is helping so far.

Inspired by a godly friend and upheld by the Lord, we've had a consistently restarted family worship. Hearing the kids sing Christmas Carols at the tops of their lungs has been a wonderful temporal reward to months of patiently asking them to "please come back to the table and let daddy finish reading this."

I'm trying to pay more attention to what God is doing, so my quarterly reviews now prominently feature answers to prayer that I know about. A quick scan showed around 40ish. Awfully encouraging to go to my knees when I can easily remind myself that the Lord hears.

Relationships

I'm blessed by my wife. Best of wives, best of women.

I've been attempting to refocus my intentionality on our relationship. To that end I added a section to my daily and weekly journaling to notice what's going on her life. I'll likely extend this to the kids as well, especially as our older ones are getting big feelings and "story arcs" that last weeks.

I've also taken the kids on more "daily adventures," one of the privileges of homeschooling. Returning packages, getting haircuts, coworking at the coffeeshop, even career events. They seem to love it, it gets them out of the house for the wife, and car-ride questions are always a golden opportunity.

Health

I started this year ten pounds heavier than I should be. I did largely lose that weight and also gained some muscle.

I was working through a foot injury all year. After a year of PT, I can muster up a run once a week without pain which is such a blessing.

I also invested in some weights and a sports watch. Moving from bodyweight to a simple bench and dumbells has helped me reengage with workouts, and the watch has the dual purpose of helping me track sleep (which is improving!) and offering coaching and running workouts suggestions. I'm excited to see that compounding effect over time.

Creating

I'm still sketchnoting every sermon I hear.

I don't yet know what to do with these. I think having a "blog" here with a separate RSS feed makes the most sense, but I'm not sure.

This has been a quietly productive year. I did a lot of learning about nix, so that dominated a lot of my random coding time.

I touched 4000 files in my wiki this year, although I'm sure a lot of those were cleaning up my - [ ] tasks to get ready to use Obsidian Tasks as my task manager (more on that later!)

I just about tied last year with 51-ish¹ articles.

I'm proud of:

• On Augmented Reality
• Connected Bible Study in Obsidian
• Positions on Generative AI
• Making my Nvim Feel More Like Helix with Mini.nvim

Reading

I started 28 books this year, finishing 26. 7 fiction, 19 non-fiction. I still don't have a regular reading habit, it fits in-between other things.

Work

This has been a busy and chaotic year. I have a great team that I love to serve, and I have found encouragement measuring the effect of our UX Vision has had over the past five years.

I've started using FocusMate to create focused blocks of work, and I have enjoyed it. I've also switched back to doing some pomodoro blocks and have benefited from that too.

I'm excited to see what this year holds.

2025

As much as I am a fan of yearly themes, a new theme for 2025 has not emerged. To be honest, this holiday season has had less reflection time than I typically give myself, although I'm not sorry for how I spent it. Perhaps a phrase will reveal itself and resonate as we go through Plan Your Year this week.

May your 2025 be blessed. Happy New Year!

A personal system should change with you. While I sadly am not skilled enough to rescue my favorite jacket, I can adjust my productivity system to serve my needs.

I've been holding out for a while, ignoring some of the signs. It was scary to change something that's been working so well for so long. Eventually some of the friction has really started to bother me.

• Over the past five years my work has shifted to more writing.
• I'm often copying things out of Obsidian and linking back to context in Obsidian. (Booknotes action items, next steps for writing, etc.)
• I was grooming two different project boards: one for writing, another for the rest of my life. Everything but writing was winning… even though I say I value writing.
• I wanted badly to express a more nuanced view of Project state.. I found myself managing a Kanban in another app just to visualize it.
• I badly wanted a way to put tasks on my calendar.
• I'm doing more and more work on PC and Linux. It's frustrating to go power up an older Mac device just to see my tasks.
• I'm simply not using quick capture (Thing's best feature) less and less.¹
• I don't work out of the Things.app Today list. I copy big things to my bullet journal, and check in periodically, but I don't have it open in the second monitor.

While I've played around with other Task Managers before, around four months ago I started slowly planning to finally make the change.

Jobs to Be Done

I've realized there are two jobs that I've hired my task manager to do:

1. Manage and filter a series of project-esque lists.
2. Remember and Nudge: due dates or rituals.

I've currently split these up. I may live to regret it.

Two insights:

First, that neither require require constant browsing access. For managing, you just need to know a limited subset of "next things to do." For nudging, all you need is the reliable notification at the right moment.

Second: These "jobs" are highly modal. Almost all Nudges are recorded on phone on the go, and almost all Manage tasks are created from my laptop during the execution of a project.

I believe there is great value in having both these "jobs" live in the same system. I really wouldn't advocate for having separate systems. In fact, Things.app is really great at handling both jobs.

I'm particularly refactoring my Manage system, so for the moment I've broken out Nudging from Things.app into Reminders.app so that my normal machine of life can keep chugging. In addition, I was choosing between bullet journal and Obsidian Tasks, and neither of those are especially good at Nudging.

What Defines a "Nudge?"

This is really clear in my mind, but very hard to explain.

Everything that I define to be a nudge is an isolated² task that is only directly related on a true Start Date or Location.

(If you use Siri to create reminders, many of those "remind me to grab milk when I get home" or "remind me to take my pill every day at 8a" sort of things I would define to be a Nudge.)

I also moved my Rituals prompts to Reminders… and it's been great!

• Reminders is very good at notifications.³
• Inputting random items through Siri is very handy.
• I can share some of them with family through iCloud.
• Reminders directly supports a URL, so linking to a checklist in Obsidian (of course!) is easy.

While I intended this to be temporary system… it's working much better than I anticipated. I would advocate that most people should have all their tasks and nudges in one system, but this will work for now for me.

(Honestly, Reminders.app is now a "good enough" task manager for most people, especially if you add some apps or Shortcuts on top of it to make capture easier.)

Why Not Bullet Journal?

Honestly, with this division of jobs between manage and remember, I could easily give an analog system the job of Remembering. As it is, there were certain advantages I could see in using a digital system, but you could take that insight and run with it.

If you are customizing your system, make something that works the way you work. If you are a tmux-ninja who lives in his terminal, choose TaskWarrior. If you are trying to use grippy rather than slippy tools to help your burdened focus (or just love fountain pens!) choose Bullet Journal. If you just want Things + time blocking on your calendar, Todoist is winning the race.

I do lot of writing and thinking in plaintext markdown, and many of my tasks and "next actions" come from that activity. Embedding my tasks in the context that spawned them has a lot of value for me.

…

In the next post I'll detail how I set up Obsidian Tasks to feel familiar coming from Things.app, and the neat features and things I've found since switching.

a quick demo of how I edit my website with Obsidian 1.8

write in @obsdmd → auto-build jekyll → preview local site in web viewer tab → push to github → auto-deploy to live site

I've been making websites for twenty five years, and this is by far the nicest it's ever been pic.twitter.com/Dlw7Iorxop

— kepano (@kepano) December 19, 2024

Fantastic.

I've got a lot of technical debt: A 2GB+ blog repo (images I haven't been able to scrub from history), but I want to maintain the history to preserve my changelogs. Which history would have to disappear? My wiki and changes, or my blog's truthfulness and accountability? Ugh!

I complained, and Chris Krycho and Jonathan Creekmore kindly reached out separately with solutions. Thank you gentlemen! 🙏

• git merge --allow-unrelated-histories let's you take two separate histories and merge them.
• git filter-repo lets you do some big changes to a repository.

(To be fair, Krycho was pointing out that this would be even easier in jujutsu, but more on that later. 😂)

What I Did

Now inspired… I got hacking. I'm again using ruby to drive shell scripts, which is weird, but allows me to drop into ruby's very powerful regex system for file manipulation.

Here's what I was able to do:

Starting with:

• blog: evantravers.com repo (2GB, middleman site, history of articles)
• wiki: wiki repo (189MB, markdown and javascript, history of wiki edits)

I create some non-destructive tmp copies. Then I'm mostly changing things in the blog repo:

1. Use git filter-repo --path-regex to delete everything that isn't a markdown file
2. Use git filter-repo --subdirectory-filter to set the folder with articles as "root"
3. Clean up other files in the repo.
4. git filter-repo --strip-blobs-bigger-than 1M
5. git gc (garbage collection just in case.)
6. For each file:
   • rename the file as a ZK or evergreen file
   • add permalink/slug metadata
7. Make a commit describing the changes I've just done.

Then I merge the two repos with git merge --allow-unrelated-histories, leaving my tmp/wiki folder in a merge conflict between the old evergreen notes and the new copies from the blog.

How I Did It

If you are interested in seeing code, let's dig in:

First: some boilerplate, some resetting of the folder so that the script is idempotent, and some git filter-repo magic to shrink the blog repo down to just the markdown articles.

# frozen_string_literal: true

# Setup some constants to store the locations of the tmp folders
BLOG = 'tmp/evantravers.com'
WIKI = 'tmp/wiki'

require 'date'

# BLOG MINIFICATION AND MERGING WITH WIKI
# =============================================================================
puts 'Resetting tmp…'
`rm -rf tmp`
`mkdir tmp`

# COPY blog to this folder
puts 'Copying blog…'
`cp -r ../evantravers.com/ ./#{BLOG}`
`cd #{BLOG}; rm -rf build`

# Remove everything but the content
# TODO: I probably need to include my resume builder
puts 'remove everything but articles: remove LFS, git filter-repo'
`
cd #{BLOG}
git lfs uninstall
`
# (I'm currently using LFS, but I'd like to move away from that eventually.)

# Now we get into it. I want to end up with a folder containing nothing but my articles and their git history.
# First, `git filter-repo` is going to strip out everything that doesn't match a regex, in this case doesn't end in `.md`
`
git filter-repo --path-regex '^.*.md$' --use-base-name --force

# This next command sets source/articles as if it was the root dir. Pretty magic.
git filter-repo \
  --subdirectory-filter source/articles \
  --force

# This command is worded strangely. I want to get rid of the series folder, so I filter-repo **to** series, but then invert the "selection"
git filter-repo --path series --invert

# a quick clean to remove any now un-tracked files
git clean -df
# removing a folder that doesn't need to exist anymore.
rm -rf source

# Remove the 400MB LFS folder
rm -rf .git/lfs

# Remove untracked dotfiles
rm -rf .devbox .devenv .direnv .DS_Store
`

# CLEAN unlinked objects? (Currently reduced the repo size to 3.9MB)
puts 'Attempting to clean the repo to make it smaller'
`
cd #{BLOG}
# this may not be needed, but stripping all blobs bigger than a 1M should remove every image. Could be smaller I suppose.
git filter-repo --strip-blobs-bigger-than 1M
# a garbage collection just in case.
git gc --auto
`

After all those transformations, my once 2GB blog repo is now a meagre 5.5MB. Awesome!

With that done I now do some transforming of the article files so that they can live in the wiki comfortably.

I'll define some convenience functions, and then Dir.glob over the articles we've just git filter-repo'd.

# NOTE: Should there be booknotes in this list?
# Some of my blog posts have "mirrors" in my main notes. This is a mapping of those posts to those Evergreen or Main Notes that already exist.
EVERGREEN = {
  '2024-09-16-take-screenshots-of-your-work.md' => 'Take Screenshots of Your Work',
  '2024-09-03-positions-on-generative-ai.md' => 'Positions on Generative AI',
  '2023-10-25-opportunity-solution-trees.md' => 'Opportunity Solution Trees',
  '2023-06-26-he-who-grasps-the-heel.md' => 'He Who Grasps the Heel',
  '2023-05-21-and-there-arose-a-generation-who-knew-not.md' => 'And There Arose a Generation Who Knew Not',
  '2022-07-12-never-make-infinite-meetings.md' => 'Never Make Infinite Meetings',
  '2021-11-08-border-of-the-known.md' => 'Border of the Known',
  '2020-07-09-outcomes-over-outputs.md' => 'Outcomes over Outputs'
}.freeze

# quick check to make sure that I end up with the same number of files that I started with.
puts "BEFORE: #{puts `ls -l #{BLOG} | wc -l`} posts"

# quick and dirty way to "slice" a YAML block out of the front of an article.
def find_meta(content)
  meta_start = content.lines.find_index { |l| l =~ /---/ }
  meta_end = content.lines.slice(1…-1).find_index { |l| l =~ /---/ }

  content.lines.slice(meta_start + 1, meta_end).join
end

# add_meta takes a file's content and writes a new YAML string key
# I 100% should have just used a gem for this.
# FIXME: add_meta is going to read and write like three times per file
def add_meta(content, key, value)
  meta = find_meta(content)

  return content if meta.nil?

  return content if meta.match(key)

  new_meta = meta.lines.insert(-2, "#{key}: #{value}\n").join

  content.gsub(meta, new_meta)
end

# The main loop.
Dir.glob("#{BLOG}/*").each do |file|
  content = File.read(file)

  # add `published: true` to every article.
  content = add_meta(content, 'published', 'true')

  # compute the slug and add it. I may move this to a permalink attribute some day.
  slug = File.basename(file, '.md').gsub(/\d{4}-\d{2}-\d{2}-/, '')
  content = add_meta(content, 'slug', slug)

  filename =
    if EVERGREEN.key?(File.basename(file))
      # rename file to evergreen title
      puts "Found an evergreen file! #{file}…"
      EVERGREEN[File.basename(file)]
    else
      # use zkid based on date
      datestr = content.match(/^date: (.*)/)[1]

      zkid =
        DateTime.parse(datestr)
                .strftime('%Y%m%d%H%M')

      zkid
    end
  File.write(file, content)
  # I specifically use a rename rather than the single write so that git will `--follow` it.
  File.rename(file, "#{BLOG}/#{filename}.md")
end

# quick check to make sure that I end up with the same number of files that I started with.
puts "AFTER: #{puts `ls -l #{BLOG} | wc -l`} posts"

With all that done, I make a commit on the repo to "stamp" the changes in before doing the merge.

puts 'Committing changes'
`
cd #{BLOG}
git add -A
git commit -m 'Migration to wiki:\n\n- rename and rewrite of history\n- adding new YAML attributes'
`

# COPY wiki to this folder
puts 'Copying wiki…'
`cp -r ../../../wiki/ ./#{WIKI}`

Now all that's left is to use git remote and git merge to pull this new slimmed down repo into my wiki:

# MERGE modified blog with wiki
`
cd #{WIKI}
git remote add blog ../evantravers.com
git fetch --all
git merge blog/master --allow-unrelated-histories
`

What's Next

This leaves me in a merge conflict where I need to reconcile the existing Evergreen files and my blog posts… and that's fantastic!

At this point, the next step seems to be to write some kind of middleware to translate the wiki's content into something that Middleman will accept¹. (Middleman is very picky about filenames, file extensions, a whole mess of things.)

So I suppose the deploy will look like this:

• a push to my wiki or my blog repo will trigger a build.
• the blog builder will shallow checkout, and then deep checkout the content (wiki) repo.
• the middleware will transform the small wiki into a smaller subset of middleman ready articles
• then middleman will run and push it to S3.

One thing that I've realized is that this will likely speed up deploys: Currently I have to do a deep copy checkout of my whole 2G repo in order to have the changelogs... now I can just do a shallow checkout and save a few seconds.

The nice thing is that since this script is stable, I can keep working and writing while I figure out whether that middleware layer should be in nix, middleman, or a ruby script I just call.

I should just do the simplest thing and move on. 🤷

People keep bashing the Apple Intelligence ads… for somewhat good reason. They are a noted departure from the slick and trend-setting ads that have come before, from 1984 to the iPod silhouettes to Spike Jonze and FKA Twigs. Some might ask, "what is Apple thinking?" but they make total sense to me.

From a historical perspective they stand in a grand Apple tradition of introducing non-ideal user behavior into their UX Vision. There's a very direct line drawn from the selfish, lazy professor in the Knowledge Navigator video to the polished but kinda slinky "cheat off the machine" ads that are running today for Apple Intelligence. It's funny… but it's also somewhat realistic. While we detest some of the behavior, it's easier to recognize ourselves in the protagonists.

This has a benefit from an economic perspective. By shifting the "hero" away from a technological wunderkind, the Apple Intelligence ad distances itself from Justin Long and proclaims that this technology is for everyone: forgetful, distracted, desiring approval. I think that's a pretty smart position for an AI Product when the daily use of the tool hasn't quite crossed the chasm.

My qualms about putting AI in every device still stands… but at least I understand what they are trying to say.

I've been kinda stuck.

I can see the final-state: a single git repository that stores my writing and hosts my blog's content, a home for all my words to live and grow, links to make sense, and for the act of writing and developing thought to live equally in harmony with my other commitments.

It's beautiful, no?

The transition has been… tortured.

• In order to get the blog and the wiki merged, I'm faced with losing the git history for one of them, and I like my changelogs.
• trying to migrate off of middleman since… forever.
• While I can't get off Middleman, trying to rewrite the github action in nix, but I have been successful because nix derivations don't let me use git history to do the changelog.
• Trying to move my Things task manager to Obsidian Tasks (that's a whole other blog post for the future.) If I can move Tasks to Obsidian, then I can see and prioritize writing next to all my other work, whereas right now I maintain two separate project lists. Instead of maintaining a meta-task for writing, I can just write and that note that I'm workshopping can be a "project" in the system
• I've actually written a half-way decent Things -> Obsidian migration tool but I haven't been able to commit fully because of all the other things going on.

But I haven't been able to do any of the two. Still in Things, still have separate repos.

Worst part is that an in progress writing can live in one of three places: I started this blog post on my computer in the get repository, and then as I was walking around and thinking about it, I wanted to add to it on my phone… And I had to remember whether it was on Drafts, in Obsidian, or in to get repo. Often it exists in a horrible superposition of two of the three. That needs to stop.

The good news is that I believe this will be sortable in time: writing is thinking. Part of this private little snarky complaint was to force my brain to articulate and visualize the dependency tree that's keeping the work from flowing. My digital lament is an act of self-direction and a certain amount of accountability.

But good grief I can't figure out what to do first. 🙇

I highlight and quote parts of web pages a lot to build mention pages or recapture a thought, so I worked it into my hammerspoon-powered clipping program. Here's the commit: Github/evantravers/dotfiles.

-- https://stackoverflow.com/questions/19326368/iterate-over-lines-including-blank-lines
local function magiclines(s)
  if s:sub(-1)~="\n" then s=s.."\n" end
  return s:gmatch("(.-)\n")
end

-- Snip current highlight
Hyper:bind({}, 's', nil, function()
  local win = hs.window.focusedWindow()

  -- get the window title
  local title = win:title()
                   :gsub("- Brave", "")
                   :gsub("- Google Chrome", "")
  -- get the highlighted item
  hs.eventtap.keyStroke('command', 'c')
  local highlight = hs.pasteboard.readString()
  local words = {}
  for word in string.gmatch(highlight, "([^%s]+)") do
    table.insert(words, word)
  end
  local textStart = hs.http.encodeForQuery(words[1] .. " " .. words[2])
  local textEnd = hs.http.encodeForQuery(words[#words-1] .. " " .. words[#words])
  local quote = ""
  for line in magiclines(highlight) do
    quote = quote .. "> " .. line .. "\n"
  end
  -- get the URL
  hs.eventtap.keyStroke('command', 'l')
  hs.eventtap.keyStroke('command', 'c')
  local url = hs.pasteboard.readString():gsub("?utm_source=.*", "")
  --
  local template = string.format([[%s

%s
[%s](%s#:~:text=%s,%s)]], title, quote, title, url, textStart, textEnd)
  -- format and send to drafts
  hs.urlevent.openURL("drafts://x-callback-url/create?tag=links&text=" .. hs.http.encodeForQuery(template))
  hs.notify.show("Snipped!", "The snippet has been sent to Drafts", "")
end)

Rather than including the whole quote in the URL, I'm arbitrarily choosing to highlight the two words at start and end of the passage. I think that will work for my purposes.

I wish that there was an 5G, e-ink device, USB-C charging, decent battery life, and decent calling/ 5G hotspot.

Well 2022-Evan, looks like you have your wish!

Mudita Kompakt

Mudita is teasing their new device: the Kompakt. USB-C charging, super simple OS, and can be used as an internet hotspot.

The previous Mudita Pure was a lovely device but apparently a horrid phone. I'm going to be watching this closely. The Lightphone update does not interest me although it's a bold step.

I've been rewriting my nvim config to align with the features I am enjoying in Helix: simple TS-aware movements and uniform LSP-actions.

I haven't messed with my nvim config for quite a while… the last time I wrote about a plugin change was five years ago!

Changes

Basically four objectives:

1. Update and replace plugins with TreeSitter and LSP aware versions.
2. Change keybindings to match Helix where it doesn't break Vim's paradigm.
3. Find some LSP-aware text-objects and motions.
4. Simplify wherever I can.

I wound up removing everything, and slowly re-adding plugins and bindings as I missed functionality.

I was in the middle of this, when @folke pointed out mini.nvim. Mini provides a slew of useful, well written, TS and LSP aware lua modules that are really straightforward to configure.

This madlad wants vim to work like I want it to work. 👏

I wound up replacing a lot with mini.nvim modules:

• EasyAlign -> mini.align
• flash.nvim -> mini.jump
• lualine -> mini.statusline
• nvim-autopairs -> mini.pairs
• nvim-web-devicons -> mini.icons
• vim-sandwich -> mini.surround
• vim-unimpaired -> mini.bracketed

It's wild to me that I've taken unimpaired out of my nvim config. It's been there since nearly the very beginning… but the reason is Treesitter. Because @echasnovski is prioritizing Treesitter, I get consistent, useful Treesitter motions that go with all the others.

I removed the following plugins because they weren't working, deprecated… of I just don't use them anymore.

• completion-nvim
• git-messenger-vim
• nvim-ts-autotag
• plenary-nvim
• popup-nvim (noice.nvim)
• trouble-nvim
• vim-abolish
• vim-elixir
• vim-fetch
• vim-gist
• vim-projectionist
• vim-repeat
• webapi-vim

I really like mini.nvim's style. You don't have to go all-in like I did, they are so well documented and built out… you probably will.

I also spent some time rewriting my lsp configuration such the the bindings are nearly the same as I have become used to in Helix, and instrumenting those bindings using mini.clue.

Walkthrough

I know that not everyone who reads this is going to want to use nix to manage their dotfiles, so I'll pull it out of nix just to highlight some things.

Here's the final config file (after nix is done with it and with heavy commentary!)

At the top I load my vimrc which has my main settings that are backwards compatible, then I load all the neovim specific options and changes in an init.lua.

-- Load .vimrc
vim.cmd([[runtime .vimrc]])

-- Neovim specific settings
vim.o.icm = 'split'
vim.opt.foldtext = "v:lua.vim.treesitter.foldtext()"

vim.o.showmode = false

-- Use rg
vim.o.grepprg = [[rg --glob "!.git" --no-heading --vimgrep --follow $*]]
vim.opt.grepformat = vim.opt.grepformat ^ { "%f:%l:%c:%m" }

-- Set up pretty unicode diagnostic signs
vim.fn.sign_define("DiagnosticSignError", {text = "", hl = "DiagnosticSignError", texthl = "DiagnosticSignError", culhl = "DiagnosticSignErrorLine"})
vim.fn.sign_define("DiagnosticSignWarn", {text = "", hl = "DiagnosticSignWarn", texthl = "DiagnosticSignWarn", culhl = "DiagnosticSignWarnLine"})
vim.fn.sign_define("DiagnosticSignInfo", {text = "", hl = "DiagnosticSignInfo", texthl = "DiagnosticSignInfo", culhl = "DiagnosticSignInfoLine"})
vim.fn.sign_define("DiagnosticSignHint", {text = "", hl = "DiagnosticSignHint", texthl = "DiagnosticSignHint", culhl = "DiagnosticSignHintLine"})

Then I set some keymaps that I've been using for years that aren't related to any plugins.

-- Make <Tab> work for snippets
vim.keymap.set({ 'i', 's' }, '<Tab>', function()
   if vim.snippet.active({ direction = 1 }) then
     return '<cmd>lua vim.snippet.jump(1)<cr>'
   else
     return '<Tab>'
   end
 end, { expr = true })

-- Covenience macros
-- fix ellipsis: "…" -> "…"
vim.keymap.set('n',
  '<leader>fe',
  "mc:%s,\\.\\.\\.,…,g<CR>:nohlsearch<CR>`c",
  {noremap = true, silent = true, desc = "… -> …"})
-- fix spelling: just an easier finger roll on 40% keyboard
vim.keymap.set('n',
  '<leader>fs',
  '1z=',
  {noremap = true, silent = true, desc = "Fix spelling under cursor"})

The plugins are all loaded through nix, but we'll go through the configured ones here. Nix puts some in vim's paths that don't show up in the config.

First, my trusty zenbones color scheme.

vim.g.zenbones = {
  solid_line_nr          = true,
  solid_vert_split       = true,
}
vim.cmd [[color zenbones]]

Then I have a plugin previously that follows the OS light/dark scheme and works across operating systems:

require('auto-dark-mode').setup({
  update_interval = 1000,
  set_dark_mode = function()
    vim.api.nvim_set_option('background', 'dark')
  end,
  set_light_mode = function()
    vim.api.nvim_set_option('background', 'light')
  end,
})

A plugin that uses virtualtext to show colors in CSS files:

require'nvim-highlight-colors'.setup({
  render = 'virtual',
  enable_tailwind = true
})

Oil.nvim is a re-think of vinegar.vim which sits on top of netrw to make interacting with files a bit easier.

require("oil").setup({
  view_options = {
    show_hidden = true
  }
})
vim.keymap.set("n", "-", require("oil").open, { desc = "Open parent directory" })

Display git status in signcolumn:

require('gitsigns').setup()

Highlight TODO style comments and bindings to throw them into the :quickfix list.

require("todo-comments").setup()

A custom function for a minimal writing environment using zen-mode that emulates pencil.vim, but isn't broken. 🤷

-- I write prose in markdown, all the following is to help with that.
function _G.toggleProse()
  require("zen-mode").toggle({
    window = {
      backdrop = 1,
      width = 80
    },
    plugins = {
      gitsigns = { enabled = true },
      tmux = { enabled = true },
      kitty = {
        enabled = true,
      },
    },
    on_open = function()
      if (vim.bo.filetype == "markdown" or vim.bo.filetype == "telekasten") then
        vim.cmd 'set so=999'
        vim.cmd 'set nornu nonu'
        vim.cmd 'set wrap'
        vim.cmd 'set linebreak'
        vim.cmd 'set colorcolumn=0'

        vim.keymap.set('n', 'j', 'gj', {noremap = true})
        vim.keymap.set('n', 'k', 'gk', {noremap = true})
      end
    end,
    on_close = function()
      vim.cmd 'set so=3'
      vim.cmd 'set rnu'
      if (vim.bo.filetype == "markdown" or vim.bo.filetype == "telekasten") then
        vim.cmd 'set nowrap'
        vim.cmd 'set nolinebreak'
        vim.cmd 'set colorcolumn=80'
      end

      vim.keymap.set('n', 'j', 'j', {noremap = true})
      vim.keymap.set('n', 'k', 'k', {noremap = true})
    end
  })
end

vim.keymap.set(
  'n',
  '<localleader>m',
  ':lua _G.toggleProse()<cr>',
  {noremap = true, silent = true, desc = "Toggle Writing Mode"}
)

This plugin renders markdown in a sort of styled way in the terminal… which as many doc sources are in markdown makes some of the LSP popups have some style for free!

require("render-markdown").setup()

Telescope for finding files and picking stuff:

vim.keymap.set('n', '<space>/', "<cmd>lua require('telescope.builtin').live_grep()<cr>", {noremap = true, silent = true, desc = "Live Grep"})
vim.keymap.set('n', '<space>f', ":lua require('telescope.builtin').find_files({ find_command = {'rg', '--files', '--hidden', '-g', '!.git' }})<cr>", {noremap = true, silent = true, desc = "Live Grep"})
vim.keymap.set('n', '<space>b', ":lua require('telescope.builtin').buffers()<cr>", {noremap = true, silent = true, desc = "Buffers"})
vim.keymap.set('n', '<space>z', ":lua require('telescope.builtin').find_files({prompt_title = 'Search ZK', shorten_path = false, cwd = '~/src/wiki'})<cr>", {noremap = true, silent = true, desc = "Wiki"})

Treesitter for all my grammars and syntax files.

require'nvim-treesitter.configs'.setup {
  highlight = { enable = true, },
  indent = { enable = true },
}

Tree-pairs makes % respect Treesitter nodes, which is great for languages with do -> end style syntax (looking at you ruby and elixir!)

require('tree-pairs').setup()

Treesitter Incremental selection lets me emulate most of Helix's feature to select up to the next tree-sitter scope. Highly recommended. I'm using Helix-like bindings. Most people use <cr> or v.

require'nvim-treesitter.configs'.setup {
  incremental_selection = {
    enable = true,
    keymaps = {
      init_selection = "<M-o>",
      scope_incremental = "<M-O>",
      node_incremental = "<M-o>",
      node_decremental = "<M-i>",
    },
  },
}

And then mini.nvim is doing a ton of heavy lifting.

require('mini.ai').setup()         -- a/i textobjects
require('mini.align').setup()      -- aligning
require('mini.bracketed').setup()  -- unimpaired bindings with TS
require('mini.comment').setup()    -- TS-wise comments
require('mini.icons').setup()      -- minimal icons
require('mini.jump').setup()       -- fFtT work past a line
require('mini.pairs').setup()      -- pair brackets
require('mini.statusline').setup() -- minimal statusline
require('mini.surround').setup({   -- surround
  custom_surroundings = {
    ['l'] = { output = { left = '[', right = ']()'}}
  }
})
local miniclue = require('mini.clue')
miniclue.setup({                   -- cute prompts about bindings
  triggers = {
    { mode = 'n', keys = '<Leader>' },
    { mode = 'x', keys = '<Leader>' },
    { mode = 'n', keys = '<space>' },
    { mode = 'x', keys = '<space>' },

    -- Built-in completion
    { mode = 'i', keys = '<C-x>' },

    -- `g` key
    { mode = 'n', keys = 'g' },
    { mode = 'x', keys = 'g' },

    -- Marks
    { mode = 'n', keys = "'" },
    { mode = 'n', keys = '`' },
    { mode = 'x', keys = "'" },
    { mode = 'x', keys = '`' },

    -- Registers
    { mode = 'n', keys = '"' },
    { mode = 'x', keys = '"' },
    { mode = 'i', keys = '<C-r>' },
    { mode = 'c', keys = '<C-r>' },

    -- Window commands
    { mode = 'n', keys = '<C-w>' },

    -- `z` key
    { mode = 'n', keys = 'z' },
    { mode = 'x', keys = 'z' },

    -- Bracketed
    { mode = 'n', keys = '[' },
    { mode = 'n', keys = ']' },
  },
  clues = {
    miniclue.gen_clues.builtin_completion(),
    miniclue.gen_clues.g(),
    miniclue.gen_clues.marks(),
    miniclue.gen_clues.registers(),
    miniclue.gen_clues.windows(),
    miniclue.gen_clues.z(),
  },
})

lsp_config is setup to give me a consistent interface, even the same leader keys and actions as Helix.

vim.keymap.set('n', '<space>d', vim.diagnostic.setloclist, {desc = "Add buffer diagnostics to the location list."})

-- Use LspAttach autocommand to only map the following keys
-- after the language server attaches to the current buffer
vim.api.nvim_create_autocmd('LspAttach', {
  group = vim.api.nvim_create_augroup('UserLspConfig', {}),
  callback = function(ev)
    -- Enable completion triggered by <c-x><c-o>
    vim.bo[ev.buf].omnifunc = 'v:lua.vim.lsp.omnifunc'

    -- Buffer local mappings.
    -- See `:help vim.lsp.*` for documentation on any of the below functions
    local opts = function(str)
      return { buffer = ev.buf, desc = str }
    end

    vim.keymap.set('n', 'gD', vim.lsp.buf.declaration, opts("Declaration"))
    vim.keymap.set('n', 'gd', vim.lsp.buf.definition, opts("Definition"))
    vim.keymap.set('n', 'gi', vim.lsp.buf.implementation, opts("Implementation"))
    vim.keymap.set('n', '<M-k>', vim.lsp.buf.signature_help, opts("Signature Help"))
    vim.keymap.set('i', '<M-k>', vim.lsp.buf.signature_help, opts("Signature Help"))
    vim.keymap.set('n', '<space>wa', vim.lsp.buf.add_workspace_folder, opts("Add Workspace Folder"))
    vim.keymap.set('n', '<space>wr', vim.lsp.buf.remove_workspace_folder, opts("Remove Workspace Folder"))
    vim.keymap.set('n', '<space>wl', function()
      print(vim.inspect(vim.lsp.buf.list_workspace_folders()))
    end, opts("List Workspace Folders"))
    vim.keymap.set('n', '<space>D', vim.lsp.buf.type_definition, opts("Type Definition"))
    vim.keymap.set('n', '<space>r', vim.lsp.buf.rename, opts("Rename Symbol"))
    vim.keymap.set({ 'n', 'v' }, '<space>a', vim.lsp.buf.code_action, opts("Code Action"))
    vim.keymap.set('n', 'gr', vim.lsp.buf.references, opts("Buffer References"))
    vim.keymap.set('n', '<localleader>f', function()
      vim.lsp.buf.format { async = true }
    end, opts("Format Buffer"))
  end,
})

local lspconfig = require('lspconfig')

lspconfig.elixirls.setup { cmd = { "elixir-ls" } }
lspconfig.solargraph.setup({
  settings = {
    solargraph = {
      diagnostics = true,
      useBundler = true
    }
  }
})
lspconfig.nixd.setup {}
lspconfig.lua_ls.setup {
  settings = {
    Lua = {
      runtime = {
        version = 'LuaJIT',
        path = vim.split(package.path, ';'),
      },
      diagnostics = { globals = {'vim', 'hs'}, },
      workspace = {
        library = {
          [vim.fn.expand('$VIMRUNTIME/lua')] = true,
          [vim.fn.expand('$VIMRUNTIME/lua/vim/lsp')] = true,
          [vim.fn.expand('/Applications/Hammerspoon.app/Contents/Resources/extensions/hs/')] = true
        },
      },
    },
  },
}
lspconfig.markdown_oxide.setup{}

And that's it! 271, down from 441.

…

I've been bouncing back and forth, and so far I'm very pleased. Having all my plugins be Treesitter and lsp aware makes for a much more consistent interface, and mini.clue's little prompts reminds me that I have a lot of textobjects and actions that I often forget about.

It's also a bit snappier. It's much easier to see on my older intel mac, but less plugins == speed.

Thanks to mini.clue and some refactoring of bindings, the way I interact with the LSP is roughly the same muscle memory on Helix or nvim, so I have a choice whether to use Helix's interesting new modal model, or nvim's tried and true ecosystem.

Have a weekly prompt to take screenshots of your work.

Most of the digital record of my career is already gone.

I'm old enough that the first things I ever made on a computer¹ were in Clarisworks on floppy disks.

While I obviously can't open those anymore, I've lost much more. When I did the redesign post in 2020 this blog's software was old enough that it was non-trivial to "rewind" and take screenshots of how it used to look. Soon it will be nearly imposible.

The first projects I ever built as a professional are all gone. They weren't captured by the Internet Archive, the original design files weren't in git or were in old versions of Photoshop or Indesign that aren't even compatible with modern versions… even if I was willing to pay for it. It's all gone.

Which brings me to the main point.

One of the most important ritual habits I recently adjusted: Take Screenshots.

At the end of the week I remind myself to look back and record any work that I'm proud of…

• meetings where I contributed…
• designs I pushed forward…
• research insights I gathered…
• conflict I helped work through…
• anything I shipped…

I take screenshots of things visual, and write tweet-length summaries of all of it.

I keep the screenshots and logs in my personal log, and translate it to my current professional goal-system.

It makes easier reviewing quarterly/yearly goals, and provides me with a sense of satisfaction and growth that is invaluable.

References:

• Alex Wichlan wrote a great blog post about this that I think I encountered a while back.
• I feel certain that I've encountered Jason Scott (textfiles) advising this somewhere.

To solve this problem, I moved the focus outline to the parent container.

[...]

.bento-card:has(button:focus-visible) {
  outline: 2px solid var(--color-primary);
}
/* Remove the default button focus outline */
.bento-card button {
  outline: none;
}

Immediately using this. What a cool accessibility tool.

It kinda feels like :has is the "missing selector" in CSS. Historically, there have been a bunch of relationships we just couldn't express in CSS. With :has, we can select any element based on the properties/status of any other element. No limits!

As we've seen, the :has selector is incredibly powerful. Things that used to require JavaScript can now be accomplished exclusively using CSS!

Thank you Josh!

The Undeniable Utility Of CSS :has • Josh W. Comeau - www.joshwcomeau.com

Latticework’s main goal, then, is to enable fluid movement between these foraging and sensemaking stances.

This looks like such neat solution to the "how can I highlight" and move back and forth between source and research. I love it. I feel very validated in my recommendation to keep your source document clean.

I hope that Matthew and Andy continue this work, it's very promising.

Latticework: Unifying annotation and freeform text editing for augmented sensemaking - www.matthewsiu.com

This is the best explanation of using Helix as a Vim-user. Vim is such a muscle-memory specific thing that explaining where its mental model is inconsistent is really hard for me. Approaching Helix's consistent modal paradigm and "selection first" model feels like re-thinking everything… and probably will make me a better Vim-user.

So what does this mean?

Vim has been under my fingers for my entire career. As such, it's hard to articulate what the differences are, but the chief change is that Helix is consistently selection -> action. Maybe I use Vim wrong, but my paradigm usually involves placing the cursor in the right place/line, then invoking a Command Verb followed by Motion/Direct Object. This requires knowing the change you wish to make in the first place.

Helix's adamant decision that everything starts with a selection (a cursor is a single character selection!) brings a lot of clarity and consistency, as well as mapping very well to identifying a thing to change, then considering the change. You can "select" without knowing what you are yet going to do.

It is a weird experience as a vim-nerd. There are things that are crazy simple that seem harder, and there are refactors that would be extremely convoluted in vim that become extremely simple.

A contrived example: aligning vertically.

This is really a terrible example. It only resonates if you use Helix enough to realize that each of the more esoteric refactor techniques stay consistent within Helix's selection -> action model, while the same behaviors can force cause Vim to break its idioms.

(It also could be that I'm bad at Vim.)

If nothing else, it works really well if you are the kind of person who constantly highlights text they are reading. 🤷

I think Helix's style and consistency has a lot of merit. Making changes on subsets of plain-text is a core refactoring and writing activity, and maps well to some of the LLM assisted coding tools that are becoming popular. I'm already experimenting with how this changes my Vim usage, at first that's going to be trying to come up with some consistent TreeSitter enabled motions since those have been so helpful in Helix.

I've been writing unpublished essays about AI since Dall-E was announced. My opinions have slowly congealed to the following points. We shall see how well they stand the passage of time.

First of all, Generative AI is not an Artificial General Intelligence (AGI). Much of the fear and discussion¹ around the future of GenAI concerns whether it leads to AGI.

I'm going to sidestep that conversation for the moment and discuss GenAI directly for this moment.

A quick definition of Generative AI:

Generative AI is an advanced machine learning technology. It relies on Training Data, a machine-reinforced Model, and a Prompt, with the goal of simulating human creativity or behavior… It relies on Training Data, a machine-reinforced Model, and a Prompt, with the goal of simulating human creativity or behavior.

Theological: Math, not a mind

Theologically, I believe creation of life is a non-communicable aspect of the Triune God.

The best explanation I have yet encountered is Stephen Wolfram's What is ChatGPT Doing… and Why Does It Work?. While it can feel like we are interacting with an intelligence, ACT's discussion of Janus Simulators speaks to interacting with a math function that feels but is not sentient in any way².

The human tendency to anthropomorphize GenAI actions makes this conversation difficult. Even those who believe it's just a mathematical simulation still talk about AI "making stuff up" to say hallucination… when it's not making up, it is simulating based on its training data and model.

That being said: it doesn't have to be a mind to be dangerous or interesting.³

Legal: Training Data ~= Piracy.

Y'all remember Limewire? People smirking and saying "I'm not stealing, I'm just ''borrowing one bit from a hundred thousand people!'" Ethically murky businesses championed technologies that eventually spawned legitimate businesses… after the lawsuits settled.

Sound familiar? AI training data is making the same argument, same situation, I'm guessing same timeline.

Morally: It's likely defrauding.

Have you noticed that some uses of GenAI seem wonderful and some seem downright sinister? I find the 1828 Webster's dictionary definition of defrauding helpful (emphasis mine):

DEFRAUD, verb transitive [Latin To cheat.]

1. To deprive of right, either by obtaining something by deception or artifice, or by taking something wrongfully without the knowledge or consent of the owner; to cheat; to cozen; followed by of before the thing taken; as, to defraud; a man of his right.

We have corrupted no man, we have defrauded no man. (2 Corinthians 7:2)

"Taking without knowledge or consent" is a useful rubric for this GenAI moment. The degree of "wrongness" in an AI application correlates with perceived consent.

In these early days of TOS changes and rushing to scrape the web before the legal precedent is set we are guaranteed to be hoisting content without the author's knowledge, GenAI is always a little questionable⁴.

Practical: Broadens your skills, zero-to-one.

GenAI can not make you better, but it can grant you new capability. As Wolfram points out:

tasks—like writing essays—that we humans could do, but we didn’t think computers could do, are actually in some sense computationally easier than we thought.⁵

There is a new set of previously "unprogrammable" problems that are available to everyone.

If you are familiar with the idea of a T-shaped skillset, AI-tooling will not deepen your core skill, but it can extend the breadth of your capability. It won't 10X a programmer, but it can help that programmer write better marketing copy or generate more research documents.

I personally use it a fair amount for defeating blank page syndrome. I'll generate an outline, and then start hating on it… because it's usually terrible. Arguing with mediocre GenAI work is easier than trying to start from scratch.

I also generate coloring pages for my kids. A lot.

Investment: Too bubbly.

It's the current bubbly long bet after crypto. There'll be ten thousand losers and two winners, same as all bubbles. Too early to tell. There will be lies and grifters the whole way, but that's not new.

I personally believe the current hardware buildout and investment is not going to be worth the amount we are putting in, simply because I believe that a second generation of hardware will come along and the billions of spend on current cloud-based build out will be obsolete.

Cultural: Brace yourself for the trust apocalypse.

I will frame this as a bet: Video evidence will not be admissible in criminal court by 2026.

GenAI is so far exceptional at mass-producing mass-media. They call it "AI slop," and it's growing quickly. What's worse is it seems capable of mass-producing longer-ish form media that was previously unfakeable: podcasts, more podcasts, books and novels... and it's only going to continue.

Our society is not prepared legally, culturally, or socially for a world where most media we encounter is untrustworthy. Bad actors will use the momentary confusion for evil. Eventually good people will evolve defensive cultural and technological strategies. Until then, Building and Keeping Community will be critical.⁶

Analyze: Data is value. Don't give it away.

The apocryphal Native Americans who sold the rights to Manhattan Island for a handful of beads made an incredibly good deal… in the economy in which they operated and assumed would persist. They traded something valueless (to them) for something valuable, and died happy… and wrong.

The largest companies in the world are giving away free technological tools in exchange for your attention and behavioral data. They are even waging secret wars against each other for the same data⁷. It's a great deal for you… until the economy in which we live shifts towards the next.

Consider the deal you are making. You are giving away your forest for beads. So have I. That train has already left, but we can start renegotiating that deal now.

Caution: Spooky interactions at a distance.

There's a wild combination of effects between the ability to query previously "unprogrammable" problems and the wild land-grab of barely-legal dataset acquisition.

People will lean on these systems as authoritative and god-like, and the weird interactions of several together could create very unpredictable and harmful edge cases.

In a previous technological moment, The Data Visualization trend of the early Web 2.0 had some examples of what happens when you reveal or translate a dataset in a new way: Strava revealed locations of secret military bases, Fitbit told everyone when you had sex… and as advertising/attention economy shifts towards consolidating power on Training Data… the surveillance economy will only benefit.

GenAI has the ability to notice and correlate patterns, and puts that power in more people's hands.

Cynical: Bias, unintentional and intentional.

The Training Data is generated by us sinful humans. The Prompt is written by sinful humans. Sinful humans interact with the final product. There is a potential Tolerance Stacking problem here. GenAI is trained on our preferences and behavior… and our what the parents do in moderation the silicon children do in excess.

I think often about Neil Gaiman's American Gods. In the novel, anything to which humans devote time and attention become little gods. In the novel, the old gods of myth and legend are grappling with their worship fading as the New Gods of Materialism and Media grow in power. The bible has long warned us about what we worship… our idols resemble us and we grow to resemble them.

Training Data has been gathered unethically from the corpus of available human endeavor on the internet. This mass of writing and behavior made by humans operating in Redemptive History contains both echoes of Doctrine of Common Grace⁸ and our human Sin Nature. This can have dramatic and somewhat unexpected effects:

• A machine learning algorithm called COMPAS was trained on criminal court sentencing to eliminate human racial bias. Instead, the system picked up on the pattern and exaggerated it.
• A current generation portrait generator trained on millions of illustrations will "pornify" when prompted with a picture of an asian woman because of the millions of such images in its training data.

Existential: Terrifying… depending on your worldview.

Math emulating human intelligence is not scary to a theist.

However, to a materialist human intelligence is purely physical phenomena, math and chance. If your own mind is math, the assertion that GenAI is "math, not a mind" becomes quite frightening.

A materialistic worldview is also open to the theory that we are in simulation of reality . If GenAI is basically a faster and higher-fidelity simulator… another threatening thought which is explored in Neal Stephenson's Fall; or, Dodge in Hell by Neal Stephenson.

It's fascinating that technology is easier to digest as a theist.

Hardware: Race to the edge.

The SAAS⁹ revolution dominated software for decades, and the present AI-focused hardware buildup follows that same path. However, I predict that a combination of speed requirements and the growing desire to keep data private will reverse this trend and push models to edge devices. It's already happening: Rabbit.ai's R1, Humane's AI pin, Rewind.ai's Pendant, and the new iPhones have GenAI chipsets "on the edge." These device-based, edge-based models have the advantage of being able to "securely" tie together the machine learning and the user's present context in a way that will be more focused and useful.

I used scarequotes around "securely" on purpose. Such an approach will not be private. Big Tech has always bowed the knee since the start. OpenAI is already commited to this with their board appointments.

Future: AI in the light of History and Eternity

I am surprisingly hopeful about the future. We live in a world primed for economic upheaval driven by a technological innovation. While I would prefer to not live in interesting times, I believe Ecclesiastes is true: there is nothing new under the sun.

The invention of the printing press triggered a new wave of personal autonomy and thought. Knowledge and art unbundled from patronage and distributed to rising classes, new forms of financial power, and political unrest… and out of that chaos strode a squat german monk with a list of Theses.

The first industrial revolution destroyed economies, started riots, coincided with nation-reforming and moving… and out of that noise and change arose the sparks of Great Awakenings.

Revival often seems to colocate in redemptive history with economic and technological upheaval. We stand on the precipice of a world barren of Truth. A world longing for meaningful relationship. A world needing hope… and we as Christians are anchored in a millennia-old love story of Truth, relationship, and hope.

May we be found faithful.](https://evantravers.com/articles/2024/09/03/positions-on-generative-ai)

I've already spent nearly a grand on an incredible camera and speaker system that I always have with me… why not use it for the calls that dominate most of my workday? It gives me a clean home desk without the looming desklight and microphone, and I can be sure to have the same setup no matter where I decide to work that day.

Four years ago, when we all went home to work remote, I supplemented my stolid Blue Snowball microphone with a new Logitech StreamCam and Elgato Key Light. I was in a large part reacting to a post proclaiming that "a good streaming setup is the new three piece suit."

I used this setup happily until the last OSX release which introduced Continuity Camera. This allows you to use the camera and micorophone on your iPhone as a webcam and microphone.

I have been shocked how good the results are. I sold my video light and camera. For the past eleven months I exclusively used just my iPhone and Airpods Pro as my entire remote meeting setup. I did update my Airpods Pro to the 2nd version two months ago. It has worked amazingly even in relatively loud toddler-filled environments.

I have both the monitor and laptop Belkin Magsafe mounts. The monitor edition stays at my home desk with a hidden right angle lightning cable that I can pull up to charge it when docked. The laptop one goes in my trusty office-in-a-bag.

I am shocked how good the Audio Input of the iPhone can sound. I usually have a powerful PC just a foot away, fans blowing… can't hear it. My children loudly playing just outside the room with the door open, and nothing on the recording. 🤞

For audio output I either use the laptop speakers or often my Airpods Pro on noise cancellation mode.

I turn on Portrait Mode, Studio Light, and Voice Isolation in the new Mac OSX audio/visual filters mode. I also typically turn on whatever voice isolation is available in the Video Meeting software I'm using at the moment… it helps hide my loud toddler coworkers from disturbing my remote colleagues.

In loud coffee-shops with a lot of ambient noise the iPhone doesn't work as well as input. I'll typically switch to the Airpods Pro microphone.

I'm really shocked how good the iPhone default settings nail white-balance, how well Studio Light handles the harsh backlighting of my office… as a relatively picky person, it's very good.

This past month I found that Elgato has an app called EpocCam Pro for iPhone that will allow you to use this same setup on a PC. You don't get Portrait Mode or the other filters, but it at least works and I'm able to avoid buying more equipment just for working on my PC.

I'll often make the other person's video very small and float it at the top of the monitor just under the camera to maximize eye exposure. If it's a gallery of participants, I'll use yabai to split the monitor and put them as a row at the top.

I've been very happy with this setup. 👨‍💻

My friend Tom has praised Kakoune for years and always threatened leaving Neovim for it.

Well… I'm playing with just that. I spent a weekend going through the helix --tutor, then doing a little advent of code golfing in elixir.

Why?

As fan of modal editing, I'm intrigued by the supposedly more efficient and consistent editing paradigm. I also really like how little configuration it requires to get it basically 95% of what I was doing in neovim. 17 lines I think!?

It kind of reminds me of what I like about Fish over Bash. Same principles, just enough batteries added to be comfortable without stretching out and going crazy and leaving the linux philosophy.

Thanks to the deep magicks of LSPs, I can even access my wiki pretty ably in Helix much the same way I was able to in Neovim. I still miss a lot of my customizations and bindings. I imagine that if I were to go write some serious code, I'd probably jump right back over to nvim, but for the moment Helix is like a fun weekend motorcycle. Not sure I want to make it a daily driver, but it's a fun hobby.

Searching for facts on the internet is a bit like foraging for mushrooms.

Doesn't matter how experienced you are… you should double check every single one.

I spent some time on calls today going through and refactoring all the tags.

Some I completely removed, like focus and productivity. Since nearly everything I write tends to touch on those two, it felt duplicative and useless. Also gone are tags related to ios or mac.

One I broke up... code because whatever language the code was written in: lua, javascript, css, ruby, and a few elixir posts.

I renamed bible to bible-study and prayer to prayer-journal as that's more specifically what they are.

One new lovely tag is time-stewardship, because it's something I'm passionate about and have written a fair amount related to it.

There were a bunch that were basically mirrors, like books and reading, vimwiki and vim. There were a bunch related to my obsession with plaintext notes... plaintext, zettelkasten, smz and maybe another I've forgotten have been condensed to notemaking. I don't love that because it's Nick's term, but it fits and I use it for my own thinking.

Since anyone who can see this is the "true audience," let me know if that makes sense or if I've broken a favorite bookmark. 🤷

The core is a notepad that automatically does a summation of the numbers entered, and also supports human-language conversions and functions.

Soulver sits at the liminal space for questions that need several calculator operations, but it would be too much trouble to set up a spreadsheet.

Its smart summary is clever enough to understand units and fractions.

Since downloading this I use it all the time: planning vacations, how many invites fit in our party budget, how much money to redo a room of our house… and much more. I can return back to the note, adjust a variable and see a new result.

Most recently I used it as my wife and planned an upcoming camping trip. I could leave my budget in the note, and as the price of flights fluctuated I could see the budget total and when my budget and flight costs aligned, we could make a go decision.

There's a free web clone at http://numbr.dev if you want to try the concept. I recommend supporting Zac's original version. It's very convenient on mobile.

Soulver 3 by Zac Cohan

I'm thinking about refactoring all my tags on blog. I've got some that are too vague like automation, and couple that are essentially duplicates like prayer and bible

I'm probably going to forge through and try to create some more "threads" where if someone encounters a post that appeals to them, they are more likely to find something else in that same vein.

But I ask y'all, faithful secret RSS Club... what say you? What would you find most helpful? If you have an idea, I'd love to hear it.

For nearly every topic that matters, we don't need reactions, we should incentivize responses: measured, thoughtful, timely.

Instead "Trending topics" pressgangs all posts out of their original conversation: thrust into a context that rewards strong emotional reaction: a pause in scroll, a reaction click, a reply.

"Trending topics" transforms writers and conversationalists into propagandists and pundits… they have no choice.

I kind of wish I could prevent my social media posts from appearing in "trending". If there were such a feature, I'll wager much of the deeper value would be in non-trending conversation streams. At that point the conversations would no longer resemble modern social media: if you have a single stream of thought and conversation where you can control the context and learn your audience…

You have a blog or newsletter. 🤔

I suggest following ThePrimeagen’s advice on approaching your configuration. He recommends revisiting your configuration only once every couple of months, which I think is a very healthy and sustainable approach. In the meantime, take a mental note of the things that are annoying or slowing you down so that you can address them when the time to overhaul comes.

I feel very seen. And guilty.

While I agree whole heartedly with the main argument of this article, I'll present an alternative and useful mental model: think like a carpenter. Build jigs to serve your current work.

A carpenter will build a jig to automate a repetitive or precise task, but he'll make it 80% good, intentionally temporary, and perhaps throw it away at the end. If he finds himself building that jig over and over, he may make a more flexible and permanent version.

The slough of distraction is when you are trying to "perfect your config" for all situations, all languages, for problems you currently aren't solving.

If the carpenter has no project, he has no purpose to build a jig. Programmers frequently start with the jig, and end with the project. Sometimes this works out. Usually it does not.

Your tools can be improved and modified, and you should, but only change it to serve your work for today, not tomorrow.

Stop perfecting your config | Arkadiusz Chmura - arkadiuszchmura.com

Last night my friend Joschua alerted me that my website was giving a 522 error. I poked at it a little bit on my phone, but I was visiting family and couldn't look at it more. It was very strange, because I had not pushed anything to the site in a few days.

I updated some github actions from my phone in my github workflow, just in case there was a new version of the AWS actions or something that had expired. Nothing. I tried searching Twitter/X for "cloudflare" and "cloudflare 522," hoping to see a rash of complaints… nothing. I had to go to bed, hoping it was some regional thing.

This morning I was convinced it had something to do with a certificate issue, so I wound up crawling all through AWS to find all the old systems I had setup, and then all through Cloudflare's settings.

Frustratingly, the S3 static site was always available and fast. According to Cloudflare defines a 522 as the server isn't responsive. Eventually… I realized that means the DNS records were wrong.

I wasted some time deleting and shutting down AWS services I wasn't using at the time, thinking that might at least clear the air of possibilities.

When I imported the settings to Cloudflare from Route52, I think it froze the current IP that S3 was using. Probably Route52 is smart enough to follow any rotation within their system. That's not what Cloudflare recommends on their S3 static site guide. I followed the steps in this guide, and realized that my A record was pointing to an IP, while they recommend using a CNAME to point to the bucket endpoint.

Hey presto.

I guess that IP address mapped to the bucket region for years, and sometime this week it rotated out. Who knows.

For years I have embraced a simply taxonomy of named and unnamed notes. Named notes a strong ideas or strong opinions, unnamed notes are almost marginalia to other thoughts that may develop into something greater.

While exploring the graph, I started "dimming" my less-certain unnamed notes. It's as easy as adding a color to: file:/^\d{10}/

Just a small thing, but it can help you decide where to explore next, or discover a cluster of related ideas that may need some nurturing.

The emerging golden age of home-cooked software, barefoot developers, and why the local-first community should help build it.

If you like the things I write and think about, you should be following Maggie.

Home-Cooked Software and Barefoot Developers - maggieappleton.com

I started experimenting again after my last post. This has been stable for six months.

The goal is always to use the phone less. Here's some new adaptations I've made to make my life more interesting and my phone less addicting.

Lock Screen

Lock screen is largely the same. Same magic button concept as 2019. The only change is that I swapped out additional Drafts button for searching my Contacts via CardHop.

I've also noticed that the Headspaces action no longer has the bug I encountered earlier in the year, I think some iOS update patched in requiring the unlock before the menu will display.

Home Screen

Right after releasing my blog post, I heard about Blank Spaces from Mike Schmitz… and I went for it. I've been using it for months with a couple small changes. For me, it's again trying to remind myself to create with intention and then get off the device, so instead of the app names I have them listed as the creative verbs that I should use them for.

ChatGPT is a new addition. The hope is that I'll use it for quick answers without being sucked away to distraction land. ChatGPT's restrictions and hallucinations should be a helpful constraint. We shall see.

Widget Screen

A few small changes here. I moved "lemme just check" apps here: Parcel (deliveries), as well as a tiny widget for Things (tasks). I don't use Things nearly as much on my phone, but I usually have one or two home tasks that I need to see in the afternoon.

I also added Screentime widget here so that as I check my phone I'm faced with my current health and phone addiction statistics. :P

It's helped me put the phone down a few times.

Other

A couple other focus related changes…

I disabled all Siri suggestions in notifications or search. Go direct to app, don't get distracted.

I installed Mail for the first time in years. I use it mostly for emailing friends. I was opening browser to do this, and getting sucked away. Might move back on this. For now, it's not stealing my time that much and is providing meaningful conversations. (As long as I keep unsub'ing from promotional mail.)

Using ReFocus to heavy block distractions in browser… especially youtube. I've come to enjoy an intentionally high friction youtube workflow:

• I'll save the video to Omnivore
• unblock it in Refocus for 3m
• then go back to Omnivore to start the video

Even after the Refocus unblock expires, the video will keep playing, and Omnivore will let me play picture-in-picture or with the screen closed. But when the video is over, the blocking kicks in and I can't get lost in related videos. 🧑‍🍳👌

Noticeably absent: Things. I spend less and less time in it. I typically capture todos on paper or in Drafts. I look at it at the start of the day and halfway thru the afternoon. Maybe the experiments started in dating other task managers will pay off.

I've been using a copy of the Bible in Markdown in Obsidian for over three years as my primary digital Bible. It's been wonderful.

I can read along the passage with the sermon or bible study, and see every time I have ever studied or mentioned the current chapter and verses in any note from the last decade.

I do try to use my physical bible whenever possible… but if I do pull out my phone to find some scripture, I'm using Obsidian. I open the app, hit the + icon in the center of the bottom toolbar to open/create a file and type a fraction of the book/chapter… something like Gal 3 to jump to Galations 3.md.

I then just treat it like a digital bible. Because I have it organized in chapters I can read the book in the app easily. I use Strange New Worlds to highlight headers that have a link to them, so I can see any "digital marginalia" that I've added. If I scroll to the bottom and invoke the Unlinked Mentions feature it'll display any Kindle Highlights or journal entries that have not yet been linked up.

If I take notes, I usually still take notes by hand in my journal or throw it into Drafts. The friction of translation between mediums helps me filter the important and interesting… and it keeps me from spending time on my phone during a sermon or bible study session.

As with anything else, my afternoon note-making ritual will help me move anything particularly interesting into the notes. Most of them become unnamed notes with a link to the scripture in the form:

[[Galatians 3#19]] asserts that the promise made "face to face" by God to Abraham has precedence over The Law which was delivered by multiple intermediary angels over a period of time.

Source: Brumlow, bujo://10/113

(Filename: 202405081707.md)

If I come across this thought later in my notes, it has intrinsic value… but I also can encounter it as part of my digital bible in the Linked Mentions or the footnotes system from Strange New Worlds.

Dos and Don'ts

I have tried a bunch of different methods and organizations¹. Here’s what I have learned:

Do...

• Read and spend time in this Bible. While using a digital bible has focus disadvantages, you are able to encounter thoughts and notes in this bible. Obsidian is where I go to think, and my thoughts tend to center around what I learn in scripture.
• Use an application that supports highlighting links on headers. I use a plugin called Strange New Worlds in Obsidian.
• When writing notes, write the thesis sentence inline with the link so that it’s visible in the preview.
• Use headers for verses. Headers give linking, blocks, and outline. They also translate to HTML or other documents easily.
• Ensure that the files are stored locally on your device. While using Obisidan Sync it’s faster loading than most other bible apps on my phone.

Don’t...

• Make the filenames simple. I originally had ordering numbers on the books, but then I had to remember the ordering of a book to write the reference.
• Write notes inside the Bible chapter files.
  • It makes it hard to transport thoughts and connections across Bible verses.
  • If you later want to improve your reading experience "add a feature" like Next/Prev Chapter you have to be very clever to avoid destroying your precious notes.
• Use iCloud to Sync. It unloads all files locally except the last 200 or so, and you are about to be working with far more than that.

History

Already read my article on mechanical keyboards and RSI, and believe an ergonomic keyboard will help your symptoms? Ok! 👨‍💻

While You Shop: Prepare Today

Here are a few steps to prepare for your ergonomic keyboard… and they can reduce strain today.

Push Board Back for Straighter Wrists

A standard staggered keyboard forces your wrists to contort slightly. Sometimes shifting the position of your keyboard deeper onto your desk can help this, as it decreases the intensity of the angle.

You can also experiment with the height of your desk and the height of your hands above the keyboard. I don't use wrist wrests (which can aggravate tendon-related issues as they apply pressure on the bottom of your soft tissues) and "float" my hand above my keyboard. Your mileage may vary.¹

Use The Opposite Hand for Modifiers

Modifiers like Shift, Control, and Command/Windows occur on both sides of the keyboard for a reason. When I first started programming I experienced RSI-esque pain above my left wrist. My friend Tom pointed out that I only used my left hand for every single modifier. This heavy use plus contorting that hand to reach all the modifiers largely caused the pain.

There are a couple ways to learn this:

• monkeytype.com has an option called opposite shift mode.
• Karabiner-Elements has a complex rule to force this behavior.

I used the Karabiner-Elements limiter. It was incredibly frustrating for a month or two (especially passwords!) but then I learned and I've been typing using the opposite hand for modifiers ever since.

(You can also consider moving a common modifier (Control is a common choice) to the Caps Lock key. OSX allows this with no other software tools .)

Minimize Finger Motion

We want to reduce harmful hand motions… anything that requires reaching, curling-under… basically any finger movement off it's standard axis. Pay attention to common chords and keystrokes, and think how you could make it easier.

Some quick examples to pay attention to:

• Common chords: (zoom in/out, next/prev tab).
• common modifiers like Control often require a hand twist and finger curl.
• parentheses and common special characters sometimes are quite a pinky reach.

A great place to start is the recommendations made by Steve Losh in Modern Space Cadet: Control moved to Caps Lock, Shifts for parentheses.

If you are like me… I've gone wild over the last decade. But baby steps! I started with moving Control and arrows to hjkl. 🤷

Get In Nerd, We're Going Shopping

It's really hard to have an "evergreen" guide to what keyboards are good… there's new ones coming out all the time! Here's some guidelines:

• check out reddit.com/r/ergomechkeyboards to see up and coming projects.
• it needs to be reprogrammable… or you can't reap the benefit.
• if your issues are related to wrist alignment, (inflammation of tendons and soft tissues,) then a keyboard that realigns your wrists naturally like a split or "bent" keyboard can help.
• compare layouts using the split keyboard comparing tool by jhelvy. Print off 1:1 copies of layouts on a piece of paper to put your hands on the shapes: different hands prefer different positions of thumb clusters.
• at first you'll want to keep your number row and have lots of keys, but the more keys means more finger reaching and more money to pay for switches.
• there are limited keyboards available with fancy metal cases. Buy something simple and cheap.

If you still just want a "what should I buy:" I recommend the Keyboardio Atreus as a starter. It's got enough keys for most people, it's relatively inexpensive, and supports visual reprogramming.

If we hung out for a day, I'd…

1. probably have my journal out in front of me during our coffee.
2. ask you what you are learning this week.
3. give thanks for my amazing wife.
4. find a way to show you pictures of my kids.
5. teach you how to roll top a chip bag without a clip.
6. demonstrate tying the best shoelace knot.
7. ask you if you want to see weird window management tricks.
8. beg you to use a password manager.
9. shyly use this weird keyboard and kinda hope you'd notice.
10. text you that funny video about design by committee from Pentagon Papers as an weird encouragement.
11. recommend using a Clipboard history manager.
12. jot down something we said into Drafts.app because I want to write and expand on it later.
13. talk about either The Devil and The White City or In The Garden of Beasts.
14. rave about how Obsidian Canvas helps me connect things long term.
15. show stuff I do with my homescreen.
16. encourage you to give sketchnotes a try.
17. be confused by my own live demo about nix.
18. recommend learning how to coil a cable properly. (I spent too long not knowing this.)
19. attempt to explain why time-blocking is so helpful for me.
20. endorse setting up your car's mirrors correctly.
21. lament the loss of a view source Web and encourage you to build an indieweb site.
22. involuntary podcast about weak signals and Left of Bang.
23. eventually try to explain why I love Till We Have Faces, and ultimately fail. Again.
24. listen to your favorite rant… and encourage you to write a blog post about it.
25. be curious about any productivity practices you have particular to you.
26. want to know your favorite books.
27. ultimately make a C.S. Lewis or Tolkien reference.
28. write down your prayer requests, and maybe pray for you right then.
29. be curious how you would think about developing your family values with the question: "What are the attributes and values that only you can teach your children?"
30. embarrassedly chuckle and start a conversation with "I've an unfinished essay where I argue..."
31. be very pleased if you also liked bluegrass music... but not required.
32. try to restrain myself from talking for thirty minutes on creativity, AI, or whatever else it is that I'm currently essay-ing.
33. be interested in what you keep in your EDC bag.
34. find my thoughts improved and connected by our conversation... and want to write it all down so I don't lose it.
35. send you a follow-up email with links to all the random stuff I mentioned so that you wouldn't have to remember.

Oh and I recently had a birthday. 🥳

The robots.txt for evantravers.com is now generated on site build from darkvisitor.com's API.

Pretty simple change. I added this to the helpers block in my middleman's config.rb:

helpers do
  # […]
  def dark_visitors
    headers = {
      Authorization: 'Bearer <secret token>'
    }

    body = {
      agent_types: ['AI Assistant', 'AI Data Scraper', 'AI Search Crawler', 'Undocumented AI Agent']
    }

    data = URI.encode_www_form(body)

    endpoint = URI('https://api.darkvisitors.com/robots-txts').freeze
    response = Net::HTTP.post(endpoint, data, headers)

    response.body
  end
end

Then I replaced robots.txt with robots.txt.erb and added:

<%= dark_visitors %>

That's it!

Of course, adding this to my robots.txt is a little bit like hanging a sign on my house that says please don't steal my stuff, it only works for "honorable thieves," and that's a bit of a oxymoron.

Why does a child ask his parent for a snack? Because he knows the parent has the power to grant that request. He will even move towards the fridge as he asks… knowing the answer ahead of time.

Our family prayer requests are written on 3x5 cards and magneted to our kitchen fridge. We put them there because it's convenient space in our home, but it also stands for more: our Heavenly Father has the power to grant the request.

[16] Let us then with confidence draw near to the throne of grace, that we may receive mercy and find grace to help in time of need. (Hebrews 4:16)

We have a father that delights to give good gifts¹. With childlike confidence we can walk towards the fridge.

The fools who write the textbooks of advanced mathematics — and they are mostly clever fools — seldom take the trouble to show you how easy the easy calculations are. On the contrary, they seem to desire to impress you with their tremendous cleverness by going about it in the most difficult way.

Being myself a remarkably stupid fellow, I have had to unteach myself the difficulties, and now beg to present to my fellow fools the parts that are not hard. Master these thoroughly, and the rest will follow. What one fool can do, another can.

At first I thought this was a cheeky blog in Dickensian style, but it turns out that it was published in 1910! I read the first few chapters and my goodness does this "fool" cut to the point and make the 2010s textbook I had in college look a "clever fool."

Prologue | Calculus Made Easy - calculusmadeeasy.org

I was really surprised at both how easily my SASS converted to CSS… and by the advantages that I found while doing the refactor. (If you are a code-nerd and want to read the diff go for it, but otherwise read on!)

Some quick notes from the transition:

Nesting just works

I thought that I'd take a shortcut by simply copy-pasting the SASS-rendered CSS into a new CSS file. The default SASS settings "flattens" the SASS-nesting into a single level CSS file… but then I realized that CSS nesting exists and is basically 1:1 equivalent. 🤯

There's nothing much to report. I just used the exact same nesting structure for both and it worked.

OKLCH and Variables

I converted all my colors to OKLCH, first by just converting them out of hex using the Raycast color picker extension and then modifying them slightly.

I would like to explore a new palette for my blog, but for now I "burned" the existing results of any computed sass functions (like lighten(#8aace1, 30%)) to a OKLCH color. Then I computed some equivalent colors using calc():

:root {
  --blue-l: 56.3%;
  --blue-c: 0.152;
  --blue-h: 259deg;
  --blue:   oklch(var(--blue-l) var(--blue-c) var(--blue-h));

  --blue-100: oklch(calc(var(--blue-l) + 10%) calc(var(--blue-c) * 0.9) var(--blue-h));
  --blue-200: oklch(calc(var(--blue-l) + 20%) calc(var(--blue-c) * 0.8) var(--blue-h));
}