ISP</th>	Price ($)</th>	Notes</th></tr></thead>
Centra</a></td>	`43.95</code></td>`	Appear more honest on their Broadband label (showing 841Mbps/884Mbps down/up, rather than 1000Mbps).</td></tr>
ETS</a></td>	`45.00</code></td>`	Up to 10Gbps.</td></tr>
Fusion Networks</a></td>	`45.00</code></td>`	1Gb is their fastest plan.</td></tr>
3wave</a></td>	`48.00</code></td>`	</td></tr>
SenaWave</a></td>	`48.00</code></td>`	Very sparse on details.</td></tr>
Voonami</a></td>	`48.95</code></td>`	Comes with a free static IP on request. Also offers colo services. 2.5 Gbps fastest.</td></tr>
SumoFiber</a></td>	`49.95</code></td>`	Appear slightly more honest, stating 980 Mbps up/down.</td></tr>
IntelliPop</a></td>	`49.95</code></td>`	</td></tr>
ConnectFast</a></td>	`53.95</code></td>`	Only a single plan: 1Gb</td></tr>
FiberNet</a></td>	`53.95</code></td>`	1Gb is their fastest plan, but they have infra (i.e., offers colo services).</td></tr>
XMission</a></td>	`54.00</code></td>`	Runs an extra firewall layer than can break some websites.</td></tr>
Miles Broadband</a></td>	`54.00</code></td>`	</td></tr>
WiFiPros</a></td>	`55.00</code></td>`	I dislike the company name.</td></tr>
Advanced Stream</a></td>	`55.00</code></td>`	10 TB data cap, others are unlimited. Honest with specific speeds.</td></tr>
Brigham</a></td>	`58.95</code></td>`	Wordpress site, sloppy errors like discrepancies in pricing.</td></tr>
InfoWest</a></td>	`80.00</code></td>`	Unclear to me if this $80 includes UTOPIA’s $30. Probably?</td></tr>
Beehive Broadband</a></td>	N/A</td>	Hard to find pricing is a dark pattern.</td></tr>
Rise Broadband</a></td>	N/A</td>	Couldn’t find price.</td></tr>
Fastel</a></td>	N/A</td>	Sketchily sparse website and no pricing. Dark patterns.</td></tr> </tbody></table> At some point, I want to go through and learn more about their nuances. For example, XMission has an annoying trait of running their own firewall, which breaks websites occasionally. But, they also run their own datacenters and have some nice peering agreements that likely improve latency and performance.</p> Here’s a UTOPIA-provided comparison sheet</a>, too. There is some discrepancy in the pricing and the ISPs themselves, though.</p> Variable fonts and italics across browsers 2025-05-25T00:00:00+00:00 I’m a big fan of Atkinson Hyperlegible Next</a> and Berkeley Mono</a> (TX-02). It is my opinion that they both look great, unique, and provide valuable legibility features.</p> I recently refactored this site to use the variable, web versions of these fonts. I was happy that I now had only a single `@font-face</code> definition, not a handful, and went on my way. (I had haphazardly picked up these parameters on the Internet somewhere.)</p>` @font-face</span> {</span></span> font-family</span>:</span> 'Berkeley Mono'</span>;</span></span> src</span>:</span> url</span>(</span>'../fonts/Berkeley Mono Variable.woff2'</span>)</span> format</span>(</span>'woff2'</span>);</span></span> font-stretch</span>:</span> 60 100</span>;</span></span> font-weight</span>:</span> 100 900</span>;</span></span> font-style</span>:</span> oblique</span> -16</span>deg</span> 0</span>deg</span>;</span></span> font-feature-settings</span>:</span> calt</span>;</span></span> font-variant-ligatures</span>:</span> contextual</span>;</span></span> }</span></span> </span> @font-face</span> {</span></span> font-family</span>:</span> 'Atkinson Hyperlegible Next'</span>;</span></span> src</span>:</span> url</span>(</span>'../fonts/AtkinsonHyperlegibleNextVF-Variable.woff2'</span>)</span> format</span>(</span>'woff2'</span>);</span></span> font-weight</span>:</span> 100 900</span>;</span></span> font-style</span>:</span> oblique</span> -16</span>deg</span> 0</span>deg</span>;</span></span> }</span></span></code></pre> Then, just recently, I realized that my italics were broken on this site for weeks! They worked on Chrome as I had it configured. They did not work on Firefox.</p> I tried a few things.</p> First, I tried duplicating the @font-face</code> definition, but with font-style: italic</code>. This made it work on Firefox, but broke Chrome.</p> I then found there is a new way to specify italics for variable web fonts, specifically (assuming it is supported by the font): font-variation-settings</code>. In the case of Atkinson Hyperlegible Next, I could get my italics looking right on both Firefox and Chrome by adding the following CSS.</p> em</span> {</span></span> font-variation-settings</span>:</span> "ital"</span> 1</span>;</span></span> font-synthesis</span>:</span> none</span>;</span></span> }</span></span></code></pre> But, this didn’t work for Berkeley Mono.</p> I also tried things like using woff2-variations</code> in my @font-face</code> definitions and other little tweaks to no avail.</p> Finally, after more experimentation, I was pleasantly surprised that I could get everything working just by simplifying</em>.</p> @font-face</span> {</span></span> font-family</span>:</span> 'Berkeley Mono'</span>;</span></span> src</span>:</span> url</span>(</span>'../fonts/Berkeley Mono Variable.woff2'</span>)</span> format</span>(</span>'woff2'</span>);</span></span> font-stretch</span>:</span> 60 100</span>;</span></span> font-weight</span>:</span> 100 900</span>;</span></span> font-feature-settings</span>:</span> calt</span>;</span></span> font-variant-ligatures</span>:</span> contextual</span>;</span></span> }</span></span> </span> @font-face</span> {</span></span> font-family</span>:</span> 'Atkinson Hyperlegible Next'</span>;</span></span> src</span>:</span> url</span>(</span>'../fonts/AtkinsonHyperlegibleNextVF-Variable.woff2'</span>)</span> format</span>(</span>'woff2'</span>);</span></span> font-weight</span>:</span> 100 900</span>;</span></span> }</span></span></code></pre> I dropped the (likely incorrect) font-style</code> attribute. No need for the em</code> class override, now, either.</p> With that, I have italics</em>, both for my normal font, and for my monospace </code></em> font that work on both Firefox and Chrome. All I needed to do was delete the right two lines.</p> Performance gains of undervolting a T480s 2025-05-23T00:00:00+00:00 I have been using a self-refurbished Thinkpad X230</a> for quite a while as a personal machine. I believe in the benefits of continuing to use old laptops [1</a>, 2</a>, 3</a>]. However, recently, I’ve started to need to use a laptop to do presentations frequently, and the HDMI port on my X230 is not functioning fully, resulting in distorted colors and other distracting artifacts. I might try and repair that, someday.</p> However, due to pressing need, I instead picked up a used T480s</a> from a good friend, which had a working HDMI port.</p> Over the first couple days of use, I noticed that this thing ran hot</em>. Sure, I have the i7-8650u</code> version, but the fans were spinning up far more than I’d like, and CPU temps would frequently exceed 95 °C for bursts at a time.</p> Naturally, I did a little digging.</p> It turns out, Linux and the T480s have a longstanding problem! I don’t understand the problem well enough to explain it here. But, essentially, people were seeing throttling and temperature issues with these machines on Linux (but not Windows). To be clear, this issue was found on an old Linux kernel (4.15, I’m on 6.14). I do not know if this specific problem is affecting me. However, through this, I learned about a fun tool for undervolting a T480s: throttled</code></a>.</p> Even if this issue was resolved in newer kernels, I imagined that some undervolting could still help my thermals and performance. So, I tried it. In addition, to give the attempt the best chance it had, I also replaced the thermal paste with fresh Duronaut</a>.</p> I was surprised to find a 12% improvement</strong> in single-core performance and a 24% improvement</strong> in multi-core on Geekbench 6!</p> Metric</th> Original</a></th> Optimized</a></th> Change (%)</th></tr></thead> Single-core</td> 1341</code></td> 1499</code></td> +11.8</code></td></tr> Multi-core</td> 3989</code></td> 4948</code></td> +24.0</code></td></tr> </tbody></table> </div> The laptop runs much cooler, and the fans spin up much less. It’s much more pleasant to use.</p> I ultimately landed on the following undervolt for this machine. (Remember, each chip is different, you might not be able to use these values.)</p> # All voltage values are expressed in mV and MUST be negative (i.e. undervolt)!</span></span> [</span>UNDERVOLT</span>]</span></span> # CPU core voltage offset (mV)</span></span> CORE: -135</span></span> # Integrated GPU voltage offset (mV)</span></span> GPU: -105</span></span> # CPU cache voltage offset (mV)</span></span> CACHE: -135</span></span> # System Agent voltage offset (mV)</span></span> UNCORE: -105</span></span> # Analog I/O voltage offset (mV)</span></span> ANALOGIO: 0</span></span></code></pre> What a satisfying way to squeeze a little more performance out of a still-great laptop.</p> Steel man arguments, or arguing intelligently 2025-03-22T00:00:00+00:00 I’m a big fan of the idea of “steel man” argument. However, I’ve found that this term is far less widely known than its “straw man” counterpart. I’ve heard some people just call this “arguing intelligently”.</p> Here are two good definitions if you’re unfamiliar with the idea. First, Wikipedia’s for the more abstract definition, and then Robin Sloan’s practical example.</p> Wikipedia</a>:</p> A steel man argument (or steelmanning) is the opposite of a straw man argument. Steelmanning is the practice of applying the rhetorical principle of charity through addressing the strongest form of the other person’s argument, even if it is not the one they explicitly presented. Creating the strongest form of the opponent’s argument may involve removing flawed assumptions that could be easily refuted or developing the strongest points which counter one’s own position. Developing counters to steel man arguments may produce a stronger argument for one’s own position.</p> </blockquote> Robin Sloan</a></p> There are two debaters, Alice and Bob. Alice takes the podium, makes her argument. Then Bob takes her place, but before he can present his counter-argument, he must summarize Alice’s argument to her satisfaction — a demonstration of respect and good faith. Only when Alice agrees that Bob has got it right is he permitted to proceed with his own argument — and then, when he’s finished, Alice must summarize it to his satisfaction.</p> The first time I saw one of these debates, it blew my mind.</p> </blockquote> Or, as Stephen R. Covey put it: “Seek first to understand, then to be understood</a>”.</p> Imagine if the default mode of debate was like this. A tool for persuasion, consideration, exploration, and achieving consensus (or at least clearly understanding the shape of disagreement). Instead, culturally, we’re more used to debate as a stage for name-calling, politics, distraction, point-scoring, and drama.</p> Next time you’re debating something, consider arguing more intelligently, and treating the other parties with that same human respect.</p> Sharing intro cards 2025-03-16T00:00:00+00:00 Those who know me know that I am fairly introverted. But, I am also someone who strongly values community, and thinks there are huge benefits to be had by building or connecting to one.</p> A big part of building or integrating into communities is getting to know the people in them. Some people have a natural talent for this. Others have built that skill through many years of deliberate practice. There are also some people who use software to manage and track these relationships “personal CRM”-style (e.g., Monica</a>, or really detailed notes in Google Contacts).</p> I am currently none of these people.</p> But, I would like to build the skill.</p> One reason knowing people is valuable is that it helps facilitate connection. “Oh, I know X</code> is in that industry, let me connect you.” “The Y</code> family has kids that line up with your kids age and go to Z</code> Junior High, too.” “Oh A</code> used to live right around there, let’s ask them for advice.” These types of serendipitous connections can build strong bonds and strengthen a community, but you can only make them if you know enough.</p> To that end, I think “intro cards” are an interesting idea. Imagine that when you moved in somewhere, or went to a new neighborhood meeting or church event, or met with the other parents for your kid’s soccer team, you could get a small physical</em> card of pertinent information about these new people you met.</p> In big social settings like that, where you’re meeting a lot of new people, it’s very easy (for me, anyway) to have forgotten the names of the people I just</em> talked to. Now, instead imagine that throughout the event, you were exchanging intro cards, something like the following.</p> </a> An example intro card, 3"×5" sized. </figcaption> </figure> During the event, you could focus completely on the current conversations, knowing you already have some notes provided to you to recall the previous ones.</p> Is the concept so wild? In Japan, there is a whole interesting culture around exchanging business cards</a>. In the US, we rarely do so. A small Japanese town recently went even further, making a whole trading card game</a> for the middle-aged members of their town, connecting the youth to older generations in a heartwarming way.</p> Naturally, these intro cards might include personal information you probably wouldn’t put on the Internet, but might want to provide to people depending on the context. So, of course, you should tune the content to the purpose. You should also feel things out first, before you just go handing these to everyone. For example, in the context of introducing yourself to neighbors, maybe it is something like Bart’s above. If it’s meeting coworkers, maybe it highlights parts of the system you’re familiar with, or your favorite software or languages. If it’s a hobby group, maybe it highlights more about your specific niche interests.</p> I’ve started trying this idea out in a few scenarios, to positive reception. To make it easy, I just print these on 3“×5“ index cards at home rather than deal with producing actual cards. An example Typst document for it is included below.</p> Source Code: Example Intro Card in Typst</a></summary> #set</span> text</span>(</span>font</span>:</span> "Berkeley Mono"</span>)</span></span> #set</span> text</span>(</span>9pt</span>)</span></span> #set</span> par</span>(</span>leading</span>:</span> 0.35em</span>)</span></span> #set</span> page</span>(</span></span> width</span>:</span> 3in</span>,</span></span> height</span>:</span> 5in</span>,</span></span> margin</span>:</span> 0.25in</span>,</span></span> // background: rect(width: 100%, height: 100%, stroke: 1pt + black),</span></span> )</span></span> </span> // Placed here because these are reused to make links</span></span> #let</span> telephone_number</span> =</span> "xxx-xxx-xxxx"</span></span> #let</span> email_address</span> =</span> "xxxx@example.com"</span></span> #let</span> website</span> =</span> "www.example.com"</span></span> </span> #</span>grid</span>(</span></span> columns</span>:</span> 100%</span>,</span></span> rows</span>: (</span>1%</span>,</span> 1%</span>,</span> 40%</span>,</span> 2%</span>,</span> 2%</span>,</span> 1fr</span>),</span></span> gutter</span>:</span> 1.0mm</span>,</span></span> grid.</span>cell</span>(</span></span> text</span>(</span>size</span>:</span> 11pt</span>,</span> weight</span>:</span> "bold"</span>,</span> "Bart Simpson"</span>),</span></span> align</span>: (</span>left</span> +</span> horizon</span>),</span></span> ),</span></span> [],</span></span> grid.</span>cell</span>(</span></span> block</span>(</span>clip</span>:</span> true</span>,</span> radius</span>:</span> 3mm</span>,</span> image</span>(</span>"bart.png"</span>)),</span></span> align</span>: (</span>center</span> +</span> horizon</span>),</span></span> ),</span></span> [],</span></span> grid.</span>hline</span>(</span>stroke</span>: (</span>paint</span>:</span> gray</span>,</span> thickness</span>:</span> 0.75pt</span>,</span> cap</span>:</span> "round"</span>),</span> y</span>:</span> 4</span>),</span></span> [],</span></span> grid</span>(</span></span> columns</span>: (</span>20%</span>,</span> 1fr</span>),</span></span> column-gutter</span>:</span> 2mm</span>,</span></span> row-gutter</span>:</span> 2.20mm</span>,</span></span> // stroke: 1pt + silver,</span></span> grid.</span>cell</span>([</span>age</span>],</span> align</span>:</span> right</span>),</span> grid.</span>cell</span>(</span></span> [</span>Born in XXXX</span>],</span></span> align</span>:</span> left</span>,</span></span> ),</span></span> grid.</span>cell</span>([</span>family</span>],</span> align</span>:</span> right</span>),</span> grid.</span>cell</span>(</span></span> [</span>Spouse: Susan </span>\</span></span> Children: Johnny (M, XXXX)</span>],</span></span> align</span>:</span> left</span>,</span></span> ),</span></span> grid.</span>cell</span>([</span>rel-to</span>],</span> align</span>:</span> right</span>),</span> grid.</span>cell</span>(</span></span> [</span>Marge (mom), Homer (dad), Lisa (sis), Maggie (sis)</span>],</span></span> align</span>:</span> left</span>,</span></span> ),</span></span> grid.</span>cell</span>([</span>from</span>],</span> align</span>:</span> right</span>),</span> grid.</span>cell</span>(</span></span> [</span>New York, NY (</span>--</span>XXXX) </span>\</span> Chicago, IL (</span>--</span>XXXX)</span>],</span></span> align</span>:</span> left</span>,</span></span> ),</span></span> grid.</span>cell</span>([</span>job</span>],</span> align</span>:</span> right</span>),</span> grid.</span>cell</span>(</span></span> [</span>Manager at </span>#</span>link</span>(</span>"https://www.example.com"</span>)</span>[Example</span>]</span>]</span>,</span></span> align</span>:</span> left</span>,</span></span> ),</span></span> grid.</span>cell</span>([</span>edu</span>],</span> align</span>:</span> right</span>),</span> grid.</span>cell</span>(</span></span> [</span>NYU (BS in PR, 'XX)</span>],</span></span> align</span>:</span> left</span>,</span></span> ),</span></span> grid.</span>cell</span>([</span>email</span>],</span> align</span>:</span> right</span>),</span> grid.</span>cell</span>(</span></span> link</span>(</span>"mailto:"</span> +</span> email_address</span>,</span> email_address</span>),</span></span> align</span>:</span> left</span>,</span></span> ),</span></span> grid.</span>cell</span>([</span>phone</span>],</span> align</span>:</span> right</span>),</span> grid.</span>cell</span>(</span></span> link</span>(</span>"tel:"</span> +</span> telephone_number</span>,</span> telephone_number</span>),</span></span> align</span>:</span> left</span>,</span></span> ),</span></span> grid.</span>cell</span>([</span>website</span>],</span> align</span>:</span> right</span>),</span> grid.</span>cell</span>(</span></span> link</span>(</span>"https://"</span> +</span> website</span>,</span> website</span>),</span></span> align</span>:</span> left</span>,</span></span> ),</span></span> [],</span> grid.</span>cell</span>(</span></span> text</span>(</span>size</span>:</span> 5pt</span>,</span> style</span>:</span> "italic"</span>)[</span>v25.03</span>],</span> // calver</span></span> align</span>:</span> right</span> +</span> top</span>,</span></span> ),</span></span> )</span></span> )</span></span></code></pre></details>

Luke Hsiao's blog

Omarchy on an ASUS CN60 Chromebox

2026-07-06T00:00:00+00:00

Background
If you haven’t noticed, AI and the datacenter build-out have taken a real toll on personal computing. Prices of RAM, NVMe, GPUs, and more have grown astronomically. As a point-in-time example, the desktop workstation I built in 2023</a> for $2075.29 (including tax) now costs $3459.48 (before tax). That is nearly a 67% increase before tax!</p>
Even before personal computing started getting so expensive, I’ve always been a fan of reducing and reusing old electronics, as have many others [1</a>, 2</a>, 3</a>]. But I’m also practical. There’s a moving threshold: machines older than that often aren’t worth the extra work, or are too slow even for light use. That threshold is different for everyone. When the stars align, it feels great to get some use out of an old computer that would’ve otherwise been destined to be e-waste.</p>

An ASUS CN60 Chromebox
Recently, I happened on an old ASUS CN60 Chromebox from March 2014. This is a dated x86_64 machine that came configured with an Intel Celeron 2955U, 2GB DDR3-1600, and a 16GB SATA SSD. This machine stopped receiving ChromeOS updates in September 2019</a>. (Side rant: this artificial EOL for Chrome devices is responsible for so much e-waste it hurts to think about.)</p>
I have fond memories of using an ASUS C720 Chromebook for most of my college degree, running Linux via crouton.</p>
I was curious to see how running Linux felt on these old Chromeboxes, and I was pleasantly surprised!</p>

Installing new firmware
The world of Linux on Chrome devices had moved quite a bit since I last tinkered. For example, I learned that there is now a nice UEFI Full ROM replacement via MrChromebox.tech</a>. In the case of the CN60 (HWID `PANTHER</code>), this was as easy as removing the write-protect screw.</p>`
</a> The location of the write-protect screw, courtesy MrChromebox.tech. </figcaption> </figure> I followed the instructions (Developer Mode, terminal, run the firmware utility script) and it all worked first try.</p> Tip</span> </div> I ran into one unique issue during this process: the CN60 does not seem to be able to connect to a high-resolution display on initial boot. For example, connecting it to my 4K monitor via HDMI or DisplayPort resulted in just a black screen, leaving me unable to get into Developer Mode. Connecting it to an older 1080p monitor worked just fine.</p> </div> </div>Installing OmarchyWith the firmware replacement done, I moved on to installing Omarchy. My first attempt at this failed: I ran out of disk space. It turns out 16GB is not enough for the Omarchy installer!</p> Because I wanted to see how my “normal” distribution worked (rather than some intentionally stripped-down, lightweight distro), I got a 64GB SATA SSD off eBay for $10 shipped and tried again.</p> Tip</span> </div> This is fairly specific to Omarchy. A more lightweight distribution may work without a higher-capacity SSD.</p> </div> </div> </a> After the SSD upgrade. </figcaption> </figure> </a> It took 12 minutes, 20 seconds to install. </figcaption> </figure> No issues!</p> After a reboot, I was once again surprised that everything just worked.</p> </a> Fastfetch output in Omarchy. </figcaption> </figure> The machine is quite slow; it scores about 280/420 single-/multi-core on Geekbench 6</a>. But slow is enough for some use cases. I also suspect adding RAM for dual-channel memory would noticeably speed things up.</p> Wrapping upOf course, this machine is slow and only has 2GB of RAM (though this is upgradable). I’m not going to use it as a dev machine any time soon. But for some use cases like a silent garage PC for watching YouTube videos, this still works excellently.</p> The process was easy, especially compared to someone else’s experience installing Omarchy on a Chromebook</a>.</p> Linux on the desktop has come a long way, and I’m impressed by the custom firmware process. I’ll definitely be keeping my eye out for other ways to make use of discarded ChromeOS hardware in the future.</p> If you have old hardware, I hope you give it a chance for a second life, whether that’s putting it to use yourself or passing it on cheap (or free!) to someone else.</p>



Tip: creating a recurring 5th Sunday event in Google Calendar
2026-05-03T00:00:00+00:00
I occasionally have the need to create a recurring calendar event on a cadence that isn’t natively supported by Google Calendar.
The most prominent example of this is an event that occurs on every 5th Sunday of the month, if one exists.
This is very different than the “last” Sunday of the month.</p>
One nice workaround that seems to work well is to create an ICS file with the native 5th Sunday syntax and import it.</p>
Here’s an example file for an all-day event.</p>
BEGIN:VCALENDAR</span></span>
VERSION:2.0</span></span>
PRODID:-//x//EN</span></span>
BEGIN:VEVENT</span></span>
UID:5sun@x</span></span>
DTSTAMP:20260503T000000Z</span></span>
DTSTART;VALUE=DATE:20260531</span></span>
RRULE:FREQ=MONTHLY;BYDAY=5SU</span></span>
SUMMARY:5th Sunday Event</span></span>
END:VEVENT</span></span>
END:VCALENDAR</span></span></code></pre>
The secret is the RRULE:FREQ=MONTHLY;BYDAY=5SU</code> rule, which expresses the logic we want.</p>
Here is another example for an event with a specific time window.</p>
BEGIN:VCALENDAR</span></span>
VERSION:2.0</span></span>
PRODID:-//x//EN</span></span>
BEGIN:VEVENT</span></span>
UID:5sun@x</span></span>
DTSTAMP:20260503T000000Z</span></span>
DTSTART;TZID=America/Denver:20260531T093000</span></span>
DTEND;TZID=America/Denver:20260531T103000</span></span>
RRULE:FREQ=MONTHLY;BYDAY=5SU</span></span>
SUMMARY:5th Sunday Event</span></span>
END:VEVENT</span></span>
END:VCALENDAR</span></span></code></pre>
Copy-paste the appropriate data into a text file with a .ics</code> file extension and import it into Google Calendar, then you can update the title and whatnot as you please.</p>


Using a USB switch as a full KVM
2026-03-31T00:00:00+00:00
I just found a brilliantly easy quality-of-life improvement I needed to share: display-switch</code></a>.</p>
ContextI’m the type of person who invests in interfaces</a>.
Consequently, I generally like to work at my desk, with my chosen peripherals and tools.
Typically, the two most common computers I use there are a work-issued MacBook, and a personal workstation</a> running Linux.
I want to switch between them without dealing with a lot of plugging and unplugging of cables.</p>
For years, my solution was to use a USB switch with my monitor plugged into both computers simultaneously (e.g., one via USB-C, one via DisplayPort).
When I’d switch, I’d click my USB switch to flip my five peripherals (mouse, keyboard, webcam, USB audio interface, YubiKey).
Then, I’d toggle my monitor’s menu to switch inputs.
This is fine.</p>
The USB switch is nice because even if a monitor has built-in KVM functionality, it rarely has enough ports for my use case.
They also often have fatal design flaws that make them not very functional.</p>
Today, my USB switch broke.
Naturally, I took it as an opportunity to revisit the space and see how I could improve my setup.</p>
What I foundFirst, I discovered UGREEN</a> makes 2-in, 7-out USB 3.2 switches now.
I picked one up and it’s been great.
I even have two free USB ports now.</p>
Second, and the motivation for this blog post, there are cool software solutions for switching display inputs without touching your monitor settings!</p>
If your monitor supports DDC/CI</a> (display data channel/command interface), then it supports being sent commands via software to switch inputs.
With that, you can wire up display-switch</code>, and now your cheap (relative to full-fledged KVMs) USB switch can effectively function as a full KVM, switching your monitor input, too, at the press of a single button!</p>
Simply follow the guide on the display-switch</code> repository README</a>.</p>
That said, I will leave you with a few tips not covered by the README.</p>
Tip: use display-switch</code> for monitors normal KVMs don’t supportMost KVMs, even higher-end ones, do not support very high resolution displays.
For example, most will do 4K@60Hz or similar.
If you have a higher resolution or refresh-rate monitor, you might have thought that you can’t enjoy the KVM convenience.
display-switch</code> works by assuming you are just directly wired into your monitor on both computers, so this isn’t a problem!</p>
Tip: use the brew</code> path for the service on macOSOn macOS, it’s simpler to just brew install haimgel/tools/display_switch</code>.
But, if you do, the README leaves you with a footgun when setting it up to run at startup.
Specifically, the example dev.haim.display-switch.daemon.plist</code></a> assumes you have installed it manually and moved it to /usr/local/bin/display_switch</code>.
Instead, just install it with brew</code> and update that path to be accurate:</p>
<?</span>xml</span> version</span>=</span>"1.0"</span> encoding</span>=</span>"UTF-8"</span>?></span></span>
<!DOCTYPE</span> plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd"</span>></span></span>
<</span>plist</span> version</span>=</span>"1.0"</span>></span></span>
    <</span>dict</span>></span></span>
        <</span>key</span>></span>Label</span></</span>key</span>></span></span>
        <</span>string</span>></span>dev.haim.display-switch.daemon</span></</span>string</span>></span></span>
        <</span>key</span>></span>Program</span></</span>key</span>></span></span>
        <</span>string</span>></span>/opt/homebrew/bin/display_switch</span></</span>string</span>></span></span>
        <</span>key</span>></span>RunAtLoad</span></</span>key</span>></span></span>
        <</span>true</span>/></span></span>
    </</span>dict</span>></span></span>
</</span>plist</span>></span></span></code></pre>Tip: find USB device IDs without lsusb</code>For unknown reasons, I couldn’t get lsusb</code> to work on macOS.
If you find yourself in the same boat, here’s a simple way to get the same information.</p>
I suggest uv</code></a> so you don’t need to deal with Python virtualenvs manually:</p>
uv</span> run --with pyusb python</span></span></code></pre>
Then, paste this into your interpreter:</p>
import</span> usb</span>.</span>core</span></span>
</span>
for</span> dev</span> in</span> usb</span>.</span>core</span>.</span>find</span>(</span>find_all</span>=</span>True</span>):</span></span>
    try</span>:</span></span>
        name</span> =</span> f</span>"</span>{</span>dev</span>.</span>manufacturer</span>}</span> — </span>{</span>dev</span>.</span>product</span>}</span>"</span></span>
    except</span> Exception</span>:</span></span>
        name</span> =</span> ""</span></span>
    print</span>(</span>f</span>"</span>{</span>dev</span>.</span>idVendor</span>:04x</span>}</span>:</span>{</span>dev</span>.</span>idProduct</span>:04x</span>}  {</span>name</span>}</span>"</span>)</span></span></code></pre>
This should get you lsusb</code>-like output:</p>
046d:0892  None — HD Pro Webcam C920</span></span>
1532:0085  Razer — Razer Basilisk V2</span></span>
07fd:000b  MOTU — M2</span></span>
05e3:0610  GenesysLogic — USB2.1 Hub</span></span>
04fe:0021  PFU Limited — HHKB-Hybrid</span></span>
05e3:0625  GenesysLogic — USB3.2 Hub</span></span>
1050:0406  Yubico — YubiKey FIDO+CCID</span></span>
05e3:0625  GenesysLogic — USB3.2 Hub</span></span>
05e3:0610  GenesysLogic — USB2.1 Hub</span></span>
0b95:1790  ASIX — AX88179A</span></span>
0b05:0411  Generic — USB3.2 Hub</span></span>
0b05:0c23  Generic — USB2.1 Hub</span></span>
0b05:1c55  Cypress Semiconductor — DMC Device</span></span>
8087:0b40  Intel Corporation. — USB3.0 Hub</span></span>
1d5c:5801  Fresco Logic, Inc. — USB2.0 Hub</span></span></code></pre>Tip: use cargo</code> to install on LinuxFor Linux, rather than downloading releases or building from source manually, use cargo</code>.
Doing so will let you use tools like cargo-update</code></a> to easily keep it up to date with minimal work (via cargo install-update --all --git</code>).</p>
cargo</span> install --locked --git https://github.com/haimgel/display-switch</span></span></code></pre>
Like the brew</code> case for macOS, you will now need to change the default $XDG_CONFIG_HOME/systemd/user/display-switch.service</code> example to have the right path.
By default it will look like $HOME/.cargo/bin/display_switch</code>.</p>
[Unit]</span></span>
Description</span>=</span>Display switch via USB switch</span></span>
</span>
[Service]</span></span>
# update this path</span></span>
ExecStart</span>=</span>/home/youruser/.cargo/bin/display_switch</span></span>
Type</span>=</span>simple</span></span>
StandardOutput</span>=</span>journal</span></span>
Restart</span>=</span>always</span></span>
</span>
[Install]</span></span>
WantedBy</span>=</span>default.target</span></span></code></pre>Tip: use on_usb_disconnect</code> to reduce latencyFinally, display-switch</code> supports an on_usb_disconnect</code> configuration:</p>
usb_device = "1050:0407"</span></span>
on_usb_connect = "Hdmi1"</span></span>
on_usb_disconnect = "Hdmi2"</span></span></code></pre>
But the README notes:</p>

The optional on_usb_disconnect</code> settings allows to switch in the other direction when the USB device is disconnected.
Note that the preferred way is to have this app installed on both computers.
Switching “away” is problematic: if the other computer has put the monitors to sleep, they will switch immediately back to the original input.</p>
</blockquote>
While this is true, if your monitor and setup support it, using on_usb_disconnect</code> can significantly reduce the latency of the switch.</p>
Without it, the chain of delays is:</p>
Push button</span></span>
    ↓</span></span>
USB devices switch</span></span>
    ↓</span></span>
2nd computer detects new USB devices</span></span>
    ↓</span></span>
2nd computer runs display-switch</span></span>
    ↓</span></span>
Monitor switches input</span></span>
    ↓</span></span>
2nd computer ready to use</span></span></code></pre>
With it, the monitor input switch and the USB handoff happen in parallel.</p>
 Push button</span></span>
      │</span></span>
      ├─────────────────────────────────┐</span></span>
      ↓                                 ↓</span></span>
  USB devices switch         1st computer runs display-switch</span></span>
      ↓                                 ↓</span></span>
  2nd computer detects           Monitor switches input</span></span>
  new USB devices                       │</span></span>
      │                                 │</span></span>
      └──────────────┬──────────────────┘</span></span>
                     ↓</span></span>
             2nd computer ready to use</span></span></code></pre>SummaryIf you frequently switch between two computers at your desk, you don’t need an expensive KVM.
A USB switch paired with display-switch</code></a> gets you the same convenience for a fraction of the price.
It’s a $500+ KVM-like experience for the cost of an $80 USB switch and a free tool.
I’m all about software that reduces friction and makes computing more delightful, and display-switch</code> is a great example of that: switching my monitor and full peripheral set is now a single button press, and meaningfully faster than before.</p>


Using Changesets in a polyglot monorepo
2026-02-20T00:00:00+00:00
One of the nice things about working in a smaller business is you can enjoy using things that don’t need to scale to extreme sizes.
One example in the software world is monorepos</a>.
While monorepos can</em> scale well (see Google, Facebook, and others), doing so requires special tooling and infrastructure.
With plain git</code>, you can only go so far</a>.
While you can use it, it has meaningful advantages, like being able to make atomic changes that affect many parts of the system in a single commit, which eliminates whole classes of compatibility and integration issues.
You can always split a monorepo later (see git-filter-repo</code></a>).</p>
So, suppose you’re a small-to-medium team using a monorepo.
Let’s go further and say that this monorepo stores all your company’s code, meaning it spans many different programming languages—it’s a polyglot monorepo.
What tool can you use to manage versioning in a consistent way?</p>
I argue that changesets</code></a> is a solid choice, even if it’s primarily focused on the JavaScript/TypeScript ecosystem.</p>













  
    
      
      Note</span>
  </div>

  There is an open discussion about native polyglot monorepo support</a>.
However, even without native support, changesets</code> has the hooks needed to implement this as-is for many setups.</p>
</div>
</div>
BackgroundFor any versioning tool, you are typically looking for how to:</p>

define what content appears in the changelog/release notes</li>
influence the version numbers of the packages</li>
automate the commits doing the actual metadata bumps and tagging</li>
automate the builds that happen in response</li>
</ul>
changesets</code> assumes per-package semantic versioning</a> (i.e., all packages have their own version).
In addition, each package has its own CHANGELOG.md</code>.</p>
The changesets</code> team also has a GitHub Action, changesets/action</code></a> which importantly allows specifying custom scripts for the version</code> and publish</code> commands.
That customization is what gives changesets</code> support for polyglot repositories.</p>
In changesets</code>, engineers commit “changeset” files to the repository that define what content ends up in changelogs, and what packages versions are bumped (i.e., major, minor, patch).</p>
See the changesets</code> documentation</a> for more details.</p>
Implementing an automated release process on GitHubI’m a fan of just</code></a>.
I also really like uv</code> scripts</a>.
The example below uses both.</p>
I’m also going to assume you are in a enterprise setting where all your monorepo is private, not open-source.</p>
Repository setupMy recommended organization (at least at time of writing) is something like the following.</p>
.</span></span>
├── .changeset</span></span>
│   ├── config.json</span></span>
│   └── README.md</span></span>
├── contrib</span></span>
│   └── utils</span></span>
├── docker</span></span>
│   └── Dockerfile</span></span>
├── docs</span></span>
│   ├── package.json</span></span>
│   ├── pnpm-lock.yaml</span></span>
│   ├── ...</span></span>
│   └── pnpm-workspace.yaml</span></span>
├── Justfile</span></span>
├── package-lock.json</span></span>
├── package.json</span></span>
├── packages</span></span>
│   ├── python-one</span></span>
│   │   ├── ...</span></span>
│   │   └── package.json</span></span>
│   ├── rust-one</span></span>
│   │   ├── ...</span></span>
│   │   └── package.json</span></span>
│   └── rust-two</span></span>
│   │   ├── ...</span></span>
│   │   └── package.json</span></span>
├── pnpm-workspace.yaml</span></span>
└── third-party</span></span></code></pre>
Put all packages in a packages/</code> directory, no matter what language they are.
I also enjoy having documentation as code</a>, so let’s say you have a docs/</code> directory, too, and that your docs is written in a javascript-based frontend (like Starlight</a>), for the purposes of highlighting a nuance later.</p>
Changeset configurationWith this setup, you can configure changesets</code> with a proxy pnpm</code> workspace at the root with all your packages.</p>
# pnpm-workspace.yaml</span></span>
packages</span>:</span></span>
  -</span> "packages/**"</span></span></code></pre>
And, declare your changesets</code> dependencies:</p>
// package.json</span></span>
{</span></span>
  "</span>name</span>":</span> "example-monorepo"</span>,</span></span>
  "</span>private</span>":</span> true</span>,</span></span>
  "</span>devDependencies</span>": {</span></span>
    "</span>@changesets/changelog-git</span>":</span> "^0.2.0"</span>,</span></span>
    "</span>@changesets/cli</span>":</span> "^2.29.0"</span></span>
  }</span></span>
}</span></span></code></pre>
You should now also update your .gitignore</code>:</p>
node_modules/</span></span></code></pre>
Because changesets</code> is built for JavaScript, we also need “proxy” package.json</code> files for all of our packages; changesets</code> uses these to perform version bumps.</p>
These can be as simple as:</p>
// packages/python-one/package.json</span></span>
{</span></span>
  "</span>name</span>":</span> "python-one"</span>,</span></span>
  "</span>version</span>":</span> "0.1.0"</span>,</span></span>
  "</span>private</span>":</span> true</span></span>
}</span></span></code></pre>
With this setup, note how we are intentionally trying to exclude</em> our internal docs/</code> as a pnpm workspace member—we only want to version packages.
To do so, declare the docs/</code> directory its own</em> pnpm</code> workspace, otherwise it will try and combine the docs/</code> dependencies into the root package-lock.json</code>.
This can be as simple as:</p>
# docs/pnpm-workspace.pyml</span></span>
packages</span>:</span> []</span></span></code></pre>
Next, we can add our changeset configuration:</p>
// .changeset/config.json</span></span>
{</span></span>
  "</span>$schema</span>":</span> "https://unpkg.com/@changesets/config@3.1.1/schema.json"</span>,</span></span>
  "</span>changelog</span>":</span> "@changesets/changelog-git"</span>,</span></span>
  "</span>commit</span>":</span> false</span>,</span></span>
  "</span>fixed</span>": [],</span></span>
  "</span>linked</span>": [],</span></span>
  "</span>access</span>":</span> "restricted"</span>,</span></span>
  "</span>baseBranch</span>":</span> "main"</span>,</span></span>
  "</span>updateInternalDependencies</span>":</span> "patch"</span>,</span></span>
  "</span>ignore</span>": [],</span></span>
  "</span>privatePackages</span>": {</span></span>
    "</span>version</span>":</span> true</span>,</span></span>
    "</span>tag</span>":</span> true</span></span>
  },</span></span>
  "</span>___experimentalUnsafeOptions_WILL_CHANGE_IN_PATCH</span>": {</span></span>
    "</span>onlyUpdatePeerDependentsWhenOutOfRange</span>":</span> true</span></span>
  }</span></span>
}</span></span></code></pre>Automating releases with GitHubThe glue to create polyglot versioning PRsNext, we want to automate our releases.
That is, generating the changelog PRs, bumping package metadata, pushing tags, and triggering builds on those tags.</p>
Let’s start with our GitHub Workflow definition, and unpack the scripts it calls.</p>
name</span>:</span> Release</span></span>
</span>
on</span>:</span></span>
  push</span>:</span></span>
    branches</span>:</span></span>
      -</span> main</span></span>
</span>
concurrency</span>:</span> ${{ github.workflow }}-${{ github.ref }}</span></span>
</span>
permissions</span>:</span></span>
  contents</span>:</span> write</span></span>
  pull-requests</span>:</span> write</span></span>
</span>
jobs</span>:</span></span>
  release</span>:</span></span>
    name</span>:</span> Release</span></span>
    runs-on</span>:</span> ubuntu-latest</span></span>
    outputs</span>:</span></span>
      published</span>:</span> ${{ steps.changesets.outputs.published }}</span></span>
    steps</span>:</span></span>
      -</span> uses</span>:</span> actions/checkout@v6</span></span>
      -</span> uses</span>:</span> actions/setup-node@v4</span></span>
        with</span>:</span></span>
          cache</span>:</span> npm</span></span>
      -</span> uses</span>:</span> astral-sh/setup-uv@v7</span></span>
      -</span> uses</span>:</span> taiki-e/install-action@just</span></span>
      -</span> run</span>:</span> npm install</span></span>
      -</span> name</span>:</span> Create Release Pull Request or Tag</span></span>
        id</span>:</span> changesets</span></span>
        uses</span>:</span> changesets/action@v1</span></span>
        with</span>:</span></span>
          version</span>:</span> just version</span></span>
          publish</span>:</span> npx @changesets/cli publish</span></span>
          # I like conventional commits</span></span>
          commit</span>:</span> "chore(release): version packages"</span></span>
          title</span>:</span> "chore(release): version packages"</span></span>
        env</span>:</span></span>
          GITHUB_TOKEN</span>:</span> ${{ secrets.GITHUB_TOKEN }}</span></span>
</span>
  docker</span>:</span></span>
    needs</span>:</span> [</span>release</span>]</span></span>
    if</span>:</span> needs.release.outputs.published == 'true'</span></span>
    uses</span>:</span> ./.github/workflows/docker.yml</span></span>
    secrets</span>:</span> inherit</span></span></code></pre>












  
    
      
      Tip</span>
  </div>

  You might be wondering why we run a workflow explicitly, rather than using something like on.push.tags</code> as a trigger.</p>
It turns out GitHub has two fatal flaws with that intuitive approach (at time of writing).
First, if you push >3 tags at once, workflows will not trigger</a>.
Unfortunately, this is a relatively common scenario in a monorepo.
Second, GitHub’s triggering of on.push.tags</code> is highly unreliable</a>.
This unreliability is still present, even if you use a PAT as they instruct</a>.</p>
So, instead consider an explicit workflow_call</code> for the purpose as I’ve done here.</p>
</div>
</div>
Setting version: just version</code> is the key to polyglot support.</p>
# Version packages based on changesets</span></span>
[doc(</span>'Consume changesets: bump versions, update changelogs, sync native version files.'</span>)]</span></span>
[group(</span>'release'</span>)]</span></span>
version</span>:</span></span>
    npx @changesets/cli version</span></span>
    uv run --script contrib/utils/sync-versions.py</span></span></code></pre>
The meat of the glue for polyglot support then, is how you implement sync-versions.py</code>.</p>
The key bit here is we rely on changesets</code> to bump the versions in package.json</code> for us when we call npx @changesets/cli version</code>, but then it is up to us to propagate that version to the respective language’s metadata appropriately.</p>
Here is an example that uses pretty naive parsing.
You can write something similar (or better!) for the languages you use.</p>
#!/usr/bin/env -S uv run --script</span></span>
#</span></span>
# /// script</span></span>
# requires-python = ">=3.12"</span></span>
# dependencies = []</span></span>
# ///</span></span>
#</span></span>
# Sync versions from package.json files (updated by changesets) to native</span></span>
# package manifests (Cargo.toml, pyproject.toml, etc.).</span></span>
</span>
import</span> json</span></span>
import</span> re</span></span>
import</span> subprocess</span></span>
from</span> enum</span> import</span> Enum</span>,</span> auto</span></span>
from</span> pathlib</span> import</span> Path</span></span>
</span>
PACKAGES_DIR</span> =</span> Path</span>(</span>__file__</span>).</span>resolve</span>().</span>parent</span>.</span>parent</span>.</span>parent</span> /</span> "packages"</span></span>
</span>
</span>
class</span> SyncResult</span>(</span>Enum</span>):</span></span>
    NOT_FOUND</span> =</span> auto</span>()</span></span>
    UP_TO_DATE</span> =</span> auto</span>()</span></span>
    UPDATED</span> =</span> auto</span>()</span></span>
</span>
</span>
def</span> read_package_json</span>(</span>pkg_dir</span>:</span> Path</span>) -></span> dict</span> |</span> None</span>:</span></span>
    """Read and parse a package.json file."""</span></span>
    pkg_json</span> =</span> pkg_dir</span> /</span> "package.json"</span></span>
    if not</span> pkg_json</span>.</span>exists</span>():</span></span>
        return</span> None</span></span>
    return</span> json</span>.</span>loads</span>(</span>pkg_json</span>.</span>read_text</span>())</span></span>
</span>
</span>
def</span> update_cargo_toml</span>(</span>pkg_dir</span>:</span> Path</span>,</span> version</span>:</span> str</span>) -></span> SyncResult</span>:</span></span>
    """Update version in [package] section of Cargo.toml."""</span></span>
    cargo_toml</span> =</span> pkg_dir</span> /</span> "Cargo.toml"</span></span>
    if not</span> cargo_toml</span>.</span>exists</span>():</span></span>
        return</span> SyncResult</span>.</span>NOT_FOUND</span></span>
</span>
    lines</span> =</span> cargo_toml</span>.</span>read_text</span>().</span>splitlines</span>(</span>keepends</span>=</span>True</span>)</span></span>
    in_package_section</span> =</span> False</span></span>
</span>
    for</span> i</span>,</span> line</span> in</span> enumerate</span>(</span>lines</span>):</span></span>
        stripped</span> =</span> line</span>.</span>strip</span>()</span></span>
</span>
        # Track which TOML section we're in</span></span>
        if</span> stripped</span>.</span>startswith</span>(</span>"["</span>):</span></span>
            in_package_section</span> =</span> stripped</span> ==</span> "[package]"</span></span>
            continue</span></span>
</span>
        if</span> in_package_section</span> and</span> stripped</span>.</span>startswith</span>(</span>"version"</span>):</span></span>
            new_line</span> =</span> re</span>.</span>sub</span>(</span></span>
                r</span>'</span>^</span>(</span>\s</span>*</span>version\s</span>*</span>=\s</span>*</span>"</span>)([</span>^</span>"</span>]</span>+</span>)(</span>"</span>)</span>'</span>,</span></span>
                rf</span>"\g<1></span>{</span>version</span>}</span>\3"</span>,</span></span>
                line</span>,</span></span>
            )</span></span>
            if</span> new_line</span> !=</span> line</span>:</span></span>
                lines</span>[</span>i</span>]</span> =</span> new_line</span></span>
                cargo_toml</span>.</span>write_text</span>(</span>""</span>.</span>join</span>(</span>lines</span>))</span></span>
                rel</span> =</span> cargo_toml</span>.</span>relative_to</span>(</span>PACKAGES_DIR</span>.</span>parent</span>)</span></span>
                print</span>(</span>f</span>"  Updated </span>{</span>rel</span>}</span>"</span>)</span></span>
                return</span> SyncResult</span>.</span>UPDATED</span></span>
            return</span> SyncResult</span>.</span>UP_TO_DATE</span></span>
</span>
    return</span> SyncResult</span>.</span>UP_TO_DATE</span></span>
</span>
</span>
def</span> update_pyproject_toml</span>(</span>pkg_dir</span>:</span> Path</span>,</span> version</span>:</span> str</span>) -></span> SyncResult</span>:</span></span>
    """Update version in [project] section of pyproject.toml."""</span></span>
    pyproject</span> =</span> pkg_dir</span> /</span> "pyproject.toml"</span></span>
    if not</span> pyproject</span>.</span>exists</span>():</span></span>
        return</span> SyncResult</span>.</span>NOT_FOUND</span></span>
</span>
    lines</span> =</span> pyproject</span>.</span>read_text</span>().</span>splitlines</span>(</span>keepends</span>=</span>True</span>)</span></span>
    in_project_section</span> =</span> False</span></span>
</span>
    for</span> i</span>,</span> line</span> in</span> enumerate</span>(</span>lines</span>):</span></span>
        stripped</span> =</span> line</span>.</span>strip</span>()</span></span>
</span>
        # Track which TOML section we're in</span></span>
        if</span> stripped</span>.</span>startswith</span>(</span>"["</span>):</span></span>
            in_project_section</span> =</span> stripped</span> ==</span> "[project]"</span></span>
            continue</span></span>
</span>
        if</span> in_project_section</span> and</span> stripped</span>.</span>startswith</span>(</span>"version"</span>):</span></span>
            new_line</span> =</span> re</span>.</span>sub</span>(</span></span>
                r</span>'</span>^</span>(</span>\s</span>*</span>version\s</span>*</span>=\s</span>*</span>"</span>)([</span>^</span>"</span>]</span>+</span>)(</span>"</span>)</span>'</span>,</span></span>
                rf</span>"\g<1></span>{</span>version</span>}</span>\3"</span>,</span></span>
                line</span>,</span></span>
            )</span></span>
            if</span> new_line</span> !=</span> line</span>:</span></span>
                lines</span>[</span>i</span>]</span> =</span> new_line</span></span>
                pyproject</span>.</span>write_text</span>(</span>""</span>.</span>join</span>(</span>lines</span>))</span></span>
                rel</span> =</span> pyproject</span>.</span>relative_to</span>(</span>PACKAGES_DIR</span>.</span>parent</span>)</span></span>
                print</span>(</span>f</span>"  Updated </span>{</span>rel</span>}</span>"</span>)</span></span>
                return</span> SyncResult</span>.</span>UPDATED</span></span>
            return</span> SyncResult</span>.</span>UP_TO_DATE</span></span>
</span>
    return</span> SyncResult</span>.</span>UP_TO_DATE</span></span>
</span>
def</span> refresh_lockfiles</span>() -></span> None</span>:</span></span>
    """Refresh all lockfiles under the repo to match updated versions."""</span></span>
    repo_root</span> =</span> PACKAGES_DIR</span>.</span>parent</span></span>
</span>
    print</span>(</span>"Refreshing lockfiles..."</span>)</span></span>
</span>
    # Cargo.lock — root workspace + any standalone crate lockfiles</span></span>
    cargo_locks</span> =</span> sorted</span>(</span></span>
        set</span>(</span>repo_root</span>.</span>glob</span>(</span>"Cargo.lock"</span>))</span> |</span> set</span>(</span>PACKAGES_DIR</span>.</span>rglob</span>(</span>"Cargo.lock"</span>))</span></span>
    )</span></span>
    for</span> cargo_lock</span> in</span> cargo_locks</span>:</span></span>
        lock_dir</span> =</span> cargo_lock</span>.</span>parent</span></span>
        rel</span> =</span> lock_dir</span>.</span>relative_to</span>(</span>repo_root</span>)</span> or</span> Path</span>(</span>"."</span>)</span></span>
        print</span>(</span>f</span>"  cargo update --workspace in </span>{</span>rel</span>}</span>"</span>)</span></span>
        subprocess</span>.</span>run</span>([</span>"cargo"</span>,</span> "update"</span>,</span> "--workspace"</span>],</span> cwd</span>=</span>lock_dir</span>,</span> check</span>=</span>True</span>)</span></span>
</span>
    # uv.lock — Python packages</span></span>
    for</span> uv_lock</span> in</span> sorted</span>(</span>PACKAGES_DIR</span>.</span>rglob</span>(</span>"uv.lock"</span>)):</span></span>
        lock_dir</span> =</span> uv_lock</span>.</span>parent</span></span>
        print</span>(</span>f</span>"  uv lock in </span>{</span>lock_dir</span>.</span>relative_to</span>(</span>repo_root</span>)</span>}</span>"</span>)</span></span>
        subprocess</span>.</span>run</span>([</span>"uv"</span>,</span> "lock"</span>],</span> cwd</span>=</span>lock_dir</span>,</span> check</span>=</span>True</span>)</span></span>
</span>
def</span> main</span>() -></span> None</span>:</span></span>
    print</span>(</span>"Syncing versions from package.json to native manifests..."</span>)</span></span>
    print</span>()</span></span>
</span>
    updated</span> =</span> 0</span></span>
    for</span> pkg_json</span> in</span> sorted</span>(</span>PACKAGES_DIR</span>.</span>rglob</span>(</span>"package.json"</span>)):</span></span>
        pkg_dir</span> =</span> pkg_json</span>.</span>parent</span></span>
        pkg_data</span> =</span> read_package_json</span>(</span>pkg_dir</span>)</span></span>
        if</span> pkg_data</span> is</span> None</span>:</span></span>
            continue</span></span>
</span>
        version</span> =</span> pkg_data</span>.</span>get</span>(</span>"version"</span>)</span></span>
        if</span> version</span> is</span> None</span>:</span></span>
            continue</span></span>
</span>
        name</span> =</span> pkg_data</span>.</span>get</span>(</span>"name"</span>,</span> pkg_dir</span>.</span>name</span>)</span></span>
        print</span>(</span>f</span>"</span>{</span>name</span>}</span> @ </span>{</span>version</span>}</span>"</span>)</span></span>
</span>
        results</span> =</span> [</span></span>
            update_cargo_toml</span>(</span>pkg_dir</span>,</span> version</span>),</span></span>
            update_pyproject_toml</span>(</span>pkg_dir</span>,</span> version</span>),</span></span>
        ]</span></span>
</span>
        if</span> any</span>(</span>r</span> ==</span> SyncResult</span>.</span>UPDATED</span> for</span> r</span> in</span> results</span>):</span></span>
            updated</span> +=</span> 1</span></span>
        elif</span> all</span>(</span>r</span> ==</span> SyncResult</span>.</span>NOT_FOUND</span> for</span> r</span> in</span> results</span>):</span></span>
            print</span>(</span>"  (no native manifest found)"</span>)</span></span>
        else</span>:</span></span>
            print</span>(</span>"  (already up to date)"</span>)</span></span>
</span>
    print</span>()</span></span>
    print</span>(</span>f</span>"Synced </span>{</span>updated</span>}</span> package(s)."</span>)</span></span>
    print</span>()</span></span>
</span>
    refresh_lockfiles</span>()</span></span>
    print</span>()</span></span>
    print</span>(</span>"Done."</span>)</span></span>
</span>
</span>
if</span> __name__</span> ==</span> "__main__"</span>:</span></span>
    main</span>()</span></span></code></pre>Reacting to package tagsIn the standard changesets</code> flow, you will now have a pull request on GitHub with the appropriate CHANGELOG.md</code> updates, as well as the metadata updates for all the relevant packages.</p>
Once that is merged, the very same action will run, realize all the .changeset</code> files are consumed, and push tags.</p>













  
    
      
      Note</span>
  </div>

  With our example configuration, changesets</code> will only push tags, not publish packages, because we set</p>
"privatePackages"</span>: </span>{</span></span>
    "</span>version</span>":</span> true</span>,</span></span>
    "</span>tag</span>":</span> true</span></span>
}</span></span></code></pre>
in our .changeset/config.json</code> and have all the packages set to private: true</code>.</p>
</div>
</div>
Typically, you’ll then want to react to these pushed tags.
For example, to build new docker images.</p>
For that, rather than using an on.push.tags</code> trigger as you would reasonably assume, you probably want a workflow_call</code>.
See the tip earlier in the post for why.</p>
on</span>:</span></span>
  workflow_call</span>:</span> {}</span></span>
  workflow_dispatch</span>:</span></span>
    inputs</span>:</span></span>
      dry_run</span>:</span></span>
        description</span>:</span> 'Build images without pushing to GHCR'</span></span>
        required</span>:</span> false</span></span>
        type</span>:</span> boolean</span></span>
        default</span>:</span> false</span></span>
      no_cache</span>:</span></span>
        description</span>:</span> 'Force a build without using the cache'</span></span>
        required</span>:</span> false</span></span>
        type</span>:</span> boolean</span></span>
        default</span>:</span> false</span></span></code></pre>Summarychangesets</code> can manage per-package semantic versioning and changelogs in polyglot monorepos today, even without direct native support for multiple languages.
The trick is to treat JavaScript package manifests as the canonical source of version bumps, and then syncing those bumps via your own scripts to the language-native manifests.</p>
A few gotchas exist (like explicitly making independent pnpm-workspace.yaml</code> files for subdirectories you want to be independent, or using a separate personal access token to push tags), but none are blockers to being able to benefit from changesets</code>’s convenient workflow.</p>
I used to suggest versioning monorepos with a single global version using a tool like semantic-release</code></a>.
Since trying changesets</code>, I’m sold on the benefits of letting people write commit messages for future internal engineers while also adding a separate changelog note for end users.
These are often two distinct audiences, and relying on a single conventional commit to serve both is often suboptimal.</p>


Fixing missing Omarchy boot entries
2026-01-24T00:00:00+00:00
In a normal Omarchy installation, the expected behavior is that you will see two new boot options in your BIOS: Omarchy</code> and Limine</code>.
There are two for good reason.
Omarchy</code> boots straight to Omarchy, and is what should be first in your boot order, typically.
Limine</code> goes to the Limine boot loader menu, which allows you to restore from snapshots</a>, which is useful.</p>
However, in my experience, sometimes a fresh install will fail to set up these boot entries.
Unfortunately, I have not spent the effort to discover the true root cause.
Regardless, fixing it is easy.</p>
As a concrete example, I recently installed Omarchy on a ThinkPad T14 Gen 4, and after what appeared to be a successful installation, I had the Limine</code> boot entry, but was missing the Omarchy</code> one, meaning when I booted, I was wasting time in the Limine menu each boot.</p>
The /boot</code> partition was set up as expected, though.</p>
❯</span> lt /boot/EFI/</span></span>
drwxr-xr-x</span>    - root</span> 23</span> Jan 15:50 /boot/EFI</span></span>
drwxr-xr-x</span>    - root</span> 23</span> Jan 15:48 ├── BOOT</span></span>
.rwxr-xr-x</span> 291k root</span> 23</span> Jan 15:48 │   ├── BOOTIA32.EFI</span></span>
.rwxr-xr-x</span> 283k root</span> 23</span> Jan 15:48 │   └── BOOTX64.EFI</span></span>
drwxr-xr-x</span>    - root</span> 23</span> Jan 15:49 ├── limine</span></span>
.rwxr-xr-x</span> 287k root</span> 23</span> Jan 15:49 │   ├── limine_x64.bak</span></span>
.rwxr-xr-x</span> 283k root</span> 23</span> Jan 15:49 │   └── limine_x64.efi</span></span>
drwxr-xr-x</span>    - root</span> 23</span> Jan 15:50 └── Linux</span></span>
.rwxr-xr-x</span>  47M root</span>  6</span> Jan 10:29     └── omarchy_linux.efi</span></span></code></pre>
And, with that, it’s very easy to fix the boot entries with efibootmgr</code></a>.</p>
First, let’s look at drive names.</p>
❯</span> df -h</span></span>
Filesystem</span>        Size  Used Avail Use% Mounted on</span></span>
dev</span>               7.7G</span>     0</span>  7.7G   0% /dev</span></span>
run</span>               7.7G  1.9M  7.7G   1% /run</span></span>
efivarfs</span>          196K  118K   74K  62% /sys/firmware/efi/efivars</span></span>
/dev/mapper/root</span>  237G   21G  214G   9% /</span></span>
tmpfs</span>             7.7G  580K  7.7G   1% /dev/shm</span></span>
none</span>              1.0M</span>     0</span>  1.0M   0% /run/credentials/systemd-journald.service</span></span>
none</span>              1.0M</span>     0</span>  1.0M   0% /run/credentials/systemd-resolved.service</span></span>
none</span>              1.0M</span>     0</span>  1.0M   0% /run/credentials/systemd-networkd.service</span></span>
tmpfs</span>             7.7G  8.0K  7.7G   1% /tmp</span></span>
/dev/mapper/root</span>  237G   21G  214G   9% /var/log</span></span>
/dev/mapper/root</span>  237G   21G  214G   9% /var/cache/pacman/pkg</span></span>
/dev/mapper/root</span>  237G   21G  214G   9% /home</span></span>
/dev/nvme0n1p1</span>    2.0G  144M  1.9G   8% /boot</span></span>
tmpfs</span>             1.6G  228K  1.6G   1% /run/user/1000</span></span></code></pre>
With these two pieces of information, adding an Omarchy</code> boot entry is simple.</p>
First, you can run sudo efibootmgr</code> to see your existing boot entries.
You’ll be able to confirm whether you’re missing entries here.</p>













  
    
      
      Note</span>
  </div>

  I should’ve recorded the output before the fix, but didn’t think I’d write a post about it until after the fact.
Hindsight is 20/20.</p>
</div>
</div>
Then, to add a new boot entry you can simply run:</p>
sudo</span> efibootmgr</span> \</span></span>
  --create</span> \</span></span>
  --disk /dev/{drive-name}</span> \</span></span>
  --part {partition-num}</span> \</span></span>
  --loader /path/from/boot/to/efi</span> \</span></span>
  --label "YourLabel"</span></span></code></pre>
So, given the output of df</code>, where I see my /boot</code> is mounted to /dev/nvme0n1p1</code>, I know /dev/nvme0n1</code> is my drive name, and it’s on p1</code> or partition 1</code>.
Thus, my specific call would be the following.</p>
sudo</span> efibootmgr</span> \</span></span>
  --create</span> \</span></span>
  --disk /dev/nvme0n1</span> \</span></span>
  --part</span> 1</span> \</span></span>
  --loader /EFI/Linux/omarchy_linux.efi</span> \</span></span>
  --label "Omarchy"</span></span></code></pre>
Same deal if you were missing a Limine entry (using my specifics as an example again).</p>
sudo</span> efibootmgr</span> \</span></span>
  --create</span> \</span></span>
  --disk /dev/nvme0n1</span> \</span></span>
  --part</span> 1</span> \</span></span>
  --loader /EFI/limine/limine_x64.efi</span> \</span></span>
  --label "Limine"</span></span></code></pre>
Once that’s done, you should be able to see the boot entries in efibootmgr</code>, as well as in your BIOS.</p>
❯</span> sudo efibootmgr</span></span>
BootCurrent:</span> 0000</span></span>
Timeout:</span> 0</span> seconds</span></span>
BootOrder:</span> 0000,0001,001E,001F,0021,0020,0022,0023,0024,0025,0026</span></span>
Boot0000*</span> Omarchy       HD</span>(</span>1,GPT,e7363f48-0ae8-47bb-bb0f-298baceaff27,0x800,0x400000</span>)</span>/</span>\E</span>FI</span>\L</span>inux</span>\o</span>marchy_linux.efi</span></span>
Boot0001*</span> Limine        HD</span>(</span>1,GPT,e7363f48-0ae8-47bb-bb0f-298baceaff27,0x800,0x400000</span>)</span>/</span>\E</span>FI</span>\l</span>imine</span>\l</span>imine_x64.efi</span></span>
Boot0010</span>  Setup FvFile</span>(</span>721c8b66-426c-4e86-8e99-3457c46ab0b9</span>)</span></span>
Boot0011</span>  Boot Menu     FvFile</span>(</span>126a762d-5758-4fca-8531-201a7f57f850</span>)</span></span>
Boot0012</span>  Diagnostic Splash Screen      FvFile</span>(</span>a7d8d9a6-6ab0-4aeb-ad9d-163e59a7a380</span>)</span></span>
Boot0013</span>  Lenovo Diagnostics    FvFile</span>(</span>3f7e615b-0d45-4f80-88dc-26b234958560</span>)</span></span>
Boot0014</span>  Asset Information     FvFile</span>(</span>da465b87-a26f-4c12-b78a-0361428fa026</span>)</span></span>
Boot0015</span>  Regulatory Information        FvFile</span>(</span>478c92a0-2622-42b7-a65d-5894169e4d24</span>)</span></span>
Boot0016</span>  ThinkShield secure wipe       FvFile</span>(</span>3593a0d5-bd52-43a0-808e-cbff5ece2477</span>)</span></span>
Boot0017</span>  ThinkShield Passwordless Power-On Device Manager      FvFile</span>(</span>08448b41-7f83-49be-82a7-0e84790ab133</span>)</span></span>
Boot0018</span>  Wi-Fi Configuration   FvFile</span>(</span>d3aaff0f-cb22-4792-896c-802c2e9383ba</span>)</span>2d004100700070000000</span></span>
Boot0019</span>  Reinstall Windows from Cloud  FvFile</span>(</span>3edbaac4-5017-4870-8cc4-721f9ef1974f</span>)</span>2d004100700070000000</span></span>
Boot001A</span>  Intel</span>(</span>R</span>)</span> MEBx FvFile</span>(</span>29a70110-7762-4211-ae88-fab19b7665be</span>)</span></span>
Boot001B</span>  Startup Interrupt Menu        FvFile</span>(</span>f46ee6f4-4785-43a3-923d-7f786c3c8479</span>)</span></span>
Boot001C</span>  Rescue and Recovery   FvFile</span>(</span>665d3f60-ad3e-4cad-8e26-db46eee9f1b5</span>)</span></span>
Boot001D</span>  Lenovo Memory Self Repair     FvFile</span>(</span>4ddd67e7-bdf5-4473-8ab0-02821c084338</span>)</span></span>
Boot001E</span>  USB CD        VenMsg</span>(</span>bc7838d2-0f82-4d60-8316-c068ee79d25b,86701296aa5a7848b66cd49dd3ba6a55</span>)</span></span>
Boot001F</span>  USB FDD       VenMsg</span>(</span>bc7838d2-0f82-4d60-8316-c068ee79d25b,6ff015a28830b543a8b8641009461e49</span>)</span></span>
Boot0020</span>  NVMe0 VenMsg</span>(</span>bc7838d2-0f82-4d60-8316-c068ee79d25b,001c199932d94c4eae9aa0b6e98eb8a400</span>)</span></span>
Boot0021*</span> USB HDD       VenMsg</span>(</span>bc7838d2-0f82-4d60-8316-c068ee79d25b,33e821aaaf33bc4789bd419f88c50803</span>)</span></span>
Boot0022</span>  PXE BOOT      VenMsg</span>(</span>bc7838d2-0f82-4d60-8316-c068ee79d25b,78a84aaf2b2afc4ea79cf5cc8f3d3803</span>)</span></span>
Boot0023</span>  LENOVO CLOUD  VenMsg</span>(</span>bc7838d2-0f82-4d60-8316-c068ee79d25b,ad38ccbbf7edf04d959cf42aa74d3650</span>)</span>/Uri</span>(</span>https://download.lenovo.com/pccbbs/cdeploy/efi/boot.efi</span>)</span></span>
Boot0024</span>  ON-PREMISE    VenMsg</span>(</span>bc7838d2-0f82-4d60-8316-c068ee79d25b,ad38ccbbf7edf04d959cf42aa74d3650</span>)</span>/Uri</span>()</span></span>
Boot0025</span>  Other CD      VenMsg</span>(</span>bc7838d2-0f82-4d60-8316-c068ee79d25b,aea2090adfde214e8b3a5e471856a35400</span>)</span></span>
Boot0026</span>  Other HDD     VenMsg</span>(</span>bc7838d2-0f82-4d60-8316-c068ee79d25b,ca88c2349e7ae947beeb43038a5aeae700</span>)</span></span>
Boot0027*</span> IDER BOOT CDROM       PciRoot</span>(</span>0x0</span>)</span>/Pci</span>(</span>0x14,0x0</span>)</span>/USB</span>(</span>11,1</span>)</span></span>
Boot0028*</span> IDER BOOT Floppy      PciRoot</span>(</span>0x0</span>)</span>/Pci</span>(</span>0x14,0x0</span>)</span>/USB</span>(</span>11,0</span>)</span></span>
Boot0029*</span> ATA HDD       VenMsg</span>(</span>bc7838d2-0f82-4d60-8316-c068ee79d25b,91af625956449f41a7b91f4f892ab0f6</span>)</span></span>
Boot002A*</span> ATAPI CD      VenMsg</span>(</span>bc7838d2-0f82-4d60-8316-c068ee79d25b,aea2090adfde214e8b3a5e471856a354</span>)</span></span></code></pre>
Setting Omarchy</code> to your first boot option will then boot straight to Omarchy.</p>


The outsized impact of cultural idiosyncrasies
2026-01-21T00:00:00+00:00
In the context of companies, cultural idiosyncrasies are fascinating to me.
I’m of the opinion that culture (including mission, principles, and values) is one of the biggest factors that differentiate companies from one another.
Sure, the product or service is often the largest differentiator, but company cultures—and in particular, their idiosyncrasies—have an outsized impact on public image, internal perception, and job satisfaction.</p>
Why?</p>
I believe it’s because these idiosyncrasies are evidence of what a company does</em>, and not just what it says</em> it does.
They reflect principles and values in uniquely powerful ways to both potential customers and employees.</p>
Some examplesLet me draw some examples from my own lived experience, and I’m sure I’m missing some compelling examples further back (Sun Microsystems, Xerox PARC).</p>
Also, and importantly, I’m not saying any of these idiosyncrasies are “right”, but I am saying they all have an outsized impact on my perception of the companies.</p>
GoogleOne of the earliest examples from my own memory is Google.
Not only did I experience how Google Search took over the market with its minimalism and effectiveness, but I also grew up hearing all sorts of news about how Google was “the best place to work”.
In those articles, did they talk about search?
Nope.
They talked about cultural idiosyncrasies: free meals from on-site cooks, nap pods, 20% projects, slides in the lobbies, micro-kitchens, laundry services!</p>
Oxide ComputerOxide is a prime example.
They frequently feature in online discussion, but in my perception, the majority of this discussion isn’t about their product; it’s about their culture, often with highly positive sentiment.
They find this so core to their company that they dedicated a podcast episode to it</a>.</p>
Some examples are demo Fridays, morning water-cooler, no-meet Wednesdays</a>, recorded meetings, dog-pile debugging, RFDs</a> (requests for discussion), no performance reviews, an overwhelmingly writing-focused hiring process</a>, and uniform and transparent pay</a>, to name a few.</p>
GitLabGitLab may not have the popularity of GitHub, but they have made a strong impression on me for at least two of their idiosyncrasies.</p>
The first was particularly prominent during the COVID-19 pandemic: a global, all-remote workforce</a>.
They are one of the largest all-remote companies with over 1,500 members in 65+ countries.</p>
They are also known for their transparent, handbook-first approach</a>.
They publish their handbook for all to see.
This is not brief, either.
It comprehensively covers everything: engineering, finance, sales, legal, and more.</p>
This is an incredible show of transparency and goodwill in sharing hard-earned lessons publicly.</p>
37signalsNot to be outdone, the 37signals folks also publish their handbook</a>.</p>
In their case, they have also published highly profitable books</a> about their idiosyncrasies and culture, such as Shape Up</em></a> (an engineering methodology that many companies are now adopting), REWORK</em> (unconventional business advice), and REMOTE</em> (on remote work).</p>
They also have idiosyncrasies like Omarchy</a>, an opinionated distribution of Arch Linux.
They liked it so much they ditched MacBooks as the standard-issue developer laptop and switched to Framework laptops.</p>
TonariTonari is a small Japanese tech startup making some of the most interesting audio/video portals available.</p>
Despite being very small, they contribute significant pieces of their stack to open source, such as innernet</a>, a private network system using WireGuard under the hood.</p>
They also value a heterogeneous mix of developer machines and were early on the Rust train</a> (note how each of the four engineers mentioned in this blog runs a different operating system: macOS, Arch, Ubuntu, and Pop!_OS).</p>
PalantirPalantir breaks the mold a bit in this list, because most of the public discussion around it is controversial and focused on the ethics of its business.</p>
That said, they are known for their idiosyncratic chaos culture</a>, where “everything is up for debate”—even a random engineer confronting the CEO at all-hands—and where they do almost anything to move fast—like chartering a private jet to Palo Alto to get the engineering team together during the COVID-19 pandemic.</p>
People I know who have worked there tell me this is an accurate representation.</p>
Jane StreetFamously, it’s the</em> OCaml shop people know about.
Compensation so high, even for interns, that it’s an idiosyncrasy.</p>
And, most notably to me, they have one of the most interesting tech blogs around.
For example, their code review process</a> has such a good reputation that other tech bloggers carve out exceptions for it</a> when talking about code review problems.
They care so much about rigor in tests that they not only leverage bleeding-edge strategies</a> like deterministic simulation testing (DST) but also led the funding round of Antithesis, the pioneers in DST</a>.
This is highly idiosyncratic.</p>
AmazonEven for massive companies like Amazon, some cultural idiosyncrasies still have an outsized impact.</p>
For example, I suspect most people have heard of Amazon’s 6-page memo</a> approach to meetings.
In this approach, attendees don’t read anything beforehand; instead of using PowerPoint, executives sit around a table and read six-page memos in silence before discussion commences.</p>
Likewise, Amazon is well known for its two-pizza teams</a>, where the idea is that a team should be no larger than two pizzas can feed.
That way it stays small, cohesive, and efficient.</p>
ZapposZappos is well known for its unique pay-to-quit</a> approach to making sure the team is invested.
It provides an attractive off-ramp for those who are less committed to or interested in the company after their training period, instead of staying despite lacking passion for the work.</p>
PatagoniaPatagonia is well known for its Let My People Go Surfing</em></a> policy, which prioritizes work-life balance, purpose, and employee autonomy.
The policy encourages staff to embrace flexibility and spontaneity in balancing work and play.
If the waves are good or the powder fresh, staff are trusted to step away, surf, or enjoy nature, returning to work with renewed purpose.</p>
ValveValve is the famously “flat” company, or “flatland”, as their public handbook calls it</a>.
They “don’t have any management, and nobody reports to anybody.”
They playfully poke at Google’s 20% time by saying that at Valve, it’s 100%.
Of course, this comes with its challenges, but this idiosyncrasy has become an integral part of my perception of Valve.</p>
Vannevar LabsSample size of 1, but I have a friend who really appreciates Vannevar’s $250/month stipend for mental/physical health and $300/month stipend to pay for house cleaners.
These dedicated benefits are particularly on point for a mostly remote team.
As a company they heavily hire forward-deployed engineers (FDEs) and empower them with very high autonomy.</p>
ThoughtsI’m sure this list could be ten times longer with some more thought.
But perhaps that supports the point.
All of these examples came almost immediately off the top of my head!</p>
If you’re running a company, I think it’s important to be intentional about your culture.
Both in the mission, principles, and values you profess and in the idiosyncrasies that uniquely evolve because of them.</p>
People will</em> talk about your cultural idiosyncrasies to the benefit or detriment of your company.
Your employees will reach for your idiosyncrasies when they talk about what is good or bad about working for your company.
Your customers will point to your idiosyncrasies as evidence for or against value alignment.
Your future employees will compare and contrast your idiosyncrasies with their experiences as they consider their next career move.</p>
And random people like me will evidently spend (too much?) time thinking about your idiosyncrasies and trying to theory-craft the perfect set of cultural idiosyncrasies for their hypothetical future company.</p>


2026 is the year I return to rigorous planning
2026-01-08T00:00:00+00:00
2026 is the year I return to some rigorous planning and productivity habits I’ve let slip over the years.
Specifically, time-block planning</a> (à la Cal Newport) and full-task capture (à la Getting Things Done (GTD)</a> by David Allen).</p>
The motivation for this change is that I anticipate this will be an unusually busy year for me at work, at home, and in my communities.
I want to make sure I make the most of the opportunities.</p>
The motivation for this post is twofold.
First, for a bit of documentation and musing on how I have specifically implemented these ideas this time around.
Second, for a little bit of self-accountability.
Who knows, maybe this will also motivate someone else to reevaluate their productivity habits.</p>
While we’re only a week into this year, this is a system I have used extensively since early high school—just less so recently.
Consequently, I already know that it is an effective catalyst for my own productivity.</p>
The methodsI’ll refer you to the links at the top of this post for more thorough exploration on what these systems mean.
However, for the purpose of this post, I want to briefly describe these two methods.</p>
Time-block planningTime-block planning is an intentional method for planning your days—hopefully a method that leads to being able to do deep work</a>, which I, in agreement with Newport, believe is vitally important in our modern distracted world.
This is particularly well-suited to knowledge workers, and it also served me well when I was a student.</p>
Many knowledge workers spend their day reacting</em>.
Reacting to messages, emails, changing priorities, changing requirements, meetings, etc.
This often leads to anxiety, overload, a lack of clarity, a feeling of chaos, and often impedes progress on things that require deep, focused effort.</p>
Time-blocking is all about proactive intention</em>.
Each day you fill out your calendar with time blocks representing a preliminary plan that gives every minute a purpose.
If you get knocked off this schedule, you simply update it the next time you have a chance.</p>
This sounds simple.</p>
It is.</p>
You can get things done in a chaotic environment</a>.</p>
Full task captureThis probably isn’t the right term in a GTD context, but it conveys the methodology I find useful.
The idea here is that you should capture everything</strong> that has your attention (tasks, ideas, etc.) into an external system so that you can free your mind from lingering unproductively and unreliably on them.
This capture should be both complete and as immediate as possible, and should go into a single designated spot (e.g., an “inbox”).
Then, you can process this list later with intention, either scheduling things, stashing things for later, or intentionally discarding things.</p>
If you’re the type of person who frequently has things “fall through the cracks” or finds yourself up at night repeatedly looping through things you need to do, you might find this technique refreshingly freeing.</p>
My implementationSo, now that you have the basic ideas, I want to share my current implementation.</p>
Implementation is a highly personal choice.
Some people prefer pen and paper (like Newport does).
To go further, some people might implement these ideas in the context of notebook-specific systems, like bullet journaling</a>, or a Hobonichi Techo</a>.</p>
Others might use special, purpose-built apps on their computer or phone.
Others might use intentionally basic apps or systems like todo.txt</a>.
Others might use a big whiteboard in their office.</p>
While those who know me know I love stationery, I’ve found that the single most important factor for success with these systems is low friction.
If I remember a task in the middle of the night, and that means I need to go find a pen and my notebook, it’s not happening.
But I can always find my phone for a quick note.</p>
So, I use Google Calendar and Google Tasks.
They are already on my phone.
They are easily accessible on both phone and computer.
They have sufficient features to implement the systems.</p>
Time block planning in Google CalendarA good work week usually looks something like this.</p>

  
    
  </a>
  
    Time-blocking in Google Calendar.
  </figcaption>
</figure>













  
    
      
      Note</span>
  </div>

  I have several Google accounts, so they all feed into a master view on my phone that includes time blocking before and after work hours.</p>
</div>
</div>
While the image above shows a fully-populated week, I actually only time-block one day ahead.
That is, during the “shutdown ritual” of the day, I review the tasks and ideas I may have captured within the context of my current task lists, then time-block the next day based on those tasks.
One exception here is recurring events are scheduled as recurring, and thus are already populated on their respective days.
While the screenshot above doesn’t show this well, it’s also important to have some empty buffer time to absorb unexpected events, or variance in how long things take.
This is another advantage of digital over paper: I can easily schedule events far into the future and not lose the information.
With a paper planner, it’s hard to schedule someone’s wedding in a year.</p>
As the day proceeds, if things do not go according to plan, I adjust the blocks on the calendar to reflect reality.
This is a valuable exercise both as an artifact to review where I actually spent my time on a given day and as useful feedback to improve my time estimations.
For example, you may notice I spent about three full days testing in the screenshot above.
I had initially anticipated that would take a single day.
The act of making things reflect reality is a good way to calibrate myself on how long to expect for similar work.
It goes the other way too: sometimes things take much less time than expected.</p>
When it comes to deep work, it feels good to see those larger, uninterrupted blocks of time.
If those blocks were short and highly interrupted, I’d take it as a signal to make adjustments that allow me to do deeper, more meaningful work with less context switching.</p>
You can see how time-block planning would work effectively in a knowledge worker’s or student’s life, but likely not in the life of an emergency room nurse.</p>
Full task capture in Google TasksThe last time I used Google Tasks was a few years ago, and they’ve made some nice improvements since.
For the purpose of full task capture, I keep a relatively simple system.
Not quite as simple as a todo.txt</code>, but still minimal while offering nice organization features like recurring tasks, scheduled tasks, and sub-tasks.</p>

  
    
  </a>
  
    Full task capture with Google Tasks.
  </figcaption>
</figure>
I organize Google Tasks somewhat Kanban-style.</p>
Google Tasks has a default list you cannot delete.
I use that as my “inbox”, but I title it “Maybe?”.
All quick notes go into here for later processing if I don’t have time to put it in the right list immediately.
If I decide to do it, it goes into the appropriate list.
If I don’t, it gets deleted from here.
I sort this with “My order” sorting so I can arbitrarily sort it with highest priority at the top.</p>
On the left, I have my “Not now” list.
These are things I want to do at some point, but they aren’t urgent.
I just don’t want to lose them, so this is much like a backlog.
This is also sorted “My order”, with highest priority at the top.</p>
In the middle, I have “In progress”, which could also be named “To do”.
These are things I’m actively working on.
Everything in this list has a date indicating when I intend to work on it.
I might add deadlines if relevant.
I sort this list by “Date” so that the things I need to do today are always up top, and I can quickly see what I need to do next.</p>
This is the only</strong> list that I mark things as “complete” from!</p>
Conveniently, these also show up in Google Calendar as you do them, providing a useful artifact of tasks you completed that day.</p>
Next, I have “On hold”.
These are things I was working on, but are now blocked for some reason.
A holding area.
When they become unblocked, they will go back to “In progress” with the appropriate dates.
Sorted in “My order”, with highest priority at the top.</p>
Finally, “Ideas”.
This is just a list of ideas sorted in “My order” with most interesting at the top.
I also find it handy to jot down things like gift ideas for people in the moment I discover them.</p>
When I add these items, I also occasionally use todo.txt</code>-style tags like +{project}</code> or @{context}</code>, even though Google Tasks has now way to filter for those.</p>
When I was a student, this was a superpower; I still give the advice today</a>.
As a student, I would start each semester by inputting all coursework dates from every class syllabus.
I always knew what was due, which weeks would be heavy, and which would be light.</p>
Another common question from fellow knowledge workers is how this fits in with other task tracking systems you might have at work (e.g., Linear, Jira, etc.).
The answer there is that this is far more lightweight.
I’m not writing lengthy descriptions or logging progress and notes on these items.
These are written as “just enough” context to know what they refer to clearly.
This is a personal system that complements the systems your teams might be using.</p>
Thoughts so farI should never have stopped doing this!
When you develop a productivity system that works for you personally, it feels like a bandwidth multiplier.</p>
There is also much more to discuss about setting goals, having a vision for your career</a>, and other high-level planning that ultimately feeds your day-to-day work, but those are out of scope for this particular post.</p>
This is all about the nitty-gritty of day-to-day productivity.</p>
This system might not work for you, but I hope it has sparked some ideas as you work on your own systems.</p>


My favorite software in 2025
2025-12-17T00:00:00+00:00
As an engineer, I’m always refining which tools are in my toolbox.
Here’s a big list of software I enjoy using in 2025.
Like 2024</a>, I’m omitting things I don’t touch at least once in a month.
So, please refer to 2023</a> for some honorable, but less regular, mentions.</p>
</span>
The Listaerc</a>  </a>This is my email client of choice.
I tried mutt</code>, but the configuration was too complex for me.
aerc</code>, on the other hand, is very simple to configure, and works great in the terminal.
I’m an advocate for using plaintext email</a>, and aerc</code> works great for using email for git patches</a>.
It lets me use my $EDITOR</code> of choice, search and filtering works well, and it’s quick.
Let me also call out a new discovery here: carddav-query</code></a>.
This works far better than the largely unmaintained goobook</code> I was using previously.</p>
atuin</a>  </a>You don’t realize how useful synced shell history is until you try it.
You should absolutely try it.
Installed it on a whim, and have been delighted since.</p>
bat</a>  I’ve aliased cat</code> to bat</code> and never looked back.
The syntax highlighting, the line numbers, the git integration, the paging, it all just makes it nice to use.</p>
Berkeley Mono</a> (TX-02) This is my favorite coding font, and this year they released new versions</a>!
Not only was it worth the initial $75, I paid more for a new web license.
Importantly, the new version includes more slender versions and variable fonts, so I really don’t miss Iosevka</a> anymore.</p>
bottom</a>  </a>btm</code> is a better top</code> (and htop</code>).
I originally thought I wouldn’t need more than htop</code>, until I tried to run it on a massive server with over 150 cores.
htop</code> you need to configure differently to see anything at all (dropping all the CPU bars), and it is slow</em>.
btm</code> handles it just fine out of the box.
The filtering on the processes widget is very convenient.
The ability to see all the other stuff like temps, GPU memory usage, network utilization, disk utilization, those are all cherries on top.
I’ll also call out that btop</a> is also very fun, but I find bottom more useful.</p>
chezmoi</a>  </a>I’ve tried a few different ways to manage my personal dotfiles</a>.
Before chezmoi</code>, I stored them as a bare git repo</a>, as found on HN</a>.
But, the killer feature for me was templating.
Even though I don’t use much of chezmoi</code>’s fancier features, just being able to use templates so that I could populate dotfiles based on the machine I was on was great.</p>
Ever since switching to Omarchy, I’ve revamped usage of my dotfile repo.</p>
choose</a>  </a>choose</code> is a human-friendly alternative to cut</code> and (sometimes) awk</code>.
I used to use awk</code> for most of this type of task, but choose just makes it easier.
It makes it easy to chop out columns I want while piping things around.</p>
codebook</a>  </a>codebook</code> is another spell-checker for code, like typos</code>.
It’s high quality and I enjoy it as a default LSP for text.</p>
D2</a>  </a>This is a new addition.
In general, I’m a big fan of “declarative diagraming”</a>, and D2 is the new one on the block (vs PlantUML</a>, MermaidJS</a>, GraphViz</a>, etc.)
So far, I love the syntax and functionality.
If I’m drawing up something quick that doesn’t warrant something like draw.io</code>, I’ve been reaching for D2 first and excalidraw</a> second.
Their TALA layout engine</a> is proprietary, but looking quite nice.</p>
delta</a>  </a>delta</code> is the best syntax-highlighting pager for git, diff, and grep output I’ve seen.
I used to use diff-so-fancy</code></a>, but since switching to delta</code>, I haven’t looked back.
This makes the experience of using git in the terminal much improved.</p>
difftastic</a>  </a>difftastic</code> is the another key tool I use side-by-side with delta</code>.
It is a structural diff tool that understand syntax</em>.
This means that many times, it is a much more succinct diff for files.
I have this aliased in git</code> as well, and often use both delta</code> and difftastic</code> when looking at diffs.</p>
dust</a>  </a>This is like du</code>, but better.
It’s faster, and its visually nicer.
This is my go-to way for figuring out where my disk space is being used.</p>
eza</a>  </a>This is a replacement for ls</code> that is just better.
Similar to bat</code>, after aliasing ls</code> to eza</code>, I haven’t looked back.</p>
fd</a>  fd</code> is a replacement for find</code>.
Similar to exa</code> and bat</code>, this is another rust-based tool that feels more intuitive and does the job better.</p>
fish</a>  </a>Fish has been a great shell.
I just used plain bash before this.
I switched a couple of years ago, and while I don’t think there has been any particularly large “killer feature” for me, I have had no reason to switch to anything else since.
The UI niceties (e.g., autosuggestions, tab completions, syntax highlighting, 24-bit color) all make the terminal experience pleasant.
It’s also being slowly rewritten in rust</a>.</p>
I’m interested in trying nushell</code></a> at some point soon, but I haven’t jumped in yet.</p>
Ghostty</a>  </a>I’ve switched from Wezterm</a> to Ghostty.
While there is still 1 killer feature I’m missing</a>, I’ve thoroughly enjoyed Ghostty’s performance and simplicity.
I appreciate the dedication to correctness</a> and performance.</p>
git</a>  </a>git</code> is my favorite version control software.
Yes, that might be because it’s pretty much ubiquitous, and I’ve spent the time to get over the learning curve.
It’s a fantastic tool.</p>
If you haven’t leveraged aliases (here are mine</a>), then I hope reading this is a plug to go enjoy those.</p>
Since it’s git-related, I’ll also mention I’m a strong proponent of conventional commits</a>, and using useful git trailers</a> like they do for git itself and Linux.</p>
While we’re all used to the PR/MR type of workflow, if you haven’t experienced working with git the truly distributed way (via git-send-email</a>) its also worth trying.</p>
git-absorb</a>  </a>This fits exactly into my normal git workflow, and it’s algorithm is simple and effective.
If you are used to making fixup</code> commits yourself, definitely try this out!</p>
git-cliff</a>  If you’re following conventional commits</a>, then git-cliff</code> is a fantastic tool for automatically generating useful changelogs.
I use this in the vast majority of my repositories.</p>
git-grab</a>  This is a small tool that clones a git repository to a standard location, organized by domain name and path.
I used to just have a repos/</code> directory full of random repos.
At one point, I tried to organize these better (e.g., “personal”, “forks”, etc.), but it didn’t work well.
Now, I just use git-grab</code> and stick with that structure.</p>
gping</a>  </a>“Ping, but with a graph.”
That’s an accurate description, but don’t underestimate the niceness of a graph.
It also has features like graphing multiple hosts at the same time, or graphing execution times of commands.
Similar to bat</code>, exa</code>, fd</code>, btm</code>, if you have gping</code>, you really don’t need to go to ping</code> anymore.</p>
helix</a>  </a>I’m embarrassed to say, but I didn’t really</em> learn how to use vim</code> until 2017.
But, that was such a positive experience that I’ve been on modal editors since.
I went from vim</code>, to neovim</code></a>, and then, most recently, to hx</code>.</p>
Going from electron-based editors to vim</code> was a big jump.
Going from vim</code> to these others was just incremental.
I had developed a very custom nvim</code> experience with plugins and all sorts of customizations.</p>
That, surprisingly, is part of the reason I’ve enjoyed hx</code> so much: I use it pretty much stock.
It’s got all the right basics built-in (LSP, file pickers, tree-sitter, etc.) such that I don’t need</em> to customize it much.</p>
If you’re interested in experimenting with a new editor, I highly recommend helix.</p>
hurl</a>  </a>hurl</code> is an easy way to test HTTP requests with plain text.
Since it can chain requests, capture values, etc., I actually often use it to “script” some request chains for testing purposes.
I haven’t used this extensively, but so far, it seems very useful.</p>
hyperfine</a>  hyperfine</code> is the best command-line benchmarking tool around.
It should be the standard, in my opinion.
If you ever want to benchmark how long a particular command-line command takes in a robust way, look no further.</p>
jaq</a>  </a>jaq</code> is a clone of the ubiquitous jq</code></a> JSON processing tool.
But, it is more correct and faster.
As long as you aren’t doing crazy stuff with jq</code>, jaq</code> might be an easy alias to make for some small wins.</p>
jless</a>  </a>jless</code> is a command-line JSON viewer.
If you’re viewing JSON files with some combination of jq</code> (or jaq</code>), less</code>, cat</code>, etc., then jless</code> might be just what you’re looking for.
It makes it easy to quickly peruse a JSON file and espand/collapse objects and arrays.</p>
Jujutsu</a>  </a>jj</code> is a git-compatible version-control system that is both simple and powerful.
This is the surprise</em> of the year for me.
While it doesn’t really solve any concrete problems for me from git</code>, it does do some fun things, like let me rebase all of my branches at once.</p>
I’ve enjoyed the experiment using this over the past couple months, and suspect I will continue to do so.</p>
just</a>  </a>just</code> is a versatile command runner that takes inspiration from make</code>, but without the baggage.
This is a new entry on this list, and not one I have used as extensively, but so far, it seems nice.
There are many situations where I have a Makefile</code> with a bunch of .PHONY</code> targets because I’m just trying to use make</code> as a command runner.
Well, now I have a nice command runner.</p>
There are several repositories I’ve worked with with a scripts/</code> folder that could just be absorbed into a justfile</code>.</p>
lychee</a>  The web is great, but it is unfortunate when you come across broken links.
lychee</code> is a great way to help prevent that (they even have a GitHub Action</a>).
It’s incredibly fast.
I use it to check most of my repositories for dead links, as well as my blogs.</p>
Mosh</a>  </a>The mobile shell that allows roaming, supports intermittent connectivity, and provides intelligent local echo.
A recent release</a> also brought true color support, which was the only thing that bothered me before.
99% of the time I say I’m “ssh”-ing, I’m actually just using mosh</code>.
The ability to start a session, get a tmux</code> session all set up, close my laptop, go somewhere else, open it and just pick up where I was is too good to ignore.</p>
This is an example of software that is pretty much “complete”.
Lack of activity on the repository shouldn’t scare you one bit, its because it has a rock solid history and does what it sets out to do.</p>
mpv</a>  mpv</code> is the best media player I know of.
I prefer this to VLC or others.
It “just works” and is extremely minimal and performant.
It’s integration with yt-dl</code> (or better yet, yt-dlp</code></a>) means I often just play web videos (even YouTube) via mpv</code>.</p>
Omarchy</a>  </a>Omarchy is a beautiful, modern, and opinionated Linux distribution build on hyprland</a> and Arch</a>.
This is my favorite find of the year.</strong>
I’m a big fan of tiling window managers and Linux on the desktop.
Earlier in the year, I built my own spin of Wayblue sway, but since Omarchy came out, it has checked every box for me.</p>
There are many things that are just integrated incredibly well within this distro.
I won’t bother calling them out explicitly as items on this list, but I’ll highlight that Omarchy uses tools like impala</code></a>, gpu-screen-recorder</code></a>, or things like waybar, hyprland, walker, limine, etc., all beautifully.
I wouldn’t know about many of these were it not for Omarchy, and now I just use them.</p>
passage</a>  </a>passage</code> is a fork of pass</code></a>, very simple password store that follows Unix philosophy</a>.
Unlike pass</code>, passage</code> uses age</code></a> encryption as the backend.</p>
I don’t miss having a password manager app on my mobile phone, so on desktop, this has served me well.
I’m a big fan of its simplicity, and the fact that my passwords are just flat files I can version in a git</code> repo.</p>
In addition, I love being able to use a yubikey, and age-plugin-yubikey</code></a> makes this very easy.</p>
ripgrep</a>  This is grep</code> on steroids.
Stop using grep</code> and start using ripgrep</code> and you’ll never go back.
It is significantly</em> faster, and has a bunch of great features (e.g., searching file types, regex, automatic filtering, etc.).
It is often thought of as the gold standard for excellent Rust code.</p>
Satty</a>  </a>When it comes to taking screenshots, Satty is my favorite on Linux.
(I still use Flameshot</a> on macOS.)
Easy to adjust, annotate (i.e., arrows, boxes, text, blur, etc.), and save to clipboard or file.
Integrates well in Omarchy.</p>
sd</a>  </a>sd</code> is an intuitive rust rewrite of sed</code>.
Much like the other tools in this list (e.g., bat</code>, exa</code>, etc.) it is just a better option in most cases.
I frequently use it in combination with fd</code> to find and replace across a project directory.</p>
sshx</a>  &  </a>sshx</code> is the best live terminal sharing application I’ve ever used.
I used to reach for things like tmate</code> for this, but it’s more constraining (e.g., I want to still use zellij).
It also does not look as nice.
sshx</code> has a level of polish no other tool I’ve tried in this space has had.
This is by go-to tool for pair programming.
They also just released the killer feature of read-only sharing</a>, which makes this extremely handy in a whole slew of scenarios.
This largely solved the screen sharing problem you might have if you use Slack or similar, but have an ultrawide monitor and your coworkers do not.
With sshx</code>, the latency is impressively low and the text will be crystal clear.
In a screen share, you have a compressed mess.</p>
Starlight</a>  </a>Starlight is my new go-to documentation framework.
It does all of the important things I used from Material for MkDocs, but often in more intuitive, ergonomic ways.
It is blazingly fast.
It looks good.
I don’t have to deal with ridiculous Python virtual environments.</p>
While we’re talking about documentation, I’ll mention that I’m a strong proponent of the Diátaxis documentation system</a>.
If you’re wondering how you should organize your documentation, please consider it!</p>
starship</a>  </a>I started using starship</code> about the same time I started using fish</code>.
It’s a fun, fast, extremely customizable prompt with nice defaults.
I’ve enjoyed it enough that I just haven’t stopped using it since first adding it to try.
If you’re the type that has some line in your .bashrc</code> to know what git branch your on, you might enjoy starship as well.</p>
Tailscale</a> Thanks to wireguard</a>, tailscale makes private mesh networking stupid easy.
It’s my go-to tool when it comes to sharing things on a private network (e.g., self-hosted stuff with my family, ssh-ing into my desktop when out and about, etc.).
It’s performant, well documented, and pretty much just works and gets out of your way.</p>
tokei</a>  tokei</code> is the best way to get statistics around counting code in a repository.
It shows you the total number of files and total lines within those files broken down by code, comments, blanks, and organized by language.</p>
It seems both faster and more accurate than tools like cloc</a>, sloccount</a>, etc.
There are other great blogs posts about code counters</a>.</p>
typos</a>  typos</code> is a very handy spellchecker that seems to work in a code context better than other things I’ve tried.
They have a CLI, as well as an LSP.
It’s worth checking out!</p>
I usually have a config like this:</p>
[files]</span></span>
extend-exclude = ["*.svg"]</span></span>
</span>
[default]</span></span>
extend-ignore-re = ["\\w{51,}"]</span></span></code></pre>Typst</a>  </a>Almost anytime I would’ve reached for LaTeX, I now reach for typst</code>.
The ecosystem has seriously grown over the years.
The performance, control, and error messages remain excellent.</p>
And, it looks just as good as LaTeX.</p>
The only thing still on my wishlist is variable font support</a>.</p>
watchexec</a>  </a>watchexec</code> simply runs a command when files in the current directory change (and it’s awesome).
Made my the same folks who make cargo watch</a>, this is a general purpose tool that can make your development loop feel</em> faster when immediately starting long processes (linting, tests, etc.) immediately in response to code changes.
Oftentimes, the checks/build/tests are finished by the time I’m ready to craft my commit.
Definitely worth trying.</p>
xh</a>  </a>xh</code> is very similar to HTTPie</a>.
While I haven’t used the latter, I’m a big fan of xh</code> over curl</code>.
The interface just seems more intuitive and friendly.
And, it still has a --curl</code> flag so I can get a curl command in case I need to share it with a teammate.</p>
YNAB</a> I used to use Mint, but when they shut down, I migrated to YNAB.
I wanted to be more hands on, more intentional, and more aware of my spending, and YNAB seems to be a great tool for that job.</p>
zellij</a>  </a>I spend the vast majority of my time every day inside a zellij</code> session.
I’m a fairly basic user, but the terminal multiplexing, scrollback buffer/search, ability to have multiple sessions and attach/detach is all I really need.
zellij</code> and mosh</code> are a perfect combo.
I like the visuals and UX enough to have had this replace tmux</code>.</p>
Zola</a>  </a>For non-documentation sites, my favorite static site generator is Zola.
The template engine is great, and its fairly simple and easy to grok how themes work and can be modified.
I use it for this site, as well as several others I’ve made.</p>
Final thoughtsOmarchy and the cascade of software that that showed me was the big change this year, with a couple of other fun highlights like Ghostty, jj</code>, and age</code>.</p>
Otherwise, the trusty toolbox has largely remained trusty!</p>


Switching from GPG to age
2025-11-04T00:00:00+00:00
It’s been several years since I went through all the trouble of setting up my own GPG</a> keys and securing them in YubiKeys following drduh’s guide</a>.
With that approach, you generate one key securely offline and store it on multiple YubiKeys, along with a backup.</p>
It has worked well for me for years, and as the Lindy effect</a> suggests, it would almost certainly continue to.</p>
But as my sub-keys were nearing expiration, I was faced with either renewing (more convenient, no forward secrecy</a>) or rotating them (rather painful, but potentially more secure).
However, I’ve realized that I essentially only use these keys for encryption, and almost never for signing.
So, instead of doing either of the usual options, I’m going to let my keys expire entirely.</p>
I’m now experimenting with age</code></a>, which touts itself as “simple, modern, and secure encryption”.
If needed, I will use minisign</code></a> for signatures.</p>
Workflow changesThis required changing a couple of things in my typical workflow.</p>
Password managerFirst, and foremost, I needed to switch from pass</code></a> to passage</code></a>, a fork of pass</code> that uses age</code> as the backend.
This was actually surprisingly easy because passage</code> includes a simple bash script to do the migration.</p>
#! /usr/bin/env bash</span></span>
set</span> -eou pipefail</span></span>
cd</span> "</span>${PASSWORD_STORE_DIR</span>:-</span>$HOME</span>/</span>.</span>password-store}</span>"</span></span>
while</span> read</span> -r -d "" passfile</span>;</span> do</span></span>
  name</span>=</span>"</span>${passfile</span>#</span>.</span>/</span>}</span>"</span>;</span> name</span>=</span>"</span>${name</span>%</span>.</span>gpg}</span>"</span></span>
  [[</span> -f</span> "</span>${PASSAGE_DIR</span>:-</span>$HOME</span>/</span>.</span>passage</span>/</span>store}</span>/</span>$name</span>.age"</span> ]] &&</span> continue</span></span>
  pass</span> "</span>$name</span>"</span> |</span> passage</span> insert -m "</span>$name</span>"</span> ||</span> {</span> passage</span> rm "</span>$name</span>"</span>;</span> break</span>; }</span></span>
done</span> <</span> <(</span>find</span> . -path '*/.git' -prune -o -iname '*.gpg' -print0)</span></span></code></pre>
There is no installer for passage</code>, and no Arch packages.
But it’s easy enough to install because it’s just a shell script you can throw on your $PATH</code>.
Note that for Arch, I also needed to install tree</code>, which it assumes you have.</p>
I also name passage</code> as pass</code> on my machine.</p>
The benefit of this is everything that had pass</code> integration has continued to “just work”.
For example, aerc</code>, my email client of choice, behaved exactly the same after the migration.</p>
No more gpg-agent</code>I would occasionally use gpg-agent</code> as my SSH agent on my machines.
It was convenient.
However, I also like the idea of having a dedicated SSH key per machine.
It makes monitoring their usage and revoking them much finer-grained.</p>
The absence of gpg-agent</code> forced me to set up new keys on all my machines and add them to various servers/services.</p>
Benefits of the age</code> approachEasy encryption with chezmoiWhile I was tending to the encryption area of my personal tech “garden”, I also started leveraging chezmoi’s encryption features</a>.
I already use chezmoi</code> for my configuration files, but with encryption, I could also easily add “secrets” to my public dotfiles repo</a>.
In my case so far, this just means my copies of my favorite paid font: Berkeley Mono</a>.</p>
chezmoi</code> also has a nice guide for configuring chezmoi to encrypt while asking for a passphrase only once</a> for age</code>.</p>
Easy YubiKey configurationI was also very pleasantly surprised with how easy it was to switch to age</code>!
Last time I set up the GPG keys on my YubiKeys, I spent several hours.</p>
This time, with the help of age-plugin-yubikey</code></a> and embracing the idea of having unique keys on each YubiKey, but encrypting everything for multiple recipients, setting up my keys was surprisingly trivial.
It also generates the keys securely on the hardware key itself, which is nice.
The whole process probably took 30 minutes.
It was so easy that in the future, I’m very much not</em> intimidated by the thought of rotating keys.</p>
ThoughtsDid I need</em> to switch to age</code>?
Of course not.</p>
However, over my career, I repeatedly find that exploring new tools for your core workflows (part of investing in interfaces</a>) is just plain fun.
I often learn new ways of thinking about problems.
Sometimes, you walk away with a new default that brings some fresh ideas and some delight to your life.
Other times, you walk away with your trusty old tool, with greater appreciation for its history and the hard-earned approach it has established.
For my uses at the moment, age</code> definitely falls into the former camp.</p>













  
    
      
      Tip</span>
  </div>

  This post made it to Hacker News.
See the thread</a> for some additional discussion.</p>
</div>
</div>


First impressions of jj from a git fan
2025-10-25T00:00:00+00:00
What is jj</code>?Jujutsu</a> (jj</code>) is a distributed version control system (like git</code>, hg</code>, darcs</code>, pijul</code>, etc.).
However, it is rather unique in that it is git</code>-compatible—it uses git</code> as a storage layer, meaning you can use it right now on your existing git</code> repos without disrupting anyone else.</p>
It also provides other features, such as</p>

conflicts as a first-class object</li>
no explicit index</li>
revset</a> language</li>
operation log and powerful undo</li>
automatic rebase and conflict resolution</li>
</ul>
It also clearly has a (currently small but) passionate group of users, which is a good sign of a useful tool.</p>
Some of these users strongly dislike git</code>, finding its user interface unintuitive and clunky.
I, however, am very much not part of that group.
I love</em> git</code>.
Over the years, I’ve curated a configuration</a> that I find a joy to use.
I’ve built up years’ worth of muscle memory.
As a result, even though I love investing in interfaces</a>, such as new software tools, I haven’t ever felt motivated enough to try jj</code>.
That changed this past week when I learned that Steve Klabnik found jj</code> so interesting that he’s leaving Oxide to pursue it further</a>.</p>
As an experiment, I’ve committed to using only jj</code> for at least a couple of weeks.</p>
As a git</code> user, the tutorial that clicked best for me is Steve’s</a>.
So, if you’re a git</code> fan, I suggest starting there.</p>
First impressionsWhat I miss from git</code>I quickly ran into two features that I wish were supported.</p>
First, jj</code> does not support submodules</a>.
Sure, submodules are not great in many cases.
However, one very common case I use them for is Zola</a> themes, such as the theme for this blog.
My customization lives in my repository, and the theme for the site lives in a git</code> submodule.
However, it looks like they are working on that actively and with great care.</p>
Second, I missed git-format-patch</code>.
This one is more minor, because I can always just fall back to git</code> to do so.
Even in just a few days, I’ve wanted to serialize a patch to a file (i.e., git format-patch</code>) or apply some patch I have sitting around with git am</code>.
One example is a patch file I keep around that customizes an environment for debugging purposes.
As a jj</code>-native approach, I’ve been keeping a change separate that I can rebase into my patch series and move out later if needed.</p>
Then, there are a handful of more rarely used things that I have not needed yet, and consequently have not figured out equivalents for.
For example, I’m not sure about an equivalent for view release notes via tags.
With git</code>, I used an alias like</p>
[</span>alias</span>]</span></span>
    tlog</span> =</span> tag --</span>sort</span>=</span>-v:refname -l --</span>format</span>=</span>'%(color:red)%(refname:strip=2)%(color:reset) - %(color:yellow)%(contents:subject)%(color:reset) by %(taggername) on %(taggerdate:human)</span>\n\n</span>%(contents:body)'</span></span></code></pre>
But, then it seems right now jj</code> only supports lightweight tags, not annotated git tags.</p>
I’m not sure an equivalent for git shortlog</code>.
Most likely would need to build some template.</p>
I don’t have some jj</code> equivalent of git-stats</code></a>.
But again, it’s git</code>-compatible, so I can just keep using git-stats</code>.</p>
I’m sure there will be a long tail of things like this.</p>
Things I like more about jj</code>Steve and others have described jj</code> as “both simpler and easier than git, but at the same time, it is more powerful.”
I’m not sure I fully agree.
In some ways, it has better defaults (e.g., jj split</code>, jj absorb</code>), but in other ways, it is complex (e.g., revset language).
That said, I do see how it is more powerful.</p>
You cannot exactly your git</code> mental model to directly onto jj</code>’s.
That said, one of the main things I enjoy at $WORK is that for a repository, git</code>’s default “view” (for lack of a better word) is a branch, whereas jj</code>’s default view is much higher level.
I find jj</code>’s approach more intuitive: it’s always pretty trivial to see what branches/PRs I have ongoing at a glance (i.e., with jj log -r "@ | ancestors(trunk()..(visible_heads() & mine()), 2) | trunk()"</code>).
It also means you can easily do fun stuff like rebase all</em> of your branches at the same time, and push them all simultaneously to your remote!
This is made even better by the fact that conflicts are first-class objects, meaning you can rebase all your branches, and deal with conflicts later.</p>
In a similar vein: jj</code> emphasizes commits or changes in a way I find pleasing.
Even though in git</code> I have ways to do similar things, jj</code> does indeed make them easier.
For example, splitting one commit into multiple is easier.
In git</code>, you’d probably do something like</p>
git</span> rebase -i</span></span>
# select the commit you want to split for editing</span></span>
git</span> reset HEAD~1 --mixed</span></span>
# add the subset of changes you want in the first commit</span></span>
git</span> commit -c ORIG_HEAD</span></span>
# tweak if necessary</span></span>
git</span> add -u</span></span>
git</span> commit</span></span>
# write a commit message for the 2nd patch from scratch</span></span></code></pre>
In jj</code>, jj split</code> just does the more intuitive thing.
Instead, the same process looks more like</p>
jj</span> split -r {REVISION}</span></span>
# select the subset of changes you want in the first commit</span></span>
# automatically presented with the original commit message, tweak if necessary</span></span>
# remaining changes automatically put in 2nd commit, presented with original commit message to tweak again</span></span></code></pre>
As another example, I’m a huge fan of git-absorb</code></a>.
It makes folding follow-up changes into an appropriate earlier commit easy and effective.</p>
However, it isn’t built into git</code>.
Meanwhile, jj</code> ships with jj absorb</code>, which does the same thing.</p>
I found that in git</code>, I was already following a workflow close to the squash workflow</a> recommended by jj</code>’s creator, Martin.</p>
Things I still find awkwardThe main thing I still feel clumsy with is named bookmarks (similar to git</code> branches).
Specifically, I find it hard to remember to set</code> the bookmark when I make updates, and how to rebase them without looking up commands.
That said, it’s becoming more familiar over time.</p>
My configsMuch like git</code>, I’ve also found that jj</code>’s defaults aren’t entirely sufficient for me.
I needed to make some tweaks.
You can see my up-to-date dotfiles here</a>, but as a snapshot, these are changes I found to be particularly valuable right from the start.</p>
#:schema https://jj-vcs.github.io/jj/latest/config-schema.json</span></span>
</span>
[</span>user</span>]</span></span>
name</span> =</span> "Luke Hsiao"</span></span>
email</span> =</span> "{{ .email }}"</span></span>
</span>
[</span>git</span>]</span></span>
auto-local-bookmark</span> =</span> true</span></span>
# Prevent pushing work in progress or anything explicitly labeled "private"</span></span>
private-commits</span> =</span> "description(glob:'wip:*') | description(glob:'private:*')"</span></span>
</span>
[</span>ui</span>]</span></span>
editor</span> =</span> "hx"</span></span>
pager</span>=</span>[</span>"delta"</span>,</span> "--pager"</span>,</span> "less -FRX"</span>]</span> # Keeps output from the terminal after closing the pager</span></span>
diff-formatter</span> =</span> ":git"</span> # required by `delta`</span></span>
</span>
# These options allow for `jj diff` and `jj show` to clear the output from the terminal after closing the pager.</span></span>
[[</span>--scope</span>]]</span></span>
--when</span>.</span>commands</span> =</span> [</span>"diff"</span>,</span> "show"</span>]</span></span>
</span>
[</span>--scope.ui</span>]</span></span>
pager</span> =</span> "delta"</span></span>
</span>
[</span>template-aliases</span>]</span></span>
commit_template</span> =</span> '''"JJ: <type>(<scope>): (If applied, this commit will...) <subject> (Max 50 char)</span></span>
JJ: |<---- Try to limit to a max of 50 char ---->|</span></span>
</span>
JJ: Explain why this change is being made</span></span>
JJ: |<----- Try to limit each line to a maximum of 72 characters ----->|</span></span>
</span>
JJ: Provide links or keys to any relevant tickets, articles or other resources</span></span>
JJ: Example: GitHub issue #23, BREAKING CHANGE: <description>, Ref: 5119ae</span></span>
</span>
JJ: --- COMMIT END ---</span></span>
JJ: Type can be</span></span>
JJ:   build:    changes that affect the build system or external dependencies</span></span>
JJ:   chore:    updating grunt tasks; no production code change</span></span>
JJ:   ci:       changes to our ci configuration files and scripts</span></span>
JJ:   docs:     changes to documentation</span></span>
JJ:   feat:     new feature, correlates with MINOR</span></span>
JJ:   fix:      bug fix, correlates with PATCH</span></span>
JJ:   perf:     a code change that improves performance</span></span>
JJ:   refactor: refactoring production code; neither fixes a bug nor adds a feature</span></span>
JJ:   revert:   for reverts, revert: <old subject>; state reverted hash in body</span></span>
JJ:   style:    formatting, missing semicolons, etc; no change in code behavior</span></span>
JJ:   test:     adding or refactoring tests; no production code change</span></span>
JJ:</span></span>
JJ: Scope refers to the file, directory, or system that is being modified.</span></span>
JJ:</span></span>
JJ: Follow the type(scope) with an '!' to indicate a breaking change.</span></span>
JJ: Example: refactor(api)!: remove the accident-prone delete_all button</span></span>
JJ: --------------------</span></span>
JJ: Remember to</span></span>
JJ:    Use the imperative mood in the subject line</span></span>
JJ:    Do not end the subject line with a period</span></span>
JJ:    Separate subject from body with a blank line</span></span>
JJ:    Use the body to explain what and why vs. how</span></span>
JJ:    Can use multiple lines with '-' for bullet points in body</span></span>
JJ:    BREAKING CHANGE: to correlate with MAJOR</span></span>
JJ:</span></span>
JJ: See: https://www.conventionalcommits.org/en/v1.0.0/)"</span></span>
'''</span></span>
</span>
[</span>templates</span>]</span></span>
git_push_bookmark</span> =</span> '"lwh/" ++ change_id.short()'</span></span>
draft_commit_description</span> =</span>'''</span></span>
    concat(</span></span>
      coalesce(description, commit_template, "\n"),</span></span>
      surround(</span></span>
        "\nJJ: This commit contains the following changes:\n", "",</span></span>
        indent("JJ:     ", diff.stat(72)),</span></span>
      ),</span></span>
      "\nJJ: ignore-rest\n",</span></span>
      diff.git(),</span></span>
    )</span></span>
'''</span></span>
</span>
[</span>aliases</span>]</span></span>
cl</span> =</span> [</span>"log"</span>,</span> "-r"</span>,</span> "trunk()..@-"</span>,</span> "--reversed"</span>,</span> "-T"</span>,</span> "description ++ '</span>\n</span>---</span>\n\n</span>'"</span>,</span> "--no-graph"</span>,</span> "--no-pager"</span>]</span></span>
l</span> =</span> [</span>"log"</span>,</span> "-r"</span>,</span> "@ | ancestors(trunk()..(visible_heads() & mine()), 2) | trunk()"</span>]</span></span>
la</span> =</span> [</span>"log"</span>,</span> "-r"</span>,</span> "all()"</span>]</span></span>
pba</span> =</span> [</span>"git"</span>,</span> "push"</span>,</span> "-b"</span>,</span> "glob:lwh/*"</span>]</span></span>
rba</span> =</span> [</span>"rebase"</span>,</span> "-s"</span>,</span> "all:roots(mutable())"</span>,</span> "-d"</span>,</span> "trunk()"</span>]</span></span>
tug</span> =</span> [</span>"bookmark"</span>,</span> "move"</span>,</span> "--from"</span>,</span> "heads(::@- & bookmarks())"</span>,</span> "--to"</span>,</span> "@-"</span>]</span></span></code></pre>
First, I strongly prefer delta</code></a> over the default viewer.
jj</code> also makes it easy to view with another tool with --tool</code>.
For example, I also like using difft</code></a>.</p>
I added a config from this discussion</a> so jj log</code> doesn’t clear the screen on quit.</p>
Second, I like having my conventional commit</a> template automatically populated on jj describe</code>.
I also have the diff included</a>, which mimics the config I had with git</code> using</p>
[</span>commit</span>]</span></span>
    template</span> =</span> ~/.config/git/commit-template</span></span>
    verbose</span> =</span> true</span></span></code></pre>
Third, I changed the default git push</code> bookmark prefix to lwh/</code>.</p>
Finally, I added a bunch of aliases I use frequently.
I use jj cl</code> to copy-paste commit descriptions into PR descriptions.
I use jj l</code> to view all the logs most relevant to me.
This was discovered courtesy of Will Richardson</a>.
I use jj la</code> to view all logs.
I use jj pba</code> and jj rba</code> to push all my bookmarks, and rebase all my changes on main, respectively.
Finally, I use jj tug</code> to move my bookmark to the latest change (I found this one thanks to Shaddy</a>).</p>
Thoughts so farI actually find jj</code> quite fun!
Again, I do not think it “solved” any pain points I had with git</code>.
I was already a very happy user.
Ultimately, jj</code>’s interface and mental model do feel refreshing enough that I’m likely to continue using it.</p>


ASUS PA32QCV: a programmer's review
2025-10-15T00:00:00+00:00
Those who know me know that I invest in interfaces</a>.
Previously, I had an LG 38GN950-B</a> (38“ Ultrawide, 3840×1600 @ 144Hz).
It was expensive, but had a little extra vertical resolution vs its competitors, and the high refresh rate was great for casual gaming.
But, over the years, I play games less, and my eyes are aging!
I find myself appreciating larger and more crisp fonts for programming.</p>
With that in mind, I started looking for a high resolution “retina”-class display.
There are only a handful of these around at the time of writing.
In the 27“ 5K group: Apple Studio Display</a>/ProArt PA27JCV</a>/Samsung S9</a>/Kuycon G27P</a>.
Then, there is the 32“ 6K group: Apple Pro Display XDR/ProArt PA32QCV</a>/Kuycon G32P</a>/Dell U3225KB</a>/LG 32U990A-S</a>.
Then, there is the even more sparse 8K group: Dell UP3218K</a>/ProArt PA32KCX</a>.</p>
I know I wanted to avoid fractional scaling, so I was searching for either 6K or 8K.</p>
I immediately discovered that 8K is way out of my price range.</p>
In the land of 6K, this ProArt PA32QCV</a> met a sweet spot: (1) being available for purchase right now, (2) having relatively modern hardware, and (3) not being ridiculously expensive.
So, I bought it.</p>
First impressionsWOW.</strong></p>
I’m a big fan.
As soon as I switched, I understood why people like these high-resolution displays.
Text is crisp and delightful to look at!
I do not miss the ultrawide at all.</p>
I run at 2× scaling, and have been loving looking at it.</p>
Yes, I do notice the drop from 144Hz to 60Hz.
However, because I’m mostly programming, I really don’t notice it during a typical workday unless I go looking for it (e.g., dragging a window quickly).</p>
The colors look great.</p>
In other words, when it comes to the display itself, it seems fantastic, which is what I was looking for.</p>
Some people complain about the matte “LuxPixel” finish.
I think it looks fantastic, and appreciate the lack of glare.
This is an important feature, in my opinion.</p>
The less goodWhen it comes to some of the other features, they are notably less useful.</p>
SpeakersThese are fairly awful, as one would expect.
What confuses me is why these are here at all.
This is a “pro” monitor, and I see no value in having speakers.
I wish they saved some cost or reduced size/weight instead.</p>
KVMI frequently multiplex between a work laptop and a personal desktop.
So, a built-in KVM is actually very appealing!
However, I’ve never found one that works well for my needs, so I’ve always reverted to separate display cables and a USB switch.
The same is true here.</p>
Yes, this monitor has a KVM, but it does not have enough USB ports for my needs.
It has 3 USB ports, and 1 thunderbolt port.
The good news is that this lets me use 4 USB devices just fine on MacOS.
The bad news is that the 1 thunderbolt port does NOT work on my desktop, leaving me with just 3 devices.
Typically, I want four: a mouse, keyboard, webcam, and audio interface.
Five, if you count a security key.
So, good idea and will work for just a keyboard an mouse, but not enough for me.</p>
Another fatal flaw is that the KVM doesn’t appear to activate immediately upon switching input.
This is vital because if your other machine goes to sleep, the input button will not switch</em> until there is a display signal on that input—a signal that you have no way to initiate without a keyboard or mouse active!
With a USB switch, that means I typically switch, wake up the machine, and then switch the input.
With the built-in KVM, that means there is simply no way</em> to actually switch without waking up the machine first some other way.
Not cool.</p>
That said, my normal USB switch setup works well.</p>













  
    
      
      Note</span>
  </div>

  I recently improved this setup to be even better</a>.</p>
</div>
</div>
Light syncThe “Light Sync” feature actually sounded great: I work right by a window, and frequently do adjust brightness to compensate for the ambient light.
It would be awesome if it could do it for me!</p>
However, after using it, as far as I can tell there is no way to set the baseline/target brightness you want.
Instead, it ranges from acceptable (in Native</code> color preset) to unusably dim (in M Model-P3</code>).
It is a good idea, but the implementation seems to only be viable in Native</code> mode of the ones I tried, which means this forces you to make a color preset trade-off.
Instead, they should’ve just let me set the target brightness.</p>
That said, as someone not</em> using this monitor for color accuracy, specifically, I’ve been quite satisfied with Native</code> mode’s behavior thus far.</p>
The surprisingSome features/design choices I was pleasantly surprised at.
Not surprised they existed, but surprised how much I liked them.</p>

I really like buttons being on the front of the monitor, rather than needing to blindly click around on a side or bottom.</li>
No giant power supply!
I appreciate the saved desk space of having the power supply built-in.</li>
</ul>
CompatibilityThe box came with the display itself, a stand, a Thunderbolt 4 cable, an “ultra 8K” HDMI cable, and a power cable.</p>
After reading Michael Stapelberg’s review of the 6K Dell</a>, I was a little worried about compatibility.
I was optimistic that with a brand-new release, more compatibility issues would’ve been ironed out.</p>
I have two machines I use with this display: an M1 MacBook Pro, and my custom workstation</a> (Radeon RX 7800 XT), running both Windows and Linux.</p>
The monitor was clearly built with a MacBook in mind.
Using the Thunderbolt 4 cable, I instantly got power and display—full 6K no problems.
Colors do indeed seem highly matched with the M Model-P3</code> color preset.</p>
On my desktop with Windows via the included HDMI cable there was no problem.
It instantly recognized full 6K@60Hz.</p>
My desktop with Linux via the included HDMI cable?
No 6K at all.</p>
❯ hyprctl monitors</span></span>
Monitor</span> HDMI-A-2 </span>(</span>ID</span> 0</span>)</span>:</span></span>
        3008x1692</span>@59.96700 at 0x0</span></span>
        description</span>: ASUSTek COMPUTER INC PA32QCV T7LMSV006894</span></span>
        make</span>: ASUSTek COMPUTER INC</span></span>
        model</span>: PA32QCV</span></span>
        physical</span> size </span>(</span>mm</span>)</span>: 700x390</span></span>
        serial</span>: T7LMSV006894</span></span>
        active</span> workspace: 1 </span>(</span>1</span>)</span></span>
        special</span> workspace: 0 </span>()</span></span>
        reserved</span>: 0 26 0 0</span></span>
        scale</span>: 1.00</span></span>
        transform</span>: 0</span></span>
        focused</span>: yes</span></span>
        dpmsStatus</span>: 1</span></span>
        vrr</span>: false</span></span>
        solitary</span>: 0</span></span>
        solitaryBlockedBy</span>: windowed mode,missing candidate</span></span>
        activelyTearing</span>: false</span></span>
        tearingBlockedBy</span>: next frame is not torn,user settings,missing candidate</span></span>
        directScanoutTo</span>: 0</span></span>
        directScanoutBlockedBy</span>: user settings,missing candidate</span></span>
        disabled</span>: false</span></span>
        currentFormat</span>: XRGB8888</span></span>
        mirrorOf</span>: none</span></span>
        availableModes</span>:</span></span>
            3008x1692</span>@59.97Hz</span></span>
            4096x2160</span>@60.00Hz</span></span>
            4096x2160</span>@59.94Hz</span></span>
            4096x2160</span>@50.00Hz</span></span>
            4096x2160</span>@30.00Hz</span></span>
            4096x2160</span>@29.97Hz</span></span>
            4096x2160</span>@25.00Hz</span></span>
            4096x2160</span>@24.00Hz</span></span>
            4096x2160</span>@23.98Hz</span></span>
            3840x2160</span>@60.00Hz</span></span>
            3840x2160</span>@59.94Hz</span></span>
            3840x2160</span>@60.00Hz</span></span>
            ...</span></span></code></pre>
I first went down a bit of a rabbit hole assuming it was a Linux software issue (the same hardware works with Windows!).
But, I’m running Arch, with a very recent kernel and all up-to-date drivers.
I decided to try a DisplayPort cable instead.</p>
❯ hyprctl monitors</span></span>
Monitor</span> DP-1 </span>(</span>ID</span> 0</span>)</span>:</span></span>
        6016x3384</span>@59.99200 at 0x0</span></span>
        description</span>: ASUSTek COMPUTER INC PA32QCV T7LMSV006894</span></span>
        make</span>: ASUSTek COMPUTER INC</span></span>
        model</span>: PA32QCV</span></span>
        physical</span> size </span>(</span>mm</span>)</span>: 700x390</span></span>
        serial</span>: T7LMSV006894</span></span>
        active</span> workspace: 1 </span>(</span>1</span>)</span></span>
        special</span> workspace: 0 </span>()</span></span>
        reserved</span>: 0 26 0 0</span></span>
        scale</span>: 2.00</span></span>
        transform</span>: 0</span></span>
        focused</span>: yes</span></span>
        dpmsStatus</span>: 1</span></span>
        vrr</span>: false</span></span>
        solitary</span>: 0</span></span>
        solitaryBlockedBy</span>: windowed mode,missing candidate</span></span>
        activelyTearing</span>: false</span></span>
        tearingBlockedBy</span>: next frame is not torn,user settings,missing candidate</span></span>
        directScanoutTo</span>: 0</span></span>
        directScanoutBlockedBy</span>: user settings,missing candidate</span></span>
        disabled</span>: false</span></span>
        currentFormat</span>: XRGB8888</span></span>
        mirrorOf</span>: none</span></span>
        availableModes</span>:</span></span>
            6016x3384</span>@59.99Hz</span></span>
            3008x1692</span>@59.97Hz</span></span>
            6016x3384</span>@29.99Hz</span></span>
            4096x2160</span>@60.00Hz</span></span>
            4096x2160</span>@59.94Hz</span></span>
            4096x2160</span>@50.00Hz</span></span>
            4096x2160</span>@30.00Hz</span></span>
            ...</span></span></code></pre>
Whew!
Instantly recognized the 6K@60Hz.</p>
So, that’s the tip: use DisplayPort on Linux.</p>
VerdictSo far, after a bit more than 3 months of daily use, I’m very</em> pleased.</p>
One of the biggest evidences of how nice it is was when I went back to my old monitor for a little bit.
The lack of text clarity was just as apparent as my initial shock at the clarity going the other direction.</p>
We’ll see how it fares long term, but this is absolutely a keeper right now.</p>


AI etiquette
2025-10-05T00:00:00+00:00
It’s the thought that countsI recently read a great blog post from Alex Martsinovich</a>.
It expressed a concept that I’ve been feeling, too: proof-of-thought</em>.</p>

For the longest time, writing was more expensive than reading.
If you encountered a body of written text, you could be sure that at the very least, a human spent some time writing it down.
The text used to have an innate proof-of-thought, a basic token of humanity.</p>
Now, AI has made text very, very, very cheap.
Not only text, in fact.
Code, images, video.
All kinds of media.
We can’t rely on proof-of-thought anymore.
Any text can be AI slop.
If you read it, you’re injured in this war.
You engaged and replied – you’re as good as dead.
The dead internet is not just dead it’s poisoned.
So what do we do?</p>
Luckily for us, AI only talks in response.
Unlike Earth, AI does not emit comedy sketches into outer space on its own.
To get AI slop, somebody needs to ask for it.
To send it further, someone needs to retransmit it.
Our problem is other humans, really.</p>
There’s nothing wrong with using AI.
When you do, you know what you’re getting.
The transaction is fully consensual.
But whenever you propagate AI output, you’re at risk of intentionally or unintentionally legitimizing it with your good name, providing it with a fake proof-of-thought.
In some cases, it’s fine, because you did think it through and adopted the AI output as your own.
But in other cases, it is not, and our scrambler brain feels violated.</p>
</blockquote>
He goes on to propose a simple new sense of etiquette: AI output can only be relayed if it’s either adopted as your own or there is explicit consent from the receiving party</strong>, otherwise, it is horribly rude.
I’d add that essentially, you either are providing proof-of-thought, or, you’re explicitly acknowledging the lack of it.</p>
This resonates.</p>
Another way to put this is: if you are requesting human attention, demonstrate human effort</a>.</p>
Relatable example in the wildIt reminds me of Neven Mrgan’s reflection on how it feels to get an AI email from a friend</a>.</p>

Recently I received an AI-written email from a friend.
It wasn’t sent to test AI, or to show it off, as in “ha ha check this out”; my friend had a question to ask me, and the email asked it over the course of a few paragraphs.
It then disclosed that, oh by the way, I used AI to write this.
My reaction to this surprised me: I was repelled, as if digital anthrax had poured out of the app.
I’m trying to figure out why.</p>
</blockquote>
He then really breaks down how it did and didn’t feel as a recipient.
For example, it didn’t feel like they were using it as an autocorrect to type better.
It did feel like a family fridge decorated with printed stock art of children’s drawings.</p>

Years from now, could an AI that was trained on all of my friend’s emails and texts and personal documents sound convincingly like them?
Could it be so advanced that I wouldn’t even be able to tell that my friend hadn’t written to me at all?
Possibly.
And that idea saddens me the most.</p>
</blockquote>
Another is the bleakly entertaining rant by Bryan Cantrill: Your intellectual fly is open</a>.</p>

When you use an LLM to author a post, you may think you are generating plausible writing, but you aren’t: to anyone who has seen even a modicum of LLM-generated content (a rapidly expanding demographic!), the LLM tells are impossible to ignore.
Bluntly, your intellectual fly is open: lots of people notice — but no one is pointing it out.
And the problem isn’t merely embarrassment: when you — person whose perspective I want to hear! — are obviously using an LLM to write posts for you, I don’t know what’s real and what is in fact generated fanfic.
You definitely don’t sound like you, so…is the actual content real?
I mean, maybe?
But also maybe not.
Regardless, I stop reading — and so do lots of others.</p>
</blockquote>
My pledgeThe words on this blog have been and will always be, manually and intentionally typed by me (on a keyboard that I find delightful).
Yes, I am a big em dash (and en dash!) user—I even have macros in my editor</a> to make the substitutions.
No, that’s not AI.
Yes, you’ll find typos and grammar errors in my posts; I’m human (but if you do, please send me a note so I can fix it).
Still, I find writing a good way to clarify my own thoughts and, while I primarily write for myself, occasionally someone else benefits, too.</p>
While we have no formal way to provide proof-of-thought, my pledge to both you and myself is that this place will remain a place for human thought, and more specifically, my personal ramblings.</p>


Repairing my Windows bootloader after Omarchy
2025-09-09T00:00:00+00:00
The problemBefore I switched to Omarchy, I was running omakase-blue</code> on one NVME drive, and Windows on another.
Part of this is because I want to use full disk encryption, and part of this is because I was originally playing with Project Bluefin</a>, which doesn’t support dual-boot off of a single disk.</p>
I installed Omarchy via online ISO, and pointed it at my Linux drive.</p>
After it installed, I no longer could boot into Windows.
My BIOS didn’t even show the 2nd NVME drive as a boot option.</p>
The solutionAfter some digging, I figured out a way to get things back without needing to reinstall any operating systems.
My system looked like this after the Omarchy install:</p>
❯ lsblk --output NAME,PTTYPE,PARTLABEL,FSTYPE,FSVER,LABEL,FSSIZE,FSAVAIL,FSUSE%,MOUNTPOINTS</span></span>
NAME        PTTYPE PARTLABEL                    FSTYPE      FSVER LABEL FSSIZE FSAVAIL FSUSE% MOUNTPOINTS</span></span>
zram0                                           swap        1     zram0                       [SWAP]</span></span>
nvme0n1     gpt</span></span>
├─nvme0n1p1 gpt                                 vfat        FAT32           2G    1.8G     9% /boot</span></span>
└─nvme0n1p2 gpt                                 crypto_LUKS 2</span></span>
  └─root                                        btrfs                     1.8T    1.8T     2% /var/log</span></span>
                                                                                              /home</span></span>
                                                                                              /var/cache/pacman/pkg</span></span>
                                                                                              /</span></span>
nvme1n1     gpt</span></span>
├─nvme1n1p1 gpt    Microsoft reserved partition</span></span>
├─nvme1n1p2 gpt    Basic data partition         ntfs</span></span>
└─nvme1n1p3 gpt                                 ntfs</span></span></code></pre>
That is, the vfat</code>, FAT32</code> partition with the bootloader was on nvme0n1</code>, and it didn’t seem there was any corresponding partition on nvme1n1</code>.</p>
The good news is that this indicated that I could probably just restore the required boot files to nvme0n1p1</code> for Windows and be on my way.</p>
Repairing the Windows bootloader filesTo do so, I used Hiren’s BootCD PE</a> on a USB drive with Ventoy</a>.</p>
Once in the Windows PE environment, we can restore the files with diskpart</code></a> and bcdboot</code></a> in the command prompt.</p>
diskpart</span></span>
</span>
> list volumes</span></span>
</span>
# find the fat32 one, let's call it X</span></span>
> select volume X</span></span>
> assign letter K:</span></span></code></pre>
Now that we’ve assigned a letter, we can fix the files:</p>
  bcdboot C:\Windows /s K: /f ALL</span></span></code></pre>
where /s</code> specifies the volume letter of the system partition, and /f</code> specifies the firmware type (ALL</code> copies all of them).</p>
At this point, I could once again boot from this drive and land in Windows.</p>
Adding Windows to LimineBut, we could do even better!
Having to use the BIOS boot menu is annoying: you typically have to spam an F</code>-key at startup, and if you miss your opportunity, need to restart again.
It would be nice to be able to just boot to the same bootloader and select Windows, like in a traditional single-drive, dual-boot setup.</p>
Turns out that isn’t hard, since Omarchy uses Limine</a> out of the box.</p>
In Linux, we can just edit the boot config.</p>
sudoedit</span> /boot/limine.conf</span></span></code></pre>
Then, I added the following entry after the Omarchy ones, and before the EFI fallback.</p>
/Windows</span></span>
comment: Windows</span></span>
comment: order-priority=40</span></span>
    protocol: efi</span></span>
    path: boot():/EFI/Microsoft/Boot/bootmgfw.efi</span></span></code></pre>
With this, I then configured my BIOS to with Limine as the first boot option, and disabled the others.
Now, it boots to Limine on startup, and my Windows drive is once again an easy option to select.
Nice.</p>


Berkeley Mono Variable (TX-02) in Ghostty
2025-09-07T00:00:00+00:00
Inspired by Michael Bommarito’s post</a>, I’m just dropping some quick notes on getting Berkeley Mono Variable (TX-02) to work in Ghostty.
Specifically, Berkeley Mono 2.002</code>, released on 2024-12-31, running in Ghostty 1.1.3-arch1</code>.
Using the variable version of the font is highly convenient: it is very fast to change styles and tweak things until it is exactly how you like it, without having to iterate with installing static fonts.</p>
I suggest you read his post first for lots of nice context on fonts and their features.</p>
Then, the key bit of information I needed to get this working was the following.
TX-02, the updated version of Berkeley Mono, has different OpenType features than the original.
There is no documentation I could find on exactly what they mean, but via some trial and error, I’ve landed on the following config.</p>
font-family = "Berkeley Mono Variable"</span></span>
</span>
# Font width (60 to 100)</span></span>
#  60 = UltraCondensed</span></span>
#  70 = ExtraCondensed</span></span>
#  80 = Condensed</span></span>
#  90 = SemiCondensed</span></span>
# 100 = Normal</span></span>
font-variation = wdth=90</span></span>
</span>
# Font weight (100 to 900)</span></span>
# 100 = Thin</span></span>
# 200 = ExtraLight</span></span>
# 300 = Light</span></span>
# 350 = SemiLight</span></span>
# 400 = Regular</span></span>
# 500 = Medium</span></span>
# 600 = SemiBold</span></span>
# 700 = Bold</span></span>
# 800 = ExtraBold</span></span>
# 900 = Black</span></span>
font-variation = wght=400</span></span>
</span>
# Font slant (0 to -16)</span></span>
#   0 = Regular</span></span>
# -16 = Oblique</span></span>
font-variation = slnt=0</span></span>
</span>
# otfinfo -f ~/.local/share/fonts/Berkeley\ Mono\ Variable.otf</span></span>
# aalt    Access All Alternates</span></span>
# calt    Contextual Alternates</span></span>
# ccmp    Glyph Composition/Decomposition</span></span>
# mark    Mark Positioning</span></span>
# mkmk    Mark to Mark Positioning</span></span>
# salt    Stylistic Alternates</span></span>
# ss01    Stylistic Set 1 <- slashed 0</span></span>
# ss02    Stylistic Set 2 <- dotted 0</span></span>
# ss03    Stylistic Set 3 <- gap 0</span></span>
# ss04    Stylistic Set 4 <- slashed 0, slash 7</span></span>
# ss05    Stylistic Set 5 <- dotted 0, slash 7</span></span>
# ss06    Stylistic Set 6 <- gap 0, slash 7</span></span>
font-feature = +calt</span></span>
font-feature = +ss02</span></span>
</span>
font-size = 13</span></span>
# Personal preference</span></span>
adjust-cell-height = -2%</span></span></code></pre>
Specifically, I found that aalt</code> and salt</code> appear to change what the stylistic sets do (to different things than my comments).
ccmp</code>, mark</code>, and mkmk</code> don’t do anything that I noticed.
So, effectively, it seems to me that the only two features you actually care about are your font-variation</code> settings, and then whether you want ligatures with calt</code>, and what style of 0</code>/7</code> you want via stylistic sets.</p>
Another tip: if you have static versions of Berkeley Mono installed, I noticed that that sometimes breaks Ghostty from loading Berkeley Mono Variable.
I’m unsure why, but I was able to resolve it by removing the static fonts, configuring things, and then putting them back.</p>


The youngest sibling advantage
2025-08-31T00:00:00+00:00
I am the youngest child in my family.</p>
I’ve heard a lot of discussion around the stereotypical traits of the youngest child.
In fact, many of these are so commonly echoed that they have their own name: youngest child syndrome</a>.
Sure, some of these arguably apply to me (certainly my older siblings would label me spoiled), and others do not.
But, what I haven’t heard in many of these discussions is what I consider to be the biggest single advantage: life scouts</strong>.
No, not like Boys Scouts of America “Life” scouts, like people scouting ahead for you in life.</p>
The youngest child often has older siblings they have observed keenly, maintained a strong and open rapport with, and with whom they have shared significant life experiences.
They know them at a profound level.</p>
They then get to observe these older siblings blaze a variety of trails through life, years ahead of them.
The youngest get to observe the decisions the older siblings make, often well aware of context, and then see the consequences of those decisions play out.
Sometimes those consequences are positive, and sometimes they are not.
Sometimes the outcome seems causal, and sometimes it seems that luck played a large role.
Sometimes that whole decision-consequence cycle can happen well before a younger sibling might be faced with a similar decision.</p>
In many ways, this is like mentorship on an amplified level.
Not mentorship in terms of career or school advice, but mentorship in life—hard earned advice and examples in real time, with real stakes, resulting in real impact.</p>
The advantage of having life scouts naturally follows.
The youngest now has deeply detailed experience of highly trusted people to draw from when navigating the world ahead of them.
As a kid, you already know the best parks or playgrounds nearby.
You also know what areas of the neighborhood are dangerous.
As a student, you’re confident in navigating the school system, and the trade-offs of different schedule choices.
As an adult, you have gleaned some insight on dating and partner choices, and how those can affect directions in life.
You have observed different fields of study or career choices, and how those areas affect stress, income, flexibility, and more.
You have witnessed glimpses of different parenting styles and parenting choices.
The examples are endless.</p>
Sure, not everything directly transfers, but I’ve found these “life scouts” to be priceless in my life.
A shout-out to all the older siblings out there who pave paths and building organizational knowledge for those of us who come afterward.
We appreciate you!</p>
As for me, I think benefiting from such mentorship (from siblings) is also why I value mentorship in general so highly.
As the youngest sibling, I might not be able to provide powerful mentorship this particular way, but I still can hopefully pay it forward to nieces and nephews and other youth in my community.</p>


Comparing UTOPIA ISPs
2025-08-03T00:00:00+00:00
I currently use UTOPIA</a> for my fiber connection.
Their model is that they charge for the infrastructure, and then they have many ISPs on top that provide competing internet services.</p>
PricingAs a snapshot comparison (primarily for my own notes), here’s a comparison of pricing for residential</em> service, on the tier of 1Gbps download and upload (symmetric).
This is the tier I’m currently on.</p>
ISP</th> Price ($)</th> Notes</th></tr></thead>

Centra</a></td> 43.95</code></td> Appear more honest on their Broadband label (showing 841Mbps/884Mbps down/up, rather than 1000Mbps).</td></tr>
ETS</a></td> 45.00</code></td> Up to 10Gbps.</td></tr>
Fusion Networks</a></td> 45.00</code></td> 1Gb is their fastest plan.</td></tr>
3wave</a></td> 48.00</code></td> </td></tr>
SenaWave</a></td> 48.00</code></td> Very sparse on details.</td></tr>
Voonami</a></td> 48.95</code></td> Comes with a free static IP on request. Also offers colo services. 2.5 Gbps fastest.</td></tr>
SumoFiber</a></td> 49.95</code></td> Appear slightly more honest, stating 980 Mbps up/down.</td></tr>
IntelliPop</a></td> 49.95</code></td> </td></tr>
ConnectFast</a></td> 53.95</code></td> Only a single plan: 1Gb</td></tr>
FiberNet</a></td> 53.95</code></td> 1Gb is their fastest plan, but they have infra (i.e., offers colo services).</td></tr>
XMission</a></td> 54.00</code></td> Runs an extra firewall layer than can break some websites.</td></tr>
Miles Broadband</a></td> 54.00</code></td> </td></tr>
WiFiPros</a></td> 55.00</code></td> I dislike the company name.</td></tr>
Advanced Stream</a></td> 55.00</code></td> 10 TB data cap, others are unlimited. Honest with specific speeds.</td></tr>
Brigham</a></td> 58.95</code></td> Wordpress site, sloppy errors like discrepancies in pricing.</td></tr>
InfoWest</a></td> 80.00</code></td> Unclear to me if this $80 includes UTOPIA’s $30. Probably?</td></tr>
Beehive Broadband</a></td> N/A</td> Hard to find pricing is a dark pattern.</td></tr>
Rise Broadband</a></td> N/A</td> Couldn’t find price.</td></tr>
Fastel</a></td> N/A</td> Sketchily sparse website and no pricing. Dark patterns.</td></tr>
</tbody></table>
At some point, I want to go through and learn more about their nuances.
For example, XMission has an annoying trait of running their own firewall, which breaks websites occasionally.
But, they also run their own datacenters and have some nice peering agreements that likely improve latency and performance.</p>
Here’s a UTOPIA-provided comparison sheet</a>, too.
There is some discrepancy in the pricing and the ISPs themselves, though.</p>


Variable fonts and italics across browsers
2025-05-25T00:00:00+00:00
I’m a big fan of Atkinson Hyperlegible Next</a> and Berkeley Mono</a> (TX-02).
It is my opinion that they both look great, unique, and provide valuable legibility features.</p>
I recently refactored this site to use the variable, web versions of these fonts.
I was happy that I now had only a single @font-face</code> definition, not a handful, and went on my way.
(I had haphazardly picked up these parameters on the Internet somewhere.)</p>
@font-face</span> {</span></span>
    font-family</span>:</span> 'Berkeley Mono'</span>;</span></span>
    src</span>:</span> url</span>(</span>'../fonts/Berkeley Mono Variable.woff2'</span>)</span> format</span>(</span>'woff2'</span>);</span></span>
    font-stretch</span>:</span> 60 100</span>;</span></span>
    font-weight</span>:</span> 100 900</span>;</span></span>
    font-style</span>:</span> oblique</span> -16</span>deg</span> 0</span>deg</span>;</span></span>
    font-feature-settings</span>:</span> calt</span>;</span></span>
    font-variant-ligatures</span>:</span> contextual</span>;</span></span>
}</span></span>
</span>
@font-face</span> {</span></span>
    font-family</span>:</span> 'Atkinson Hyperlegible Next'</span>;</span></span>
    src</span>:</span> url</span>(</span>'../fonts/AtkinsonHyperlegibleNextVF-Variable.woff2'</span>)</span> format</span>(</span>'woff2'</span>);</span></span>
    font-weight</span>:</span> 100 900</span>;</span></span>
    font-style</span>:</span> oblique</span> -16</span>deg</span> 0</span>deg</span>;</span></span>
}</span></span></code></pre>
Then, just recently, I realized that my italics were broken on this site for weeks!
They worked on Chrome as I had it configured.
They did not work on Firefox.</p>
I tried a few things.</p>
First, I tried duplicating the @font-face</code> definition, but with font-style: italic</code>.
This made it work on Firefox, but broke Chrome.</p>
I then found there is a new way to specify italics for variable web fonts, specifically (assuming it is supported by the font): font-variation-settings</code>.
In the case of Atkinson Hyperlegible Next, I could get my italics looking right on both Firefox and Chrome by adding the following CSS.</p>
em</span> {</span></span>
  font-variation-settings</span>:</span> "ital"</span> 1</span>;</span></span>
  font-synthesis</span>:</span> none</span>;</span></span>
}</span></span></code></pre>
But, this didn’t work for Berkeley Mono.</p>
I also tried things like using woff2-variations</code> in my @font-face</code> definitions and other little tweaks to no avail.</p>
Finally, after more experimentation, I was pleasantly surprised that I could get everything working just by simplifying</em>.</p>
@font-face</span> {</span></span>
    font-family</span>:</span> 'Berkeley Mono'</span>;</span></span>
    src</span>:</span> url</span>(</span>'../fonts/Berkeley Mono Variable.woff2'</span>)</span> format</span>(</span>'woff2'</span>);</span></span>
    font-stretch</span>:</span> 60 100</span>;</span></span>
    font-weight</span>:</span> 100 900</span>;</span></span>
    font-feature-settings</span>:</span> calt</span>;</span></span>
    font-variant-ligatures</span>:</span> contextual</span>;</span></span>
}</span></span>
</span>
@font-face</span> {</span></span>
    font-family</span>:</span> 'Atkinson Hyperlegible Next'</span>;</span></span>
    src</span>:</span> url</span>(</span>'../fonts/AtkinsonHyperlegibleNextVF-Variable.woff2'</span>)</span> format</span>(</span>'woff2'</span>);</span></span>
    font-weight</span>:</span> 100 900</span>;</span></span>
}</span></span></code></pre>
I dropped the (likely incorrect) font-style</code> attribute.
No need for the em</code> class override, now, either.</p>
With that, I have italics</em>, both for my normal font, and for my monospace </code></em> font that work on both Firefox and Chrome.
All I needed to do was delete the right two lines.</p>


Performance gains of undervolting a T480s
2025-05-23T00:00:00+00:00
I have been using a self-refurbished Thinkpad X230</a> for quite a while as a personal machine.
I believe in the benefits of continuing to use old laptops [1</a>, 2</a>, 3</a>].
However, recently, I’ve started to need to use a laptop to do presentations frequently, and the HDMI port on my X230 is not functioning fully, resulting in distorted colors and other distracting artifacts.
I might try and repair that, someday.</p>
However, due to pressing need, I instead picked up a used T480s</a> from a good friend, which had a working HDMI port.</p>
Over the first couple days of use, I noticed that this thing ran hot</em>.
Sure, I have the i7-8650u</code> version, but the fans were spinning up far more than I’d like, and CPU temps would frequently exceed 95 °C for bursts at a time.</p>
Naturally, I did a little digging.</p>
It turns out, Linux and the T480s have a longstanding problem!
I don’t understand the problem well enough to explain it here.
But, essentially, people were seeing throttling and temperature issues with these machines on Linux (but not Windows).
To be clear, this issue was found on an old Linux kernel (4.15, I’m on 6.14).
I do not know if this specific problem is affecting me.
However, through this, I learned about a fun tool for undervolting a T480s: throttled</code></a>.</p>
Even if this issue was resolved in newer kernels, I imagined that some undervolting could still help my thermals and performance.
So, I tried it.
In addition, to give the attempt the best chance it had, I also replaced the thermal paste with fresh Duronaut</a>.</p>
I was surprised to find a 12% improvement</strong> in single-core performance and a 24% improvement</strong> in multi-core on Geekbench 6!</p>

Metric</th> Original</a></th> Optimized</a></th> Change (%)</th></tr></thead>

Single-core</td> 1341</code></td> 1499</code></td> +11.8</code></td></tr>
Multi-core</td> 3989</code></td> 4948</code></td> +24.0</code></td></tr>
</tbody></table>
</div>
The laptop runs much cooler, and the fans spin up much less.
It’s much more pleasant to use.</p>
I ultimately landed on the following undervolt for this machine.
(Remember, each chip is different, you might not be able to use these values.)</p>
# All voltage values are expressed in mV and *MUST* be negative (i.e. undervolt)!</span></span>
[</span>UNDERVOLT</span>]</span></span>
# CPU core voltage offset (mV)</span></span>
CORE: -135</span></span>
# Integrated GPU voltage offset (mV)</span></span>
GPU: -105</span></span>
# CPU cache voltage offset (mV)</span></span>
CACHE: -135</span></span>
# System Agent voltage offset (mV)</span></span>
UNCORE: -105</span></span>
# Analog I/O voltage offset (mV)</span></span>
ANALOGIO: 0</span></span></code></pre>
What a satisfying way to squeeze a little more performance out of a still-great laptop.</p>


Steel man arguments, or arguing intelligently
2025-03-22T00:00:00+00:00
I’m a big fan of the idea of “steel man” argument.
However, I’ve found that this term is far less widely known than its “straw man” counterpart.
I’ve heard some people just call this “arguing intelligently”.</p>
Here are two good definitions if you’re unfamiliar with the idea.
First, Wikipedia’s for the more abstract definition, and then Robin Sloan’s practical example.</p>
Wikipedia</a>:</p>

A steel man argument (or steelmanning) is the opposite of a straw man argument. Steelmanning is the practice of applying the rhetorical principle of charity through addressing the strongest form of the other person’s argument, even if it is not the one they explicitly presented. Creating the strongest form of the opponent’s argument may involve removing flawed assumptions that could be easily refuted or developing the strongest points which counter one’s own position. Developing counters to steel man arguments may produce a stronger argument for one’s own position.</p>
</blockquote>
Robin Sloan</a></p>

There are two debaters, Alice and Bob. Alice takes the podium, makes her argument. Then Bob takes her place, but before he can present his counter-argument, he must summarize Alice’s argument to her satisfaction — a demonstration of respect and good faith. Only when Alice agrees that Bob has got it right is he permitted to proceed with his own argument — and then, when he’s finished, Alice must summarize it to his satisfaction.</p>
The first time I saw one of these debates, it blew my mind.</p>
</blockquote>
Or, as Stephen R. Covey put it: “Seek first to understand, then to be understood</a>”.</p>
Imagine if the default mode of debate was like this.
A tool for persuasion, consideration, exploration, and achieving consensus (or at least clearly understanding the shape of disagreement).
Instead, culturally, we’re more used to debate as a stage for name-calling, politics, distraction, point-scoring, and drama.</p>
Next time you’re debating something, consider arguing more intelligently, and treating the other parties with that same human respect.</p>


Sharing intro cards
2025-03-16T00:00:00+00:00
Those who know me know that I am fairly introverted.
But, I am also someone who strongly values community, and thinks there are huge benefits to be had by building or connecting to one.</p>
A big part of building or integrating into communities is getting to know the people in them.
Some people have a natural talent for this.
Others have built that skill through many years of deliberate practice.
There are also some people who use software to manage and track these relationships “personal CRM”-style (e.g., Monica</a>, or really detailed notes in Google Contacts).</p>
I am currently none of these people.</p>
But, I would like to build the skill.</p>
One reason knowing people is valuable is that it helps facilitate connection.
“Oh, I know X</code> is in that industry, let me connect you.”
“The Y</code> family has kids that line up with your kids age and go to Z</code> Junior High, too.”
“Oh A</code> used to live right around there, let’s ask them for advice.”
These types of serendipitous connections can build strong bonds and strengthen a community, but you can only make them if you know enough.</p>
To that end, I think “intro cards” are an interesting idea.
Imagine that when you moved in somewhere, or went to a new neighborhood meeting or church event, or met with the other parents for your kid’s soccer team, you could get a small physical</em> card of pertinent information about these new people you met.</p>
In big social settings like that, where you’re meeting a lot of new people, it’s very easy (for me, anyway) to have forgotten the names of the people I just</em> talked to.
Now, instead imagine that throughout the event, you were exchanging intro cards, something like the following.</p>

  
    
  </a>
  
    An example intro card, 3"×5" sized.
  </figcaption>
</figure>
During the event, you could focus completely on the current conversations, knowing you already have some notes provided to you to recall the previous ones.</p>
Is the concept so wild?
In Japan, there is a whole interesting culture around exchanging business cards</a>.
In the US, we rarely do so.
A small Japanese town recently went even further, making a whole trading card game</a> for the middle-aged members of their town, connecting the youth to older generations in a heartwarming way.</p>
Naturally, these intro cards might include personal information you probably wouldn’t put on the Internet, but might want to provide to people depending on the context.
So, of course, you should tune the content to the purpose.
You should also feel things out first, before you just go handing these to everyone.
For example, in the context of introducing yourself to neighbors, maybe it is something like Bart’s above.
If it’s meeting coworkers, maybe it highlights parts of the system you’re familiar with, or your favorite software or languages.
If it’s a hobby group, maybe it highlights more about your specific niche interests.</p>
I’ve started trying this idea out in a few scenarios, to positive reception.
To make it easy, I just print these on 3“×5“ index cards at home rather than deal with producing actual cards.
An example Typst document for it is included below.</p>

Source Code: Example Intro Card in Typst</a></summary>
#set</span> text</span>(</span>font</span>:</span> "Berkeley Mono"</span>)</span></span>
#set</span> text</span>(</span>9pt</span>)</span></span>
#set</span> par</span>(</span>leading</span>:</span> 0.35em</span>)</span></span>
#set</span> page</span>(</span></span>
  width</span>:</span> 3in</span>,</span></span>
  height</span>:</span> 5in</span>,</span></span>
  margin</span>:</span> 0.25in</span>,</span></span>
  // background: rect(width: 100%, height: 100%, stroke: 1pt + black),</span></span>
)</span></span>
</span>
// Placed here because these are reused to make links</span></span>
#let</span> telephone_number</span> =</span> "xxx-xxx-xxxx"</span></span>
#let</span> email_address</span> =</span> "xxxx@example.com"</span></span>
#let</span> website</span> =</span> "www.example.com"</span></span>
</span>
#</span>grid</span>(</span></span>
  columns</span>:</span> 100%</span>,</span></span>
  rows</span>: (</span>1%</span>,</span> 1%</span>,</span> 40%</span>,</span> 2%</span>,</span> 2%</span>,</span> 1fr</span>),</span></span>
  gutter</span>:</span> 1.0mm</span>,</span></span>
  grid.</span>cell</span>(</span></span>
    text</span>(</span>size</span>:</span> 11pt</span>,</span> weight</span>:</span> "bold"</span>,</span> "Bart Simpson"</span>),</span></span>
    align</span>: (</span>left</span> +</span> horizon</span>),</span></span>
  ),</span></span>
  [],</span></span>
  grid.</span>cell</span>(</span></span>
    block</span>(</span>clip</span>:</span> true</span>,</span> radius</span>:</span> 3mm</span>,</span> image</span>(</span>"bart.png"</span>)),</span></span>
    align</span>: (</span>center</span> +</span> horizon</span>),</span></span>
  ),</span></span>
  [],</span></span>
  grid.</span>hline</span>(</span>stroke</span>: (</span>paint</span>:</span> gray</span>,</span> thickness</span>:</span> 0.75pt</span>,</span> cap</span>:</span> "round"</span>),</span> y</span>:</span> 4</span>),</span></span>
  [],</span></span>
  grid</span>(</span></span>
    columns</span>: (</span>20%</span>,</span> 1fr</span>),</span></span>
    column-gutter</span>:</span> 2mm</span>,</span></span>
    row-gutter</span>:</span> 2.20mm</span>,</span></span>
    // stroke: 1pt + silver,</span></span>
    grid.</span>cell</span>([*</span>age</span>*],</span> align</span>:</span> right</span>),</span> grid.</span>cell</span>(</span></span>
      [</span>Born in XXXX</span>],</span></span>
      align</span>:</span> left</span>,</span></span>
    ),</span></span>
    grid.</span>cell</span>([*</span>family</span>*],</span> align</span>:</span> right</span>),</span> grid.</span>cell</span>(</span></span>
      [</span>Spouse: Susan </span>\</span></span>
        Children: Johnny (M, XXXX)</span>],</span></span>
      align</span>:</span> left</span>,</span></span>
    ),</span></span>
    grid.</span>cell</span>([*</span>rel-to</span>*],</span> align</span>:</span> right</span>),</span> grid.</span>cell</span>(</span></span>
      [</span>Marge (mom), Homer (dad), Lisa (sis), Maggie (sis)</span>],</span></span>
      align</span>:</span> left</span>,</span></span>
    ),</span></span>
    grid.</span>cell</span>([*</span>from</span>*],</span> align</span>:</span> right</span>),</span> grid.</span>cell</span>(</span></span>
      [</span>New York, NY (</span>--</span>XXXX) </span>\</span> Chicago, IL (</span>--</span>XXXX)</span>],</span></span>
      align</span>:</span> left</span>,</span></span>
    ),</span></span>
    grid.</span>cell</span>([*</span>job</span>*],</span> align</span>:</span> right</span>),</span> grid.</span>cell</span>(</span></span>
      [</span>Manager at </span>#</span>link</span>(</span>"https://www.example.com"</span>)</span>[Example</span>]</span>]</span>,</span></span>
      align</span>:</span> left</span>,</span></span>
    ),</span></span>
    grid.</span>cell</span>([*</span>edu</span>*],</span> align</span>:</span> right</span>),</span> grid.</span>cell</span>(</span></span>
      [</span>NYU (BS in PR, 'XX)</span>],</span></span>
      align</span>:</span> left</span>,</span></span>
    ),</span></span>
    grid.</span>cell</span>([*</span>email</span>*],</span> align</span>:</span> right</span>),</span> grid.</span>cell</span>(</span></span>
      link</span>(</span>"mailto:"</span> +</span> email_address</span>,</span> email_address</span>),</span></span>
      align</span>:</span> left</span>,</span></span>
    ),</span></span>
    grid.</span>cell</span>([*</span>phone</span>*],</span> align</span>:</span> right</span>),</span> grid.</span>cell</span>(</span></span>
      link</span>(</span>"tel:"</span> +</span> telephone_number</span>,</span> telephone_number</span>),</span></span>
      align</span>:</span> left</span>,</span></span>
    ),</span></span>
    grid.</span>cell</span>([*</span>website</span>*],</span> align</span>:</span> right</span>),</span> grid.</span>cell</span>(</span></span>
      link</span>(</span>"https://"</span> +</span> website</span>,</span> website</span>),</span></span>
      align</span>:</span> left</span>,</span></span>
    ),</span></span>
    [],</span> grid.</span>cell</span>(</span></span>
      text</span>(</span>size</span>:</span> 5pt</span>,</span> style</span>:</span> "italic"</span>)[</span>v25.03</span>],</span> // calver</span></span>
      align</span>:</span> right</span> +</span> top</span>,</span></span>
    ),</span></span>
  )</span></span>
)</span></span></code></pre></details>

Zappos
Zappos is well known for its unique pay-to-quit</a> approach to making sure the team is invested. It provides an attractive off-ramp for those who are less committed to or interested in the company after their training period, instead of staying despite lacking passion for the work.</p>

Final thoughts
Omarchy and the cascade of software that that showed me was the big change this year, with a couple of other fun highlights like Ghostty, `jj</code>, and age</code>.</p>`
`Otherwise, the trusty toolbox has largely remained trusty!</p>`

`Thoughts so farI actually find jj</code> quite fun! Again, I do not think it “solved” any pain points I had with git</code>. I was already a very happy user. Ultimately, jj</code>’s interface and mental model do feel refreshing enough that I’m likely to continue using it.</p>`

Variable fonts and italics across browsers

Performance gains of undervolting a T480s

Steel man arguments, or arguing intelligently

Sharing intro cards

Luke Hsiao's blog

Omarchy on an ASUS CN60 Chromebox

Tip: creating a recurring 5th Sunday event in Google Calendar

Using a USB switch as a full KVM

Using Changesets in a polyglot monorepo

Fixing missing Omarchy boot entries

The outsized impact of cultural idiosyncrasies

2026 is the year I return to rigorous planning

My favorite software in 2025

Switching from GPG to age

First impressions of jj from a git fan

ASUS PA32QCV: a programmer's review

AI etiquette

Repairing my Windows bootloader after Omarchy

Berkeley Mono Variable (TX-02) in Ghostty

The youngest sibling advantage

Comparing UTOPIA ISPs