<?xml version="1.0" encoding="utf-8" standalone="yes"?><rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom"><channel><title>Developer Productivity on miti99</title><link>https://miti99.com/en/tags/developer-productivity/</link><description>Recent content in Developer Productivity on miti99</description><generator>Hugo</generator><language>en</language><lastBuildDate>Mon, 16 Nov 2026 17:39:19 +0700</lastBuildDate><atom:link href="https://miti99.com/en/tags/developer-productivity/index.xml" rel="self" type="application/rss+xml"/><item><title>My Late-2026 Workspace Setup: DeskMini at Home, code-server in the Cloud</title><link>https://miti99.com/en/post/2026/11/04/</link><pubDate>Wed, 04 Nov 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/11/04/</guid><description>&lt;p&gt;I wanted to be able to open my workspace from any device, let coding agents shoulder more and more of the heavy lifting, and make the most of long-term free tiers. After plenty of rounds of installing, testing, and tearing things down, my late-2026 setup has settled into three parts:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;In the cloud:&lt;/strong&gt; &lt;code&gt;code-server&lt;/code&gt; running inside a container on OCI Always Free ARM, deployed via Coolify from &lt;a href="https://github.com/tiennm99/composes" rel="noopener noreferrer"&gt;tiennm99/composes&lt;/a&gt;.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;At home:&lt;/strong&gt; an ASRock DeskMini X600 running Ubuntu, handling heavy builds, containers, and coding agents for remote access.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;On the go:&lt;/strong&gt; a lightweight ThinkPad acting as a thin client to connect to the other two over SSH, Tailscale, or &lt;code&gt;code-server&lt;/code&gt;.&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;Getting here took plenty of trial and error: switching &lt;code&gt;code-server&lt;/code&gt; images, hunting for a good browser-based terminal, and spending two weeks wrestling with remote Linux desktop solutions. Some things stuck; others now live only in my archive folder.&lt;/p&gt;
&lt;p&gt;This post was drafted with AI assistance from my Git history, plans, and notes, and I then filled in the reasoning behind each decision. I didn&amp;rsquo;t check the DeskMini live while writing; anything unverified or where I no longer remember the exact reason is called out explicitly in the relevant section.&lt;/p&gt;
&lt;h2 id="starting-point-code-server-in-a-container"&gt;Starting Point: &lt;code&gt;code-server&lt;/code&gt; in a Container&lt;/h2&gt;&lt;p&gt;I&amp;rsquo;ve been self-hosting Coolify since at least May 2025. On August 14, 2026, while reorganizing my &lt;code&gt;composes&lt;/code&gt; repo, I added &lt;code&gt;code-server&lt;/code&gt; using the LinuxServer.io image (lsio for short). Go, Node, and Python were installed via &lt;code&gt;DOCKER_MODS&lt;/code&gt;, and extra packages via &lt;code&gt;INSTALL_PACKAGES&lt;/code&gt;. The &lt;code&gt;abc&lt;/code&gt; user&amp;rsquo;s home directory lived at &lt;code&gt;/config&lt;/code&gt;.&lt;/p&gt;
&lt;p&gt;Running that image under Coolify had a few annoyances. Every redeploy recreated the container, re-downloaded the mods, and forced &lt;code&gt;apt&lt;/code&gt; to resolve the entire &lt;code&gt;INSTALL_PACKAGES&lt;/code&gt; list from scratch — enough that I had to trim the package list down. Worse, if a mod failed to install, the error was simply logged and ignored: the editor still opened, just missing tools. Freshly created workspace volumes were also owned by &lt;code&gt;root&lt;/code&gt;, which I had to work around in a Dockerfile.&lt;/p&gt;
&lt;p&gt;Those were the friction points with lsio. The reason I switched to Coder&amp;rsquo;s official image was to stay closer to upstream. I added &lt;code&gt;codercom/code-server&lt;/code&gt; with a custom Dockerfile on October 6, then removed the lsio setup and moved it to the archive on October 12.&lt;/p&gt;
&lt;p&gt;The new Dockerfile bakes in the tools I need right at build time: build-essential, &lt;code&gt;bubblewrap&lt;/code&gt;, networking CLIs, search and linting tools, database clients, plus &lt;code&gt;gh&lt;/code&gt;, Docker CLI, Compose, Buildx, &lt;code&gt;glab&lt;/code&gt;, and &lt;code&gt;gt&lt;/code&gt;. That way, helper commands and shell completions are ready out of the box. I use &lt;code&gt;FROM codercom/code-server:latest&lt;/code&gt; because the official image doesn&amp;rsquo;t publish major-version tags.&lt;/p&gt;
&lt;p&gt;So that &lt;code&gt;agent-browser&lt;/code&gt; can run headlessly on ARM64, the image includes Debian&amp;rsquo;s Chromium package along with the required fonts, and I tuned shared memory so Chromium wouldn&amp;rsquo;t crash. GTK and WebKitGTK are included for headless Tauri builds and tests.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Language toolchains, on the other hand, stay in my home directory outside the image:&lt;/strong&gt; &lt;code&gt;fnm&lt;/code&gt;, &lt;code&gt;uv&lt;/code&gt;, &lt;code&gt;rustup&lt;/code&gt;, Go from the official tarball, and SDKMAN. Baking another copy into the image would only bloat the build while getting shadowed by the versions in &lt;code&gt;$HOME&lt;/code&gt; anyway. Keeping them separate also prevents a container redeploy from silently upgrading the compiler or runtime version I&amp;rsquo;m in the middle of using.&lt;/p&gt;
&lt;p&gt;One remaining annoyance is typing Vietnamese inside the browser terminal when using Claude Code. As of my last notes on October 18, I still haven&amp;rsquo;t found an officially supported fix. Backspace events and diacritic composition have to travel through the entire chain of browser → &lt;code&gt;xterm.js&lt;/code&gt; → WebSocket → PTY. For now, I just type longer Vietnamese text outside and paste it in.&lt;/p&gt;
&lt;h2 id="things-i-evaluated-tried-and-removed-on-the-server"&gt;Things I Evaluated, Tried, and Removed on the Server&lt;/h2&gt;&lt;p&gt;Alongside switching the &lt;code&gt;code-server&lt;/code&gt; image, I looked for ways to use a terminal and coding agents directly in the browser. Between September and early November, several tools came and went on the server:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;OpenHands:&lt;/strong&gt; tried from September 18 to 19 — about a day.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;opencode web:&lt;/strong&gt; tried from September 18 to October 5 for a browser-based shell.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Paseo:&lt;/strong&gt; used from September 16 to November 3 (last tweaked on October 6). This daemon initially seemed like a good fit, but each agent CLI needed around 200 MB installed at startup. I eventually dropped it because Orca and T3 Code offered better features and a smoother experience.&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;For OpenHands and opencode web, I didn&amp;rsquo;t write down why I removed them.&lt;/p&gt;
&lt;p&gt;The Zellij web client was the one I really wanted to make work. I ran it in a container from October 21 to November 3, but immediately ran into keyboard shortcut conflicts: the browser reserves &lt;code&gt;Ctrl+T&lt;/code&gt;, &lt;code&gt;Ctrl+W&lt;/code&gt;, &lt;code&gt;Ctrl+N&lt;/code&gt;, and &lt;code&gt;Ctrl+Tab&lt;/code&gt; — the exact combinations I needed for Zellij&amp;rsquo;s modes. With the Unlock-First layout, &lt;code&gt;Ctrl+G&lt;/code&gt; opened Firefox&amp;rsquo;s find bar instead, so I had to rebind it to &lt;code&gt;Alt+G&lt;/code&gt;. On top of that, opening the root URL always spawned a brand-new session that I couldn&amp;rsquo;t clean up from the UI. Ultimately, the shortcut conflicts were what made me drop it.&lt;/p&gt;
&lt;p&gt;While setting it up, I also used &lt;code&gt;socat&lt;/code&gt; as a relay and ran into a quirk where Zellij exited silently if its config file was missing.&lt;/p&gt;
&lt;p&gt;Typing occasionally felt laggy too, though I never proved Zellij was the culprit. The container itself was barely under any load; an incorrect &lt;code&gt;TERM&lt;/code&gt; variable, Vietnamese IME input through the browser, or network latency could all have played a part. I did fix one specific bug where &lt;code&gt;TERM=unknown&lt;/code&gt; caused Backspace to move the cursor to the right.&lt;/p&gt;
&lt;p&gt;An alternative I evaluated on October 24 was &lt;code&gt;tmux&lt;/code&gt; over &lt;code&gt;ttyd&lt;/code&gt;. Because &lt;code&gt;tmux&lt;/code&gt; uses &lt;code&gt;Ctrl+B&lt;/code&gt; as its prefix, its default bindings clash much less with browser shortcuts than Zellij&amp;rsquo;s modal bindings — though it still has to live within whatever keys the browser allows through.&lt;/p&gt;
&lt;p&gt;I added a &lt;code&gt;ttyd&lt;/code&gt; template to the repo but never actually deployed it. Soon after, Orca and T3 Code covered my needs, so I archived the template too. A bare terminal alone still felt too limiting anyway: having to ask Claude just to inspect a single file felt unnecessarily roundabout.&lt;/p&gt;
&lt;p&gt;On November 3, I moved Paseo, Zellij, and the &lt;code&gt;ttyd&lt;/code&gt; template into the archive in a single commit. The Zellij container was removed; the only browser terminals I still use are Cloudflare&amp;rsquo;s browser SSH to the DeskMini and the integrated terminal inside &lt;code&gt;code-server&lt;/code&gt;.&lt;/p&gt;
&lt;h2 id="the-deskmini-at-home"&gt;The DeskMini at Home&lt;/h2&gt;&lt;p&gt;The machine sitting at home is an ASRock DeskMini X600: X600M-STX motherboard, Ryzen 7 8700G (8 cores, 16 threads, integrated Radeon 780M graphics), and 32 GB of RAM. It has two 500 GB NVMe drives — one for the OS and one for my workspace. As of my October 21 check, it runs Ubuntu 26.04 Desktop with GNOME on Wayland.&lt;/p&gt;
&lt;p&gt;I picked the DeskMini because it&amp;rsquo;s compact yet powerful and has a capable iGPU, making it a great &lt;strong&gt;always-on home Linux box for heavy workloads and remote access&lt;/strong&gt;. My Windows desktop is even more powerful, but I didn&amp;rsquo;t want to run a Windows rig 24/7 for that role. When I&amp;rsquo;m at home, I still sit at my Windows desktop; when I&amp;rsquo;m at the office and need a beefy homelab, I open Orca on the DeskMini over Tailscale.&lt;/p&gt;
&lt;p&gt;That keeps my ThinkPad light and cool: compiling, running containers, language toolchains, and long-running tasks all happen on the DeskMini or the cloud server. The DeskMini doesn&amp;rsquo;t run Coolify — services there use plain Docker Compose and &lt;code&gt;systemd&lt;/code&gt;, with browser access routed through Cloudflare Tunnel and Access.&lt;/p&gt;
&lt;p&gt;I gradually set up its toolchains starting in late October: Node via &lt;code&gt;fnm&lt;/code&gt;, Python via &lt;code&gt;uv&lt;/code&gt;, Go from the official tarball with &lt;code&gt;GOTOOLCHAIN=auto&lt;/code&gt;, Rust via &lt;code&gt;rustup&lt;/code&gt;, and Java 21 via SDKMAN, alongside &lt;code&gt;gcc&lt;/code&gt;, &lt;code&gt;git&lt;/code&gt;, &lt;code&gt;gh&lt;/code&gt;, Docker, &lt;code&gt;glab&lt;/code&gt;, and later &lt;code&gt;gt&lt;/code&gt;. One easy-to-forget gotcha when writing automation scripts: &lt;code&gt;fnm&lt;/code&gt; and SDKMAN are loaded in interactive &lt;code&gt;zsh&lt;/code&gt; startup files, so &lt;code&gt;cron&lt;/code&gt; jobs and &lt;code&gt;systemd&lt;/code&gt; services won&amp;rsquo;t see them automatically.&lt;/p&gt;
&lt;p&gt;Since October 22, the DeskMini has had its own dedicated notes in my workspace repo. At that time, its role was also tied to something I really wanted to get working smoothly: opening a full Linux desktop right inside the browser via Apache Guacamole.&lt;/p&gt;
&lt;h2 id="two-weeks-chasing-a-browser-based-linux-desktop"&gt;Two Weeks Chasing a Browser-Based Linux Desktop&lt;/h2&gt;&lt;p&gt;My goal at the time was very specific: open my Linux desktop from anywhere in a browser without installing any client software on the machine in front of me. That meant routing through Cloudflare Tunnel and Access rather than requiring Tailscale on the client machine.&lt;/p&gt;
&lt;p&gt;Among the options I surveyed on October 19, Guacamole stood out as free, self-hosted, clientless, and capable of speaking RDP to both Linux and Windows. Cloudflare&amp;rsquo;s browser RDP ranked lower in my comparison notes, yet I tried it first anyway. On October 21, GNOME Remote Desktop rejected the connection with:&lt;/p&gt;
&lt;blockquote&gt;
 &lt;p&gt;Client did not advertise support for the Graphics Pipeline, closing connection&lt;/p&gt;

&lt;/blockquote&gt;
&lt;p&gt;GNOME requires the RDP Graphics Pipeline extension, and Cloudflare&amp;rsquo;s IronRDP client didn&amp;rsquo;t advertise support for it at the time, causing GNOME to close the connection immediately. Cloudflare&amp;rsquo;s documentation also listed only Windows targets as supported. So that path was a dead end with GNOME in my test.&lt;/p&gt;
&lt;p&gt;VNC was also in my survey notes, though I never installed it. With GNOME on Ubuntu 26.04 in this configuration, everything runs on Wayland with GNOME Remote Desktop speaking RDP. The VNC options I looked into required either X11 or &lt;code&gt;wlroots&lt;/code&gt;, and older guides referencing a VNC toggle in GNOME Settings no longer matched this release.&lt;/p&gt;
&lt;p&gt;So I moved on to Guacamole, deploying &lt;code&gt;guacamole&lt;/code&gt;, &lt;code&gt;guacd&lt;/code&gt;, and PostgreSQL via Docker on the DeskMini over October 21–22. I pinned version &lt;code&gt;1.6.0&lt;/code&gt; because it was the first release supporting the RDP Graphics Pipeline (and the &lt;code&gt;latest&lt;/code&gt; tag at the time pointed to an &lt;code&gt;amd64&lt;/code&gt;-only development build).&lt;/p&gt;
&lt;p&gt;The desktop connected, but sessions kept dropping mid-use. The drops happened over both QUIC and HTTP/2 tunnels, and &lt;code&gt;cloudflared&lt;/code&gt; logged no errors corresponding to the disconnects — so switching the tunnel transport didn&amp;rsquo;t help. In the logs I captured, &lt;code&gt;guacd&lt;/code&gt; reported &lt;code&gt;User is not responding.&lt;/code&gt; after 15 seconds of silence and closed the RDP connection. Those 15-second timeouts are hardcoded at compile time and cannot be changed via configuration.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;I still haven&amp;rsquo;t pinned down the root cause.&lt;/strong&gt; At first I suspected the browser was throttling timers in background tabs, but sessions dropped even while the tab was focused right in front of me. The most plausible theory at the time was a set of regressions in Guacamole 1.6.0 — specifically &lt;code&gt;GUACAMOLE-2118&lt;/code&gt;, its duplicate reports, and &lt;code&gt;GUACAMOLE-2081&lt;/code&gt;. Those bugs had already been fixed on the &lt;code&gt;1.6.1&lt;/code&gt; branch, which hadn&amp;rsquo;t been released yet when I investigated.&lt;/p&gt;
&lt;p&gt;Even so, I never ran a pure LAN test to rule out the Cloudflare Tunnel completely. There was also one occasion where both SSH and RDP froze simultaneously despite running in separate &lt;code&gt;guacd&lt;/code&gt; processes, which that bug theory doesn&amp;rsquo;t neatly explain either.&lt;/p&gt;
&lt;p&gt;For SSH through Guacamole, disconnects were even more painful: because the shell was tied directly to the browser connection, a single drop could kill a running command and lose unsaved state. That&amp;rsquo;s what pushed me to move terminal workflows out of Guacamole altogether. I had already drafted the Zellij template on October 21 prior to this debugging session, and the Guacamole SSH drops only reinforced how much I needed terminal sessions that outlive a browser tab.&lt;/p&gt;
&lt;p&gt;Initially, I planned to stay on &lt;code&gt;1.6.0&lt;/code&gt; and wait for &lt;code&gt;1.6.1&lt;/code&gt;, falling back to &lt;code&gt;1.5.5&lt;/code&gt; only if the drops became unbearable (downgrading required backing up PostgreSQL and preparing a &lt;code&gt;1.5.5&lt;/code&gt; schema since Guacamole doesn&amp;rsquo;t support reverse migrations).&lt;/p&gt;
&lt;p&gt;By November 3, I stopped using Guacamole and archived its setup because the connection just wasn&amp;rsquo;t reliable enough. Cloudflare&amp;rsquo;s browser-rendered SSH was sufficient for quick terminal access, and whenever I need a full desktop, I use Tailscale with the official Windows RDP app. My original goal was making everything 100% browser-based, but in the end I compromised on using a native RDP client for desktop sessions.&lt;/p&gt;
&lt;h2 id="whats-running-on-the-deskmini-today"&gt;What&amp;rsquo;s Running on the DeskMini Today&lt;/h2&gt;&lt;p&gt;As of the state recorded when writing this post, browser SSH, &lt;code&gt;code-server&lt;/code&gt;, T3 Code, and Orca are all accessible through &lt;strong&gt;Cloudflare Tunnel and Access&lt;/strong&gt;, while Tailscale connects my personal devices directly.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;&lt;code&gt;code-server&lt;/code&gt;&lt;/strong&gt; is installed from the official &lt;code&gt;.deb&lt;/code&gt; package, runs via &lt;code&gt;systemd&lt;/code&gt;, and has been in my machine notes since October 22. Since it can&amp;rsquo;t use official VS Code Settings Sync, I plan to keep its configuration and extension list — Claude Code plus a theme — in my dotfiles and apply them via a manual script. I haven&amp;rsquo;t applied those dotfiles to the DeskMini yet.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Orca and T3 Code&lt;/strong&gt; were recently migrated from desktop GUI launches to &lt;code&gt;systemd&lt;/code&gt; user services. I installed Orca (&lt;code&gt;stablyai/orca&lt;/code&gt;) from its &lt;code&gt;.deb&lt;/code&gt; package on October 27 (I didn&amp;rsquo;t record the exact date I installed T3 Code). According to my notes, the goal of moving them to user services in early November was having them come up automatically on boot without needing to log into the desktop session first. One quirk with Orca: when run with &lt;code&gt;--supervise&lt;/code&gt;, the service waits if another Orca instance is already serving the same profile, so launching the desktop app first can make the background service wait.&lt;/p&gt;
&lt;p&gt;In my November 2 comparison notes, Orca is described as a desktop workspace built around Git worktrees that runs agent CLIs directly inside terminals, whereas T3 Code organizes work around conversation threads, drives agents through adapters, and offers a lightweight web UI. That comparison was based purely on documentation rather than side-by-side testing, and its conclusion was to keep Orca as my primary tool while trying T3 Code for steering agents from a phone or browser. Today, both run as services, and Orca is the app I use the most.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Tailscale and &lt;code&gt;cloudflared&lt;/code&gt;&lt;/strong&gt; split responsibilities cleanly: Cloudflare Tunnel + Access handle remote sign-in and web UIs, while Tailscale handles direct traffic between my own devices. I went with this split because I found it simpler than setting up WARP-to-WARP. For GNOME Remote Desktop, my research notes distinguish between remote login at the GDM login screen and desktop sharing after logging in, though I don&amp;rsquo;t have recorded test results for that part yet.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Gitea and &lt;code&gt;gitea-mirror&lt;/code&gt;&lt;/strong&gt; run from my &lt;code&gt;composes&lt;/code&gt; repo as my local GitHub backup on the DeskMini. I already told the story of AI crawlers discovering my Gitea instance in &lt;a href="https://miti99.com/en/post/2026/10/29/"&gt;the October 29, 2026 post&lt;/a&gt;.&lt;/p&gt;
&lt;p&gt;Setting up the mirror had its own hiccups: Gitea&amp;rsquo;s default timeouts cut off multi-gigabyte clones mid-transfer, and Bun&amp;rsquo;s &lt;code&gt;fetch&lt;/code&gt; aborted connections after five minutes without data, leaving half-imported repos behind. Bumping the timeouts fixed that. Health checks polling the GitHub API without a token also hit anonymous rate limits until I lowered their frequency. And in the CLI tooling, I replaced &lt;code&gt;tea&lt;/code&gt; with &lt;code&gt;gt&lt;/code&gt; after &lt;code&gt;tea&lt;/code&gt; was archived upstream and &lt;code&gt;gt&lt;/code&gt; hit &lt;code&gt;1.0.0&lt;/code&gt;. As for why I moved the backup instance from the cloud server to my home DeskMini, I didn&amp;rsquo;t write the reason down, so I won&amp;rsquo;t attribute it to a specific incident.&lt;/p&gt;
&lt;h2 id="remote-power-on-from-rtc-wake-to-a-smart-plug"&gt;Remote Power-On: From RTC Wake to a Smart Plug&lt;/h2&gt;&lt;p&gt;Originally, waking the machine remotely wasn&amp;rsquo;t even in scope. My research notes mentioned using an ESP32 listening to a Telegram bot to send Wake-on-LAN / power signals, though I never built it.&lt;/p&gt;
&lt;p&gt;Starting October 28, I used RTC wake (&lt;code&gt;rtcwake&lt;/code&gt;) via a &lt;code&gt;systemd&lt;/code&gt; unit to schedule the DeskMini to boot itself up. The catch with RTC wake is that a power outage or hard shutdown can cause the machine to miss setting the next wake alarm.&lt;/p&gt;
&lt;p&gt;On November 3, I removed the OS-level RTC wake schedule and switched toward using a smart plug paired with the BIOS &amp;ldquo;restore on AC power loss&amp;rdquo; setting. I didn&amp;rsquo;t record the exact trigger for dropping RTC wake, but the planned workflow is:&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;Shut the OS down cleanly first — never cut power while the PC is running.&lt;/li&gt;
&lt;li&gt;Turn the smart plug off for about 30 seconds, then turn it back on to trigger boot.&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;&lt;strong&gt;This part isn&amp;rsquo;t finished yet.&lt;/strong&gt; I still need to disable the RTC alarm in the BIOS, set &lt;em&gt;Restore on AC Power Loss&lt;/em&gt; to &lt;em&gt;Power On&lt;/em&gt;, and test the full smart-plug power cycle as well as simulated power outages. So I can&amp;rsquo;t claim remote power-on via smart plug is working in production just yet.&lt;/p&gt;
&lt;h2 id="coolify-and-two-always-free-cloud-servers"&gt;Coolify and Two Always Free Cloud Servers&lt;/h2&gt;&lt;p&gt;On the cloud side, Coolify manages two OCI Always Free ARM servers running Ubuntu 24.04 Minimal, fronted by Traefik v3 and Let&amp;rsquo;s Encrypt. I chose OCI for its generous, non-expiring free tier. Choosing Coolify over Dokploy came down to personal impression — it felt more stable to me in day-to-day use, though I haven&amp;rsquo;t run formal benchmarks comparing the two. In my compose files, I still keep Dokploy-compatible sections ready just in case.&lt;/p&gt;
&lt;p&gt;My shared deployment configs live in the public &lt;code&gt;composes&lt;/code&gt; repo under the Apache 2.0 license. Each service gets its own folder with a &lt;code&gt;compose.yml&lt;/code&gt;, a &lt;code&gt;README.md&lt;/code&gt;, and an &lt;code&gt;.env.example&lt;/code&gt;, wired up to its own Coolify application with path-filtered webhooks so changes to one service don&amp;rsquo;t trigger redeploys of another. Inline comments explain &lt;em&gt;what&lt;/em&gt; the config does, while the &lt;code&gt;README.md&lt;/code&gt; records &lt;em&gt;why&lt;/em&gt; I chose it. Tools I wrote myself keep their &lt;code&gt;compose.yml&lt;/code&gt; inside their own repositories.&lt;/p&gt;
&lt;p&gt;The &lt;code&gt;archive/&lt;/code&gt; directory makes it easy to look back at what I tried and when I retired it. What&amp;rsquo;s occasionally missing is the &lt;em&gt;why&lt;/em&gt; — I didn&amp;rsquo;t always write down the reason I dropped a tool at the moment I removed it.&lt;/p&gt;
&lt;h2 id="keeping-everything-consistent-across-machines"&gt;Keeping Everything Consistent Across Machines&lt;/h2&gt;&lt;p&gt;What keeps both me and my coding agents from getting lost across all these machines is a shared workspace repository checked out everywhere. The repo started on July 25 just to hold a few GitHub audit skills and grew organically from there. By late October, I reorganized per-machine notes so agents only load the context relevant to the host they&amp;rsquo;re running on. Claude Code and Codex share the same rule definitions (though I primarily use Claude Code), and my AgentKit CLI installs the kit into each agent&amp;rsquo;s home directory.&lt;/p&gt;
&lt;p&gt;I split context by how it gets consumed: &lt;strong&gt;rules&lt;/strong&gt; are loaded into every session, &lt;strong&gt;skills&lt;/strong&gt; are read on demand per task, and &lt;strong&gt;memory&lt;/strong&gt; has an always-loaded index pointing to topic files. Hooks block costly mistakes; notes and plans track upcoming work; Git history and docs preserve what already happened. Memory is tracked in Git too. One important lesson I have to keep in mind: only rules are guaranteed to be loaded — if you put a behavioral instruction inside memory, the agent might never read it.&lt;/p&gt;
&lt;p&gt;Dotfiles synchronization, meanwhile, &lt;strong&gt;hasn&amp;rsquo;t been rolled out to any machine yet&lt;/strong&gt;. In my October 29 comparison, I picked &lt;code&gt;chezmoi&lt;/code&gt;: it was the only tool in the group that ships as a single native binary on Windows, supports per-machine templates, prompts once for machine variables, integrates with &lt;code&gt;sops&lt;/code&gt; when applying files, and offers a dry-run diff preview. &lt;code&gt;dotter&lt;/code&gt; came in second, while Ansible required WSL on Windows and felt too heavy compared to managing config files directly.&lt;/p&gt;
&lt;p&gt;My toolchain plan evolved too: on October 30, I dropped &lt;code&gt;mise&lt;/code&gt; from the plan in favor of ecosystem-native managers — &lt;code&gt;rustup&lt;/code&gt;, &lt;code&gt;uv&lt;/code&gt;, &lt;code&gt;fnm&lt;/code&gt;, SDKMAN (or Temurin via &lt;code&gt;winget&lt;/code&gt; on Windows), and the official Go binary with &lt;code&gt;GOTOOLCHAIN=auto&lt;/code&gt;. I didn&amp;rsquo;t log any specific bug with &lt;code&gt;mise&lt;/code&gt; when making that switch.&lt;/p&gt;
&lt;p&gt;For the shell, I plan to switch from &lt;code&gt;oh-my-zsh&lt;/code&gt; + &lt;code&gt;powerlevel10k&lt;/code&gt; to &lt;code&gt;zsh&lt;/code&gt; + &lt;code&gt;zimfw&lt;/code&gt; + Starship. Among the frameworks I compared, &lt;code&gt;zimfw&lt;/code&gt; was the most popular actively maintained option and the fastest in recorded benchmarks, with built-in completions covering nearly everything I need — whereas &lt;code&gt;powerlevel10k&lt;/code&gt;&amp;rsquo;s README explicitly notes that project maintenance is now very limited. That switch is still on the to-do list; the servers are still running &lt;code&gt;oh-my-zsh&lt;/code&gt; for now.&lt;/p&gt;
&lt;h2 id="unfinished-tasks-and-lessons-learned"&gt;Unfinished Tasks and Lessons Learned&lt;/h2&gt;&lt;p&gt;As of November 4, 2026, two items are still unfinished:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;Updating the DeskMini BIOS settings and testing smart-plug power-on, including recovery after a power cut.&lt;/li&gt;
&lt;li&gt;Rolling out the dotfiles repo across my machines.&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;Looking back over all these iterations, a few lessons stand out:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;Record the &lt;em&gt;why&lt;/em&gt;, not just the &lt;em&gt;what&lt;/em&gt;.&lt;/strong&gt; Git history reconstructs &lt;em&gt;what&lt;/em&gt; changed and &lt;em&gt;when&lt;/em&gt;, but it can&amp;rsquo;t tell you your motivation if you didn&amp;rsquo;t write it down. Jotting down the reason at decision time saves you from having to reconstruct it later like I did for this post.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Browser-based remote desktops have to be tested against your exact display stack.&lt;/strong&gt; On my GNOME Wayland setup, the RDP Graphics Pipeline requirement ruled out one browser RDP option right away, and older VNC guides no longer applied.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Terminal sessions should survive closing a browser tab.&lt;/strong&gt; Tying a shell&amp;rsquo;s lifecycle directly to a browser connection means a single hiccup can take down whatever command was running.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Separating language toolchains from the container image keeps version upgrades under your control.&lt;/strong&gt; Redeploying a container shouldn&amp;rsquo;t silently swap out the compiler or runtime version you&amp;rsquo;re actively working with.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Splitting access paths by use case makes daily life much simpler.&lt;/strong&gt; Cloudflare Tunnel + Access handle browser logins and web UIs; Tailscale handles direct device-to-device connections.&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;This setup will surely keep evolving. Right now, I spend most of my time in Orca, keep &lt;code&gt;code-server&lt;/code&gt; around for opening workspaces in a browser, and let the DeskMini and cloud servers do the heavy lifting. Every tool I tried and retired along the way made it much clearer what I actually need next time.&lt;/p&gt;</description></item><item><title>Newsletter #108</title><link>https://miti99.com/en/post/2026/06/04/</link><pubDate>Thu, 04 Jun 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/06/04/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #108.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="coding-is-solved-software-is-not"&gt;&lt;a href="https://arcplane.ai/journal/software-is-not-solved" rel="noopener noreferrer"&gt;Coding is solved? Software is not.&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Opening with Boris Cherny&amp;rsquo;s (creator of Claude Code) remark that coding is &amp;ldquo;basically solved,&amp;rdquo; Arcplane&amp;rsquo;s Gao argues that the statement is true but incomplete. Coding is merely translating instructions into source code, whereas software development is turning ambiguous intent into a reliable system — a process of progressively reducing entropy. The paradox is that fast AI code generation can actually increase entropy: massive test suites that only validate whatever implementation the agent happened to pick, and plausible-sounding plans that leave core product decisions unresolved. Code arrives sooner, but the team doesn&amp;rsquo;t reach confidence any sooner — the bottleneck simply shifts to review, reconstructing the agent&amp;rsquo;s intent, and interpreting noisy verification evidence.&lt;/p&gt;
&lt;p&gt;Drawing on experience running an authentication product managing millions of identities, the author points to four things that need to change. First, context must be curated deliberately, and review feedback must be captured for future runs. Second, specifications must live alongside the work and be updated as new edge cases surface, because an agent will happily build a complete implementation of an ambiguous requirement. Third, verification evidence must be clear enough for a reviewer to see what the agent ran, what failed, and how it fixed it. Fourth, humans need well-placed checkpoints — especially before deployment — because &amp;ldquo;clean code cannot save a bad spec,&amp;rdquo; and review depth should scale with risk.&lt;/p&gt;
&lt;h2 id="ideas"&gt;&lt;a href="https://www.noahzender.com/ideas" rel="noopener noreferrer"&gt;Ideas&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Rather than a single essay, this is Noah Zender&amp;rsquo;s index page collecting nearly 500 mental models, patterns, and frameworks distilled from hundreds of books, podcasts, and videos. The ideas are organized into 11 categories: mental models and decision-making, knowledge and learning, creativity and writing, product and startups, brand and marketing, tech innovation and AI, investing and economics, psychology and self-improvement, work and leadership, philosophy and worldview, plus an uncategorized bucket. Each entry links to a short standalone page, reading more like a personal knowledge base than a linear article.&lt;/p&gt;
&lt;p&gt;A representative example is the &amp;ldquo;Leveraged Expert&amp;rdquo; concept, which argues that &lt;em&gt;when&lt;/em&gt; you specialize matters just as much as &lt;em&gt;what&lt;/em&gt; you specialize in. Every technology adoption curve has an inflection point where growth either crosses into the mainstream or rapidly fizzles out. If you are already an expert in a field right as it hits that inflection point, your leverage compounds automatically as adoption takes off without requiring extra effort on your part. Specializing too early in a field that is still too nascent yields much lower leverage; the sweet spot is the early-adopter phase, where the surface area for luck is highest. For younger developers, it&amp;rsquo;s a useful lens when deciding which technologies to invest in deeply.&lt;/p&gt;
&lt;h2 id="ai-productivity-debate"&gt;&lt;a href="https://newsletter.getdx.com/p/ai-productivity-debate" rel="noopener noreferrer"&gt;AI productivity debate&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This article from DX&amp;rsquo;s Engineering Enablement newsletter recaps the closing panel of the DX Annual conference, featuring engineering leaders and researchers from Etsy, Twilio, GitHub, Google, and DX. Asked whether AI will mean needing fewer engineers, most panelists disagreed: demand for software rises as the cost of building it falls, so total builder headcount won&amp;rsquo;t shrink even if the definition of an engineer evolves. On technical debt, opinions split: Twilio&amp;rsquo;s representative viewed AI as an amplifier (garbage in, garbage out), while Brian Houck warned that organizations are optimizing for PR velocity over simplicity, accumulating &amp;ldquo;comprehension debt&amp;rdquo; as humans understand less and less of a codebase largely written by AI.&lt;/p&gt;
&lt;p&gt;The panelists opposed top-down AI mandates: Twilio simply pre-installed tools and offered basic guidance yet still saw adoption surge, whereas mandates tend to breed superficial compliance. Using AI utilization as an individual performance metric was roundly rejected by engineers. As for bottlenecks, developers spend only about 14% of their time writing code, so the real constraints remain decision-making, prioritization, and product design; code review mostly feels slower because code is being generated faster. Finally, most adoption hurdles are human and cultural: leaders need to give engineers dedicated time to learn, and two-week group learning sprints proved far more effective than isolated solo tinkering.&lt;/p&gt;
&lt;h2 id="maintainability-sensors-for-coding-agents"&gt;&lt;a href="https://martinfowler.com/articles/sensors-for-coding-agents.html" rel="noopener noreferrer"&gt;Maintainability sensors for coding agents&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Birgitta Böckeler (Thoughtworks) shares hands-on experiments with maintainability &amp;ldquo;sensors&amp;rdquo; that help both humans and AI coding agents gauge code quality, building on the concept of &amp;ldquo;harness engineering.&amp;rdquo; Her testbed was a TypeScript, Next.js, and React dashboard rebuilt entirely with AI and given almost no up-front code-quality instructions, designed to see how far an agent could get relying solely on feedback from sensors like the type checker, ESLint, Semgrep, &lt;code&gt;dependency-cruiser&lt;/code&gt;, the test suite, and mutation testing. With ESLint, she enabled rules capping parameter counts, file length, function length, and cyclomatic complexity, rewriting error messages into actionable remediation instructions and allowing the agent to suppress warnings only if it attached an explicit justification for reviewers.&lt;/p&gt;
&lt;p&gt;&lt;code&gt;dependency-cruiser&lt;/code&gt; helped the agent respect layered module boundaries and self-correct violations. Raw coupling metrics, by contrast, proved noisy and poorly interpreted by AI because &amp;ldquo;good&amp;rdquo; versus &amp;ldquo;bad&amp;rdquo; coupling depends heavily on context — whereas an AI modularity review guided by a strong prompt caught valuable issues like duplicated route logic and misplaced responsibilities. For AI-generated tests, high line coverage did not guarantee quality: some files hit 100% statement coverage without a single true unit test, and only mutation testing exposed the missing assertions. Böckeler concludes that computational sensors work best at the file and function level, while cross-module design issues require AI to supply semantic interpretation. Sensors boost confidence in agent output, but they still cannot replace human judgment.&lt;/p&gt;
&lt;hr&gt;
&lt;p&gt;&lt;em&gt;This post was rewritten by Claude Code with Opus 5.5 on 27/09/2026.&lt;/em&gt;&lt;/p&gt;</description></item><item><title>Newsletter #101</title><link>https://miti99.com/en/post/2026/05/04/</link><pubDate>Mon, 04 May 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/05/04/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #101.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="ai-assisted-engineering-q1-2026-impact-report"&gt;&lt;a href="https://newsletter.getdx.com/p/ai-assisted-engineering-q1-2026-impact" rel="noopener noreferrer"&gt;AI-Assisted Engineering: Q1 2026 Impact Report&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;DX&amp;rsquo;s Q1 2026 report aggregates data from more than 400 companies (expanding the dataset by over 40% compared to the previous quarter) to measure AI&amp;rsquo;s impact on software engineering. AI adoption across surveyed companies has reached 93%. Most notably, Engineering Managers who use AI daily are now shipping &lt;strong&gt;4x&lt;/strong&gt; as much code to production as they did six months ago, doubling the 2x figure recorded last quarter — a sign that the &amp;ldquo;player-coach&amp;rdquo; model, where managers both lead teams and write code directly, is becoming widespread. In terms of time saved, Junior developers using AI daily save &lt;strong&gt;4.9 hours per week&lt;/strong&gt;, overtaking Staff+ engineers (4.8 hours) for the first time, who had previously always led the pack.&lt;/p&gt;
&lt;p&gt;The flip side is equally clear: at some organizations, the change failure rate on deployments can rise by up to 50% (roughly a 2-percentage-point swing), prompting the report to stress that automated testing is &amp;ldquo;no longer optional.&amp;rdquo; &amp;ldquo;Shadow AI&amp;rdquo; — developers bypassing corporate guardrails to use unauthorized AI tools — demands clear usage policies. Companies with fewer than 200 developers are realizing gains faster than large enterprises. Finally, DX notes that these figures are averages across the dataset: AI&amp;rsquo;s impact varies widely across organizations, so every team needs to measure both speed and quality for itself rather than simply benchmarking against industry averages.&lt;/p&gt;
&lt;h2 id="my-ai-workflow-without-losing-my-skills"&gt;&lt;a href="https://marcgg.com/blog/2026/04/15/my-current-ai-workflow/" rel="noopener noreferrer"&gt;My AI Workflow (Without Losing My Skills)&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Marc G shares how he leverages AI without losing his programming skills. His concern stems from the &amp;ldquo;automation paradox&amp;rdquo; (he cites an episode of the &lt;em&gt;99% Invisible&lt;/em&gt; podcast on aviation accidents caused by pilots over-relying on autopilot): automation helps us work faster but erodes our skills, making us even more dependent. So he splits his work by category. When planning, he sketches out his own design first before asking Claude, forcing himself to think things through. For personal tools, he &amp;ldquo;vibe codes&amp;rdquo; freely without worrying about quality. For production code, he writes roughly 50% himself, reads every single line generated by AI, and only delegates to Claude Code the parts that are complex yet isolated and well-tested (an &amp;ldquo;Omega Mess,&amp;rdquo; in Sandi Metz&amp;rsquo;s terminology).&lt;/p&gt;
&lt;p&gt;A concrete example is upgrading the voice feature for his boxing training app: he manually fixed older code sections to understand the system, built an MP3 generation tool with ElevenLabs, let Claude finish a large refactoring once the pattern was established, and wrote the UI himself because it was nearly as fast as writing prompts. As a result, a feature that would have taken weeks was completed in days, with the app sitting at 98.84% uptime at the time of writing. The main message: the time saved by AI should be spent thinking more deeply about feature value rather than chasing volume.&lt;/p&gt;
&lt;h2 id="managing-context-in-long-run-agentic-applications"&gt;&lt;a href="https://slack.engineering/managing-context-in-long-run-agentic-applications/" rel="noopener noreferrer"&gt;Managing Context in Long-Run Agentic Applications&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Slack Engineering shares how they manage context for a multi-agent security investigation platform where a single investigation can span hundreds of model calls and generate megabytes of data. The core design principle is &lt;strong&gt;never carrying raw conversation history into subsequent agent calls&lt;/strong&gt;; instead, context is passed exclusively through three continuous summary channels. This approach avoids blowing up the context window, reduces cost and latency, and helps agents respond better to new information because they aren&amp;rsquo;t weighed down by accumulated stale context.&lt;/p&gt;
&lt;p&gt;The first channel is the &lt;strong&gt;Director&amp;rsquo;s Journal&lt;/strong&gt;, a structured working memory that chronologically records decisions, observations, findings, questions, actions, and hypotheses, complete with metadata (phase, round, timestamp) and evidence citations, keeping every agent aligned on the same investigative thread. The second channel is the &lt;strong&gt;Critic&amp;rsquo;s Review&lt;/strong&gt;, which scores the confidence of specialist agents&amp;rsquo; findings across five tiers, from Trustworthy (0.9–1.0) down to Misguided (0.0–0.29). Across 170,000 evaluated findings, 37.7% reached the highest trust tier, while roughly 26% fell into the bottom two tiers (speculative or misguided). The third channel is the &lt;strong&gt;Critic&amp;rsquo;s Timeline&lt;/strong&gt;, which synthesizes the most plausible timeline from the latest review, the previous timeline, and the Director&amp;rsquo;s journal — prioritizing trustworthy evidence, highlighting gaps, and filtering out ungrounded hallucinations.&lt;/p&gt;
&lt;h2 id="how-the-heck-does-shazam-work"&gt;&lt;a href="https://perthirtysix.com/how-the-heck-does-shazam-work" rel="noopener noreferrer"&gt;How The Heck Does Shazam Work?&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This article visually explains how Shazam identifies a song in just a few seconds, even in a noisy room, based on a counterintuitive idea: &lt;strong&gt;throw away almost all the data&lt;/strong&gt;, keeping only what is truly distinctive. A microphone converts sound into a digital waveform, but raw waveforms are terrible for matching because the same song played louder or softer produces a completely different waveform. Instead, the app applies a &lt;strong&gt;Fast Fourier Transform (FFT)&lt;/strong&gt; to short audio slices to separate out frequencies, then stacks those slices into a spectrogram — a chart of time, frequency, and amplitude. From there, only the loudest peaks are kept, forming a sparse &amp;ldquo;constellation map&amp;rdquo;; background noise rarely produces prominent peaks, making this approach highly noise-resistant.&lt;/p&gt;
&lt;p&gt;To create fingerprints, the system pairs up nearby peaks, with each pair generating a compact hash from three values: the two frequencies and the time delta between them. Lookup uses an &lt;strong&gt;inverted index&lt;/strong&gt; — for each hash, asking which songs contain it — rather than scanning sequentially through millions of tracks, returning results almost instantly. The final step is verification: when enough hashes match with consistent time offsets, the song is identified.&lt;/p&gt;
&lt;h2 id="agents-with-taste"&gt;&lt;a href="https://emilkowal.ski/ui/agents-with-taste" rel="noopener noreferrer"&gt;Agents with Taste&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Emil Kowalski observes that coding agents handle logic very well but struggle with UI design decisions, and proposes a fix: package aesthetic taste into skill files that clearly explain &lt;em&gt;why&lt;/em&gt; a design choice works, then feed them to the agent. His argument is that taste isn&amp;rsquo;t magic — &amp;ldquo;almost every decision about taste has a rational explanation if you look closely enough,&amp;rdquo; and once you can articulate the reason, you can write it down as a rule for an agent to follow consistently.&lt;/p&gt;
&lt;p&gt;The examples are concrete: animations should start from &lt;code&gt;scale(0.95)&lt;/code&gt; rather than &lt;code&gt;scale(0)&lt;/code&gt; because it feels more grounded in the physical world, like a partially deflated balloon; easing functions are chosen via a decision tree, such as &lt;code&gt;ease-out&lt;/code&gt; for elements entering the viewport and &lt;code&gt;ease&lt;/code&gt; for hover state changes. For durations, micro-interactions take 100–150ms, standard UI elements 150–250ms, modals 200–300ms, and UI animations in general should stay under 300ms. For typography, cap line length around 65 characters, use tabular numerals for price columns, and reserve underlines strictly for links. When the logic behind design is documented, developers get much more leverage out of agents without sacrificing quality.&lt;/p&gt;
&lt;h2 id="floating-point-from-scratch-hard-mode"&gt;&lt;a href="https://essenceia.github.io/projects/floating_dragon/" rel="noopener noreferrer"&gt;Floating Point from Scratch: Hard Mode&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Julia Desmazes chronicles her journey implementing hardware floating-point arithmetic from scratch — a challenge that had intimidated her for years — for a systolic-array matrix multiplication accelerator. She chose &lt;strong&gt;bfloat16&lt;/strong&gt; (1 sign bit, 8 exponent bits, 7 mantissa bits) because it requires fewer transistors than float16, offers a dynamic range wide enough for error-tolerant AI workloads, and converts easily to float32. To reduce complexity, the design only supports round-toward-zero and omits subnormals, NaNs, and infinities. The adder uses a &lt;strong&gt;dual-path&lt;/strong&gt; architecture: the &amp;ldquo;close path&amp;rdquo; handles subtraction when the exponent difference is less than 2, while the &amp;ldquo;far path&amp;rdquo; handles everything else, avoiding the long critical path of a single-path design; the multiplier uses radix-4 Booth encoding. Both operations complete in a single cycle.&lt;/p&gt;
&lt;p&gt;Verification was done exhaustively across all 2^32 input combinations using Verilator against a C++ reference model via DPI-C; she discovered that the C++ standard library&amp;rsquo;s bfloat16 computes internally in float32 and can differ by up to 1 ULP, requiring carefully defined acceptance criteria. Two designs were taped out on the IHP 130nm process: the full systolic array occupying 126,685 µm², and a standalone pipelined multiplier reaching a design target of &lt;strong&gt;454 MHz&lt;/strong&gt; under nominal conditions. One fun lesson: a leading-zero counter written simply with &lt;code&gt;casez&lt;/code&gt; outperformed a traditional tree-based design, showing just how effectively synthesis tools optimize.&lt;/p&gt;
&lt;h2 id="the-peril-of-laziness-lost"&gt;&lt;a href="https://bcantrill.dtrace.org/2026/04/12/the-peril-of-laziness-lost/" rel="noopener noreferrer"&gt;The Peril of Laziness Lost&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Bryan Cantrill argues that LLMs are eroding one of a great programmer&amp;rsquo;s most important virtues: &lt;strong&gt;laziness&lt;/strong&gt;, as defined by Larry Wall — the drive to build powerful abstractions now in order to save effort later. That kind of laziness requires real intellectual effort and time spent pondering a better solution. Human limits on time and stamina used to act as a &lt;em&gt;natural filter&lt;/em&gt; forcing engineers to simplify systems; LLMs have no such limits and can generate endless code without any pressure toward minimalism, leading to bloated systems instead of elegant ones.&lt;/p&gt;
&lt;p&gt;A prime example is Garry Tan bragging about writing 37,000 lines of code a day with an LLM, whereas all of DTrace — a system that transformed the industry — is only around 60,000 lines. Closer inspection of Tan&amp;rsquo;s output revealed redundant test suites, a &amp;ldquo;Hello World&amp;rdquo; Rails app, a stowaway text editor, and eight copies of a logo, one of which was an empty file. Cantrill calls this performative industriousness, inflated by LLMs and &amp;ldquo;grind&amp;rdquo; culture, producing sheer volume without any thought for the maintainers left holding the bag. His conclusion: use LLMs in service of true laziness — paying down technical debt and raising engineering rigor — rather than replacing human design thinking.&lt;/p&gt;
&lt;h2 id="cleaning-up-merged-git-branches-a-one-liner-from-the-cia"&gt;&lt;a href="https://spencer.wtf/2026/02/20/cleaning-up-merged-git-branches-a-one-liner-from-the-cias-leaked-dev-docs.html" rel="noopener noreferrer"&gt;Cleaning Up Merged Git Branches: A One-Liner from the CIA&amp;rsquo;s Leaked Dev Docs&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Spencer Dixon shares a Git one-liner he found in the Vault7 documents published by WikiLeaks in 2017, which included internal developer onboarding docs for the CIA alongside hacking tools. The command solves a familiar annoyance: after working on a repo for a while, your local machine accumulates dozens of merged branches you no longer use. The original filtered against &lt;code&gt;master&lt;/code&gt;; his updated version for modern repositories compares against &lt;code&gt;origin/main&lt;/code&gt; and excludes both &lt;code&gt;main&lt;/code&gt; and &lt;code&gt;develop&lt;/code&gt;:&lt;/p&gt;
&lt;div class="highlight"&gt;&lt;div class="chroma"&gt;
&lt;table class="lntable"&gt;&lt;tr&gt;&lt;td class="lntd"&gt;
&lt;pre tabindex="0" class="chroma"&gt;&lt;code&gt;&lt;span class="lnt"&gt;1
&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/td&gt;
&lt;td class="lntd"&gt;
&lt;pre tabindex="0" class="chroma"&gt;&lt;code class="language-bash" data-lang="bash"&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt;git branch --merged origin/main &lt;span class="p"&gt;|&lt;/span&gt; grep -vE &lt;span class="s2"&gt;&amp;#34;^\s*(\*|main|develop)&amp;#34;&lt;/span&gt; &lt;span class="p"&gt;|&lt;/span&gt; xargs -n &lt;span class="m"&gt;1&lt;/span&gt; git branch -d
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/td&gt;&lt;/tr&gt;&lt;/table&gt;
&lt;/div&gt;
&lt;/div&gt;&lt;p&gt;The pipeline chains three steps: &lt;code&gt;git branch --merged origin/main&lt;/code&gt; lists merged branches, &lt;code&gt;grep -vE&lt;/code&gt; strips out the current branch and primary branches to prevent accidental deletion, and &lt;code&gt;xargs&lt;/code&gt; deletes each remaining branch using the lowercase &lt;code&gt;-d&lt;/code&gt; flag, which only deletes branches that have already been merged (into their upstream or HEAD), making it quite safe. The author recommends saving it as a shell alias (he named his &lt;code&gt;ciaclean&lt;/code&gt;) so you don&amp;rsquo;t have to remember the syntax, and running it after deployments to keep your branch list trimmed down to just active work and save a few minutes every week.&lt;/p&gt;
&lt;h2 id="agent-harness-engineering"&gt;&lt;a href="https://addyosmani.com/blog/agent-harness-engineering/" rel="noopener noreferrer"&gt;Agent Harness Engineering&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Addy Osmani argues that the quality of a coding agent depends more on its &lt;strong&gt;harness&lt;/strong&gt; — the operational scaffolding around the model — than on the model itself: &amp;ldquo;a mediocre model with a great harness will beat a great model with a bad harness.&amp;rdquo; The gap between what today&amp;rsquo;s models are capable of and what they actually deliver is largely a harness problem. A harness encompasses system prompts and instruction files (&lt;code&gt;AGENTS.md&lt;/code&gt;, skill files), the filesystem and version control for persistent state, sandboxed execution environments, cross-session memory, context management mechanisms like conversation compaction, long-horizon task orchestration through planning and verification loops, and hooks that deterministically enforce rules.&lt;/p&gt;
&lt;p&gt;Key principles include the &amp;ldquo;skill issue&amp;rdquo; mindset: most agent failures stem from poor configuration rather than model capability, which makes the problem tractable. The &lt;strong&gt;Ratchet Principle&lt;/strong&gt; treats every failure as a permanent signal — each mistake gets turned into a configuration rule so the agent never repeats it, and every rule should trace back to a specific incident. Instruction files should stay concise; HumanLayer keeps its &lt;code&gt;AGENTS.md&lt;/code&gt; under 60 lines, like a pilot&amp;rsquo;s pre-flight checklist. Osmani also advises designing backward from desired behavior, ensuring every harness component fills a specific capability gap, and notes that as models get stronger, the harness doesn&amp;rsquo;t disappear — it moves on to tackling harder problems.&lt;/p&gt;
&lt;hr&gt;
&lt;p&gt;&lt;em&gt;This post was rewritten by Claude Code with Opus 5.5 on 27/09/2026; reviewed and edited by Codex with GPT 6.1 Sol on 09/11/2026, and re-verified by Claude Code with Sonnet 5.5 on 16/11/2026.&lt;/em&gt;&lt;/p&gt;</description></item><item><title>Newsletter #94</title><link>https://miti99.com/en/post/2026/04/02/</link><pubDate>Thu, 02 Apr 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/04/02/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #94.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="inside-the-claude-code-source"&gt;&lt;a href="https://gist.github.com/Haseeb-Qureshi/d0dc36844c19d26303ce09b42e7188c1" rel="noopener noreferrer"&gt;Inside the Claude Code source&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;After the Claude Code CLI source code was inadvertently exposed in late March 2026, Haseeb Qureshi read through its core modules and compared its architecture with OpenAI&amp;rsquo;s Codex CLI. The first surprise is that the terminal UI is actually a React application rendered via Ink, bringing a web mental model to the terminal, whereas Codex&amp;rsquo;s TUI is written entirely in Rust. The entire lifecycle of a request runs through an async generator pipeline: every event flows down a single stream consumed identically by the CLI, SDK, and IDE bridge, which differ only in how they render those events. To survive long coding sessions, Claude Code layers four context-compaction strategies (proactive, reactive, snip, and context collapse), whereas Codex relies on two.&lt;/p&gt;
&lt;p&gt;The system prompt is assembled from roughly 15 functions and split in two by a cache-boundary marker: a static first half (~3,000 tokens of core instructions) cached globally across users, and a dynamic second half holding session-specific context like &lt;code&gt;CLAUDE.md&lt;/code&gt; and MCP instructions. Internal Anthropic engineers even receive different prompt rules than external users—such as a strict 25-word limit between tool calls and an adversarial verification sub-agent. Bun&amp;rsquo;s compile-time feature flags strip dead code from public builds while revealing unreleased internal features like &lt;code&gt;VOICE_MODE&lt;/code&gt; and &lt;code&gt;KAIROS&lt;/code&gt;. The author&amp;rsquo;s takeaway: across ~500,000 lines of TypeScript, actual model API calls take up only a few hundred lines; the underlying model is the easiest part to swap out, while the surrounding &lt;em&gt;harness&lt;/em&gt; encodes years of hard-won operational craft.&lt;/p&gt;
&lt;h2 id="ai-will-accelerate-your-tech-debt"&gt;&lt;del&gt;&lt;a href="https://securosis.com/ai/ai-will-accelerate-your-tech-debt/" rel="noopener noreferrer"&gt;AI Will Accelerate Your Tech Debt&lt;/a&gt;&lt;/del&gt;&lt;/h2&gt;&lt;p&gt;Chris Farris compares many engineering organizations to families living paycheck to paycheck: after years of prioritizing feature velocity over sustainable architecture, they are one major outage away from bankruptcy, and every minor incident burns the exact hours that should have gone toward paying down technical debt. Pouring AI coding tools into that environment, he argues, is like passing a tax cut on a structural deficit: it feels great and boosts short-term output, but makes the underlying fiscal problem worse. When the cost of generating code drops near zero, the natural economic friction that used to filter out half-baked features vanishes—leaving the same overstretched team with more code, a wider attack surface, and deeper system complexity.&lt;/p&gt;
&lt;p&gt;On the security side, building on Rich Mogull&amp;rsquo;s &amp;ldquo;Core Collapse&amp;rdquo; scenario, the author warns that AI-equipped attackers will discover and exploit vulnerabilities faster than defenders can patch them, and organizations that don&amp;rsquo;t understand their own environments cannot use AI to defend them either. Unlike Mogull, he argues you cannot outsource technical-debt remediation. Instead, he proposes a &amp;ldquo;Technology Troika&amp;rdquo;—bringing Finance/FinOps, Security, and Platform Engineering together to shore up foundations before opening the AI floodgates. That means investing in unglamorous fundamentals like identity management, data classification, and dependency mapping, alongside having the courage to decommission legacy systems outright rather than endlessly refactoring them. Buying more AI tools won&amp;rsquo;t save a rotting foundation.&lt;/p&gt;
&lt;h2 id="how-slack-rebuilt-notifications-"&gt;&lt;a href="https://slack.engineering/how-slack-rebuilt-notifications/" rel="noopener noreferrer"&gt;How Slack Rebuilt Notifications 📣&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Slack&amp;rsquo;s engineering team recounts rebuilding their notification settings from the ground up to reduce notification fatigue. Notifications consistently ranked among the top three drivers of customer support tickets, and the problem wasn&amp;rsquo;t just volume—it was the architecture itself: desktop and mobile had four conflicting mental models, &lt;em&gt;what&lt;/em&gt; you get notified about was tightly coupled to &lt;em&gt;how&lt;/em&gt; it gets delivered, preferences didn&amp;rsquo;t sync cleanly across devices, and advanced overrides were scattered across hidden menus.&lt;/p&gt;
&lt;p&gt;The redesign consolidated everything into a single unified model: every channel now offers three clear choices—&amp;ldquo;All new posts,&amp;rdquo; &amp;ldquo;Mentions only,&amp;rdquo; or &amp;ldquo;Mute&amp;rdquo;—while push delivery is toggled independently per device category (desktop vs. mobile). The hardest part was migrating millions of existing users safely. To preserve backward compatibility and allow instant rollbacks, the team avoided mutating legacy rows in the database and instead translated old preferences on read—for instance, mapping the old &amp;ldquo;Nothing&amp;rdquo; setting to &amp;ldquo;Mentions only&amp;rdquo; with push notifications turned off. They also removed the explicit &amp;ldquo;Save&amp;rdquo; button so changes apply immediately, shared React components across platforms, and rewrote some of Slack&amp;rsquo;s oldest iOS screens. Post-launch, engagement with notification settings jumped 5x and stayed elevated weeks later.&lt;/p&gt;
&lt;h2 id="better-faster-and-even-more"&gt;&lt;a href="https://randsinrepose.com/archives/better-faster-and-even-more/" rel="noopener noreferrer"&gt;Better, Faster, and (Even) More&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Michael Lopp (Rands) shares the tools and habits he has built over 90 days of working intensively with Claude Code, at a moment when the cost of going from &amp;ldquo;random idea&amp;rdquo; to &amp;ldquo;working software&amp;rdquo; has never been lower. Everything lives under &lt;code&gt;~/Projects/&lt;/code&gt;, with each project in its own Git repository alongside three special repos: &lt;code&gt;dotfiles&lt;/code&gt; for machine configuration symlinked into place, a private &lt;code&gt;credentials&lt;/code&gt; repo for API keys, and &lt;code&gt;scripts&lt;/code&gt; for custom CLI utilities. Every project carries two markdown files: &lt;code&gt;CLAUDE.md&lt;/code&gt; as static instructions on how to build and deploy the project, and &lt;code&gt;WORKLOG.md&lt;/code&gt; as a running session journal recording what was investigated, changed, and decided so the next session can pick right back up.&lt;/p&gt;
&lt;p&gt;Small daily workflow tweaks remove even more friction: having Claude pipe output straight to the macOS clipboard via &lt;code&gt;pbcopy&lt;/code&gt;, capturing a screen region to the clipboard and pasting it directly into Claude instead of describing UI bugs in prose, and running a custom doctor script that verifies 30+ environment checks across his three Macs. He also breaks down how he separates Claude Code&amp;rsquo;s memories, skills, and hooks, configures his status bar to display rate-limit usage, and auto-titles terminal tabs by project name. Going faster, he notes, only makes you want to go faster still—every friction point removed builds momentum for the next.&lt;/p&gt;
&lt;h2 id="java-is-fast-your-code-might-not-be"&gt;&lt;a href="https://jvogel.me/posts/2026/java-is-fast-your-code-might-not-be/" rel="noopener noreferrer"&gt;Java Is Fast. Your Code Might Not Be.&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Jonathan Vogel built a Java order-processing service for a DevNexus talk that worked outer-loop fine and passed every test—then fixed eight common performance anti-patterns without changing the architecture or upgrading the JDK. Processing time dropped from 1,198ms to 239ms, throughput jumped from 85,000 to 419,000 orders per second, and heap usage fell from over 1GB to 139MB. What makes these eight anti-patterns dangerous is that they compile cleanly, slip past code review, and only stand out under a profiler.&lt;/p&gt;
&lt;p&gt;The eight culprits: string concatenation with &lt;code&gt;+&lt;/code&gt; inside loops causing O(n²) copying (use &lt;code&gt;StringBuilder&lt;/code&gt;); running a full &lt;code&gt;Stream&lt;/code&gt; scan over a list inside a loop—the single biggest hotspot, eating nearly 71% of CPU samples, replaced by a single-pass accumulation using &lt;code&gt;Map.merge()&lt;/code&gt;; calling &lt;code&gt;String.format()&lt;/code&gt; on hot paths; autoboxing &lt;code&gt;Long&lt;/code&gt; instead of primitive &lt;code&gt;long&lt;/code&gt;, churning ~16MB of heap garbage per million elements; using exceptions for normal control flow; overly coarse &lt;code&gt;synchronized&lt;/code&gt; blocks (replaced with &lt;code&gt;ConcurrentHashMap&lt;/code&gt; and &lt;code&gt;LongAdder&lt;/code&gt;); repeatedly instantiating expensive thread-safe objects like Jackson&amp;rsquo;s &lt;code&gt;ObjectMapper&lt;/code&gt;; and pinning virtual threads on JDK 21–23 by performing blocking I/O inside &lt;code&gt;synchronized&lt;/code&gt; blocks (fixed with &lt;code&gt;ReentrantLock&lt;/code&gt;). Part two of the series will walk through the exact JFR profiler traces.&lt;/p&gt;
&lt;h2 id="go-naming-conventions-a-practical-guide"&gt;&lt;a href="https://www.alexedwards.net/blog/go-naming-conventions" rel="noopener noreferrer"&gt;Go Naming Conventions: A Practical Guide&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Alex Edwards puts together a comprehensive, practical guide to naming things in Go, starting from the language&amp;rsquo;s three hard rules for identifiers (only Unicode letters, digits, and underscores; cannot start with a digit; cannot match a reserved keyword) and moving into community conventions. Go uses &lt;code&gt;mixedCaps&lt;/code&gt; (&lt;code&gt;camelCase&lt;/code&gt;) for unexported identifiers and &lt;code&gt;ExportedCaps&lt;/code&gt; (&lt;code&gt;PascalCase&lt;/code&gt;) for exported ones, because the case of the first letter determines package visibility; &lt;code&gt;snake_case&lt;/code&gt; is almost never used. Initialisms and acronyms keep consistent casing across the entire word: &lt;code&gt;apiKey&lt;/code&gt; and &lt;code&gt;APIKey&lt;/code&gt; are idiomatic, whereas &lt;code&gt;ApiKey&lt;/code&gt; is not; likewise, write &lt;code&gt;userID&lt;/code&gt;, never &lt;code&gt;userId&lt;/code&gt;.&lt;/p&gt;
&lt;p&gt;For identifier length, the guiding principle is that the farther an identifier is used from its declaration, the more descriptive its name needs to be: a loop index over three lines can be &lt;code&gt;i&lt;/code&gt;, while a package-level variable needs a full, self-explanatory name. He advises against encoding types into variable names, shadowing built-in functions or standard-library package names like &lt;code&gt;json&lt;/code&gt; or &lt;code&gt;log&lt;/code&gt;, and exporting identifiers by default—citing &lt;em&gt;The Pragmatic Programmer&lt;/em&gt; that exporting less makes internal refactoring much easier. Package names should be short, all-lowercase single words without underscores (&lt;code&gt;ordermanager&lt;/code&gt;, not &lt;code&gt;order_manager&lt;/code&gt;), avoiding names with special toolchain meaning like &lt;code&gt;vendor&lt;/code&gt;, &lt;code&gt;testdata&lt;/code&gt;, or &lt;code&gt;internal&lt;/code&gt;.&lt;/p&gt;
&lt;h2 id="sambercc-skills-golang--a-collection-of-golang-agentic-skills-that-works"&gt;&lt;a href="https://github.com/samber/cc-skills-golang" rel="noopener noreferrer"&gt;samber/cc-skills-golang: 🧑‍🎨 A collection of Golang agentic skills that works&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This open-source repository offers a curated collection of Go-specific agent skills compatible with Claude Code, Codex, Cursor, GitHub Copilot, Gemini CLI, and Antigravity. Each skill is a modular instruction pack loaded only when relevant, keeping the coding agent&amp;rsquo;s context window lean. Bootstrapped with Claude Code from the author&amp;rsquo;s own production Go commits and then heavily edited, tested, and rewritten by hand, the project comes with a blunt warning from the author: purely AI-generated skills are useless.&lt;/p&gt;
&lt;p&gt;The catalog spans code style, naming conventions, data structures, database patterns, design patterns, documentation, error handling, observability, performance, benchmarking, security, and testing. Skills are split into small, cross-referenced units—for instance, rules about logging errors live inside &lt;code&gt;golang-error-handling&lt;/code&gt; rather than &lt;code&gt;golang-observability&lt;/code&gt;. Each skill includes benchmarked error-reduction numbers comparing agent output with and without the skill, such as a ~40% reduction in style violations and a 53% improvement in documentation compliance. Skills can be installed via the &lt;code&gt;skills&lt;/code&gt; CLI, the Claude Code plugin marketplace, or by copying them into your tool&amp;rsquo;s skill discovery directory.&lt;/p&gt;
&lt;h2 id="small-programming-tricks"&gt;&lt;a href="https://will-keleher.com/posts/small-programming-tricks-matter/" rel="noopener noreferrer"&gt;Small Programming Tricks&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Will Keleher argues that a surprising share of day-to-day engineering speed comes from accumulating &amp;ldquo;small programming tricks&amp;rdquo;—bite-sized techniques that don&amp;rsquo;t require deep theoretical study, but pay off immediately every day. His favorites include fuzzy-searching shell history with &lt;code&gt;fzf&lt;/code&gt; on &lt;code&gt;Ctrl+R&lt;/code&gt; (or &lt;code&gt;atuin&lt;/code&gt; for even richer history), running &lt;code&gt;SELECT&lt;/code&gt; without a &lt;code&gt;FROM&lt;/code&gt; clause to quickly test database functions, using &lt;code&gt;EXPLAIN ANALYZE&lt;/code&gt; to tune queries, word-boundary assertions (&lt;code&gt;\b&lt;/code&gt;) in regular expressions, the &amp;ldquo;git pickaxe&amp;rdquo; (&lt;code&gt;git log -S&lt;/code&gt;) to find commits that added or removed a specific string, and &lt;code&gt;git checkout -&lt;/code&gt; to jump back to the previous branch or commit checkout.&lt;/p&gt;
&lt;p&gt;He also calls out modern JavaScript conveniences like &lt;code&gt;Array.flatMap&lt;/code&gt;, &lt;code&gt;Object.entries&lt;/code&gt;, and &lt;code&gt;Promise.withResolvers&lt;/code&gt;, and recommends &lt;code&gt;ripgrep&lt;/code&gt; (&lt;code&gt;rg&lt;/code&gt;) over &lt;code&gt;grep&lt;/code&gt; alongside shell globs like &lt;code&gt;**/*.md&lt;/code&gt; in place of verbose &lt;code&gt;find&lt;/code&gt; invocations. Inside a company, tribal-knowledge tricks—like which internal dashboard actually shows the right logs for a given failure, or who on another team knows a legacy subsystem inside out—are even more valuable. At a previous job, the author posted one small trick a day in Slack; that daily cadence was lightweight enough not to overwhelm anyone while steadily leveling up the whole team.&lt;/p&gt;
&lt;h2 id="shell-tricks-that-actually-make-life-easier-and-save-your-sanity"&gt;&lt;a href="https://blog.hofstede.it/shell-tricks-that-actually-make-life-easier-and-save-your-sanity/" rel="noopener noreferrer"&gt;Shell Tricks That Actually Make Life Easier (And Save Your Sanity)&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Christian Hofstede-Kuhn rounds up terminal shortcuts and shell features that many developers miss once they get comfortable with basic &lt;code&gt;ls&lt;/code&gt;, &lt;code&gt;cd&lt;/code&gt;, and &lt;code&gt;grep&lt;/code&gt;. The first half covers Emacs-style line-editing keybindings (depending on your shell configuration): &lt;code&gt;Ctrl+W&lt;/code&gt; deletes the previous word, &lt;code&gt;Ctrl+U&lt;/code&gt; and &lt;code&gt;Ctrl+K&lt;/code&gt; cut to the start or end of the line, &lt;code&gt;Ctrl+Y&lt;/code&gt; yanks the cut text back, and &lt;code&gt;Ctrl+A&lt;/code&gt; / &lt;code&gt;Ctrl+E&lt;/code&gt; jump to the beginning or end of the line; &lt;code&gt;cd -&lt;/code&gt; toggles between your current and previous directory, while &lt;code&gt;pushd&lt;/code&gt; and &lt;code&gt;popd&lt;/code&gt; manage a directory stack. For scripts, &lt;code&gt;set -e&lt;/code&gt; and &lt;code&gt;set -u&lt;/code&gt; help catch errors early (though they have sharp edges and don&amp;rsquo;t replace explicit error handling, and &lt;code&gt;pushd&lt;/code&gt;/&lt;code&gt;popd&lt;/code&gt; aren&amp;rsquo;t part of POSIX &lt;code&gt;sh&lt;/code&gt;).&lt;/p&gt;
&lt;p&gt;The second half focuses on Bash and Zsh power tools: reverse history search with &lt;code&gt;Ctrl+R&lt;/code&gt;, pressing &lt;code&gt;Ctrl+X&lt;/code&gt; then &lt;code&gt;Ctrl+E&lt;/code&gt; to open the current command line in your &lt;code&gt;$EDITOR&lt;/code&gt; when crafting a complex multi-line command, brace expansion like &lt;code&gt;cp file{,.bak}&lt;/code&gt; for quick backups or &lt;code&gt;mkdir -p project/{src,tests,docs}&lt;/code&gt; to scaffold directories in one shot, process substitution like &lt;code&gt;diff &amp;lt;(sort file1) &amp;lt;(sort file2)&lt;/code&gt;, and &lt;code&gt;disown&lt;/code&gt; to detach a long-running job from the current shell session. His advice: don&amp;rsquo;t try to memorize the whole list at once—pick one trick, force yourself to use it for a week, and then move on to the next.&lt;/p&gt;
&lt;hr&gt;
&lt;p&gt;&lt;em&gt;This post was rewritten by Claude Code with Opus 5.5 on 27/09/2026; reviewed and edited by Codex with GPT 6.1 Sol on 09/11/2026, and re-verified by Claude Code with Sonnet 5.5 on 16/11/2026.&lt;/em&gt;&lt;/p&gt;</description></item><item><title>Newsletter #70</title><link>https://miti99.com/en/post/2025/12/13/</link><pubDate>Sat, 13 Dec 2025 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2025/12/13/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #70.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="the-developer-productivity-paradox-why-faster-coding-doesn"&gt;&lt;a href="https://gradle.com/blog/developer-productivity-paradox-faster-coding-slower-delivery/" rel="noopener noreferrer"&gt;The developer productivity paradox: Why faster coding doesn&amp;rsquo;t mean faster software delivery&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Trisha Gee (Gradle) distills a central theme from DPE Summit 2025: the developer productivity paradox. Nearly every developer now uses AI (~90%) and over 80% believe it makes them more productive, yet organizational delivery metrics have barely budged. The 2025 DORA report shows that AI is neither the problem nor the cure—it is a mirror and an amplifier of whatever strengths and weaknesses an engineering organization already has. Because AI models carry an inherent error rate, generating more code faster actually makes systems &lt;em&gt;less&lt;/em&gt; stable unless the surrounding delivery pipeline is solid enough to catch defects. Context-switching costs also eat up the time saved: every interruption takes 15–20 minutes to recover from, and AI introduces new interruptions of its own as developers verify outputs, tweak prompts, or jump between tools to debug subtle mistakes.&lt;/p&gt;
&lt;p&gt;To overcome the paradox, Gee argues for treating AI adoption as an organization-wide transformation grounded in Developer Productivity Engineering (DPE): invest in platform engineering and shared standards, strengthen rollback mechanisms, and tighten CI/CD feedback loops; shrink batch sizes, eliminate toil, and apply value-stream management; measure end-to-end flow and business outcomes rather than lines of code or pull request counts; and train engineers to critically evaluate AI-generated code instead of blindly clicking &amp;ldquo;Accept.&amp;rdquo;&lt;/p&gt;
&lt;h2 id="what-actually-makes-you-senior"&gt;&lt;a href="https://terriblesoftware.org/2025/11/25/what-actually-makes-you-senior/" rel="noopener noreferrer"&gt;What Actually Makes You Senior&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;According to the author, the core skill that separates senior engineers from everyone else isn&amp;rsquo;t technical trivia, but the ability to &lt;strong&gt;reduce ambiguity&lt;/strong&gt;. A mid-level engineer can execute a well-defined spec cleanly, but when handed a vague problem like &amp;ldquo;we need to improve performance&amp;rdquo; or &amp;ldquo;users are complaining about the signup flow,&amp;rdquo; a senior engineer digs in: asking questions nobody else thought to ask, separating signal from noise, and deciding what to tackle now versus what to defer. They ask what the real problem is, who the users are and what frustrates them, which assumptions the plan depends on that might be wrong, and what the blast radius looks like if they ship and those assumptions fail. In doing so, they &lt;strong&gt;de-risk the project&lt;/strong&gt;, turning &amp;ldquo;I have no idea what this even is&amp;rdquo; into &amp;ldquo;two small well-scoped projects and one thing we shouldn&amp;rsquo;t build at all.&amp;rdquo; Done well, this work is nearly invisible—projects simply run smoothly with fewer surprises and fewer outages.&lt;/p&gt;
&lt;p&gt;The author criticizes tech hiring for fixating on keyword checklists, years of experience, and LeetCode puzzles, producing &amp;ldquo;senior&amp;rdquo; engineers who can invert a binary tree on a whiteboard but freeze in front of a half-baked spec. The good news is that reducing ambiguity isn&amp;rsquo;t an innate gift, but a skill built through practice: start with the next vague ticket in your queue and spend time clarifying it upfront instead of waiting to be spoon-fed requirements or jumping straight into code.&lt;/p&gt;
&lt;h2 id="becoming-unblockable"&gt;&lt;a href="https://www.seangoedecke.com/unblockable/" rel="noopener noreferrer"&gt;Becoming unblockable&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Sean Goedecke shares practical tactics for becoming &amp;ldquo;unblockable&amp;rdquo;—always finding a way to keep moving forward when obstacles arise. First, keep more than one task in flight at a time, just like a CPU core switching threads while waiting on I/O; avoid juggling two urgent deadlines at once, and pick low-urgency background work like refactoring, performance tuning, or mandatory training rather than grabbing another feature ticket. Second, front-load the parts of a project most likely to get blocked (such as database migrations that require another team&amp;rsquo;s sign-off) or spark design debates. Be ruthless about your tooling: stick to mainstream development setups, treat a broken local environment with the same urgency as a production outage, and when you&amp;rsquo;re truly stuck locally, find workarounds like running tests in CI or deploying to a staging environment.&lt;/p&gt;
&lt;p&gt;When you hit an error coming from another team&amp;rsquo;s service, don&amp;rsquo;t immediately declare yourself blocked—go read their source code and logs yourself; today you can even point AI agents like Codex or Claude Code at their repo, which Goedecke estimates gives the right answer about a third of the time. Beyond code, build goodwill with engineers on other teams by being helpful so you have fast informal backchannels when you need a favor, and secure &amp;ldquo;air cover&amp;rdquo; from directors or VPs by aligning your projects with top company priorities.&lt;/p&gt;
&lt;h2 id="treat-test-code-like-production-code"&gt;&lt;a href="https://blog.ploeh.dk/2025/12/01/treat-test-code-like-production-code/" rel="noopener noreferrer"&gt;Treat test code like production code&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Mark Seemann argues that test code deserves the same care as production code: the same coding standards, readability, structure, and code-review rigor. In practice, test suites are often treated as second-class citizens—properly indented, yet full of copy-pasted duplication, commented-out &amp;ldquo;zombie&amp;rdquo; tests, and arbitrary &lt;code&gt;sleep&lt;/code&gt; calls in place of proper thread synchronization. Coding standards and design principles don&amp;rsquo;t exist to appease the compiler; they exist so humans—usually your future self—can understand and maintain the system. When a project has strong test coverage, the test suite is huge, making the DRY principle even more important: without it, a minor production API change triggers &amp;ldquo;Shotgun Surgery&amp;rdquo; across dozens of broken tests.&lt;/p&gt;
&lt;p&gt;For test-specific design questions like structure, organization, naming, and determinism, Seemann recommends &lt;em&gt;xUnit Test Patterns&lt;/em&gt; as the definitive reference. He also pushes back against the slogan that tests should be &amp;ldquo;DAMP, not DRY,&amp;rdquo; noting that descriptive, meaningful phrasing is a virtue whether code is duplicated or factored into helpers. There are still sensible exceptions, mostly around security when test code is never deployed: hardcoding dummy test passwords or skipping input validation in test helpers is fine. Platform-specific exceptions make sense too, such as relaxing &lt;code&gt;.NET&lt;/code&gt;&amp;rsquo;s &lt;code&gt;ConfigureAwait&lt;/code&gt; rule in tests or allowing orphan instances in Haskell test suites.&lt;/p&gt;
&lt;h2 id="how-good-engineers-write-bad-code-at-big-companies"&gt;&lt;a href="https://www.seangoedecke.com/bad-code-at-big-companies/" rel="noopener noreferrer"&gt;How good engineers write bad code at big companies&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Sean Goedecke explains why big tech companies can hire armies of talented engineers and still produce terrible code. The core reason is that large companies are &lt;strong&gt;full of engineers working outside their area of expertise&lt;/strong&gt;. With average tenure hovering around one to two years and frequent reorgs shuffling teams, many services are a decade old while most code changes are made by relative newcomers—engineers within their first six months at the company, in that codebase, or in that programming language. The few long-tenured veterans who deeply understand the system can catch issues in code review, but that stewardship role is informal and they are perpetually stretched thin by their own deliverables.&lt;/p&gt;
&lt;p&gt;The typical big-company engineer is therefore a capable developer racing to hit a deadline inside an unfamiliar codebase—doing their best in an environment that isn&amp;rsquo;t set up to produce high-craft code. In Goedecke&amp;rsquo;s view, this is a deliberate executive trade-off: leadership prioritizes organizational flexibility and fungible headcount over deep codebase mastery and code quality, and individual engineers have very little power to change it. He contrasts &amp;ldquo;pure engineering&amp;rdquo; (self-contained domains like compilers, where bad code usually reflects low skill) with &amp;ldquo;impure engineering&amp;rdquo; (more like contract electrical or plumbing work under deadline pressure, where messy code is an inevitable byproduct of the environment). At big companies, bad code happens because almost everyone is perpetually working in unfamiliar territory.&lt;/p&gt;
&lt;h2 id="the-success-trap"&gt;&lt;a href="https://mikefisher.substack.com/p/the-success-trap" rel="noopener noreferrer"&gt;The Success Trap&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Mike Fisher explores how success can quietly narrow your freedom and options. He contrasts a waiter at a neighborhood diner—whose skills are portable enough to switch jobs or careers at any time—with a waiter at a Michelin-starred restaurant, whose mastery is far higher but whose exit options are much narrower without taking a step down. In organizational theory, the &amp;ldquo;success trap&amp;rdquo; describes becoming so good at exploiting your current strengths that you stop exploring new opportunities; it is closely related to Clayton Christensen&amp;rsquo;s &lt;em&gt;Innovator&amp;rsquo;s Dilemma&lt;/em&gt;, except the innovator&amp;rsquo;s dilemma is disruption from the outside, whereas the success trap is rot from within.&lt;/p&gt;
&lt;p&gt;Fisher illustrates this with three examples: an engineer promoted up the management ladder until he no longer built anything himself, who eventually took a pay cut at a startup just to write code again; Kodak inventing the digital camera in 1975 and shelving it to protect its film cash cow; and Radiohead deliberately reinventing their sound with &lt;em&gt;Kid A&lt;/em&gt; right after the massive success of &lt;em&gt;OK Computer&lt;/em&gt;. To escape the trap, organizations need to institutionalize curiosity through dedicated experimentation time, while individuals should regularly put themselves back in the beginner&amp;rsquo;s seat and value learning velocity over comfort. For leaders, it requires a mindset of stewardship—holding success lightly and optimizing for renewal rather than coasting on past wins—because freedom, not achievement, is the true measure of success.&lt;/p&gt;
&lt;h2 id="writing-a-good-claudemd"&gt;&lt;a href="https://www.humanlayer.dev/blog/writing-a-good-claude-md" rel="noopener noreferrer"&gt;Writing a good CLAUDE.md&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This guide from HumanLayer starts from a simple fact: LLMs are stateless. At the beginning of every session, a coding agent knows nothing about your repository, and &lt;code&gt;CLAUDE.md&lt;/code&gt; (or &lt;code&gt;AGENTS.md&lt;/code&gt;) is the one file injected into every conversation by default. Its job is to onboard Claude into the codebase by answering three questions: &lt;strong&gt;WHAT&lt;/strong&gt; (the tech stack and directory structure, especially in monorepos), &lt;strong&gt;WHY&lt;/strong&gt; (the purpose of each component), and &lt;strong&gt;HOW&lt;/strong&gt; (how to work in the repo—running tests, typechecks, and builds). The author notes that Claude frequently ignores &lt;code&gt;CLAUDE.md&lt;/code&gt; because Claude Code wraps it in a system reminder telling the model to ignore instructions that aren&amp;rsquo;t &amp;ldquo;highly relevant to the current task&amp;rdquo;—so the more task-specific clutter you stuff into the file, the more likely Claude is to tune the whole thing out.&lt;/p&gt;
&lt;p&gt;Key recommendations: fewer instructions are better, since frontier reasoning models reliably follow only about 150–200 instructions in total and Claude Code&amp;rsquo;s system prompt already uses ~50 of them; keep &lt;code&gt;CLAUDE.md&lt;/code&gt; under 300 lines and as short as possible (HumanLayer&amp;rsquo;s own root file is under 60 lines), containing only rules that apply to every single task. Use progressive disclosure: put workflow-specific docs in separate Markdown files and link to them from &lt;code&gt;CLAUDE.md&lt;/code&gt;, and reference &lt;code&gt;file:line&lt;/code&gt; pointers instead of pasting code snippets that quickly go stale. Never use an LLM as an expensive linter—use deterministic linters and formatters wired into hooks or slash commands instead. Finally, don&amp;rsquo;t just run &lt;code&gt;/init&lt;/code&gt; and call it a day: &lt;code&gt;CLAUDE.md&lt;/code&gt; is the highest-leverage point of the entire agent harness, so craft every line deliberately.&lt;/p&gt;
&lt;h2 id="we-should-all-be-using-dependency-cooldowns"&gt;&lt;a href="https://blog.yossarian.net/2025/11/21/We-should-all-be-using-dependency-cooldowns" rel="noopener noreferrer"&gt;We should all be using dependency cooldowns&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;William Woodruff argues that dependency cooldowns are a free, low-effort, and remarkably effective defense against the vast majority of open-source supply-chain attacks. Most supply-chain attacks follow the same playbook: an attacker compromises a popular project (usually via phished credentials or a CI/CD vulnerability), publishes a malicious release to PyPI, npm, or GitHub, downstream users automatically pull the update, security researchers spot the anomaly, and the registry yanks the malicious package. While the attacker&amp;rsquo;s preparation may take weeks, the window between publishing the malicious version and the registry taking it down is almost always just a few hours to a few days. Out of ten high-profile incidents analyzed, eight had an active compromise window of under a week—the notable outlier being &lt;code&gt;xz-utils&lt;/code&gt; at roughly five weeks.&lt;/p&gt;
&lt;p&gt;A dependency cooldown simply puts a minimum waiting period between when a package version is published and when your tooling considers it eligible for installation, giving the security community time to catch compromises first. Configuring one takes just a couple of lines—such as &lt;code&gt;cooldown: default-days: 7&lt;/code&gt; in Dependabot, or equivalent settings in Renovate and modern package managers. A 7-day cooldown would have blocked almost every attack on the list, and a 14-day cooldown would have stopped all of them except &lt;code&gt;xz-utils&lt;/code&gt;. While it isn&amp;rsquo;t a silver bullet—since supply-chain security is fundamentally a social-trust problem—eliminating 80–90% of the risk at near-zero cost is a no-brainer.&lt;/p&gt;
&lt;hr&gt;
&lt;p&gt;&lt;em&gt;This post was rewritten by Claude Code with Opus 5.5 on 27/09/2026.&lt;/em&gt;&lt;/p&gt;</description></item><item><title>Newsletter #24</title><link>https://miti99.com/en/post/2025/05/11/</link><pubDate>Sun, 11 May 2025 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2025/05/11/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #24.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="google"&gt;&lt;a href="https://newsletter.getdx.com/p/googles-principles-for-measuring-developer-productivity" rel="noopener noreferrer"&gt;Google&amp;rsquo;s principles for measuring developer productivity&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Abi Noda summarizes the paper &amp;ldquo;Measuring Productivity: All Models Are Wrong, But Some Are Useful&amp;rdquo; by Google researchers Ciera Jaspan and Collin Green. The core idea is that measuring developer productivity is fundamentally an exercise in modeling: every model omits details, so the goal is building a model that remains useful without creating perverse incentives. Drawing on years of internal research at Google, the authors distill five principles. First, avoid single-metric models, because no single metric captures the inherent trade-offs of engineering work. Second, measure all outcomes you care about and use multiple metrics per outcome; when two metrics measuring velocity move in opposite directions, that divergence is an important signal to investigate. Third, think carefully about the incentives your measurements create—when a measure becomes a target, it ceases to be a good measure. Fourth, cover all three dimensions of speed, ease, and quality rather than fixating on just one. Fifth, combine objective system logs with subjective self-reported survey data from engineers.&lt;/p&gt;
&lt;p&gt;The article closes with practical advice. If your team is small enough to fit into a single conference room, you don&amp;rsquo;t need productivity metrics—just sit down and talk to them. Larger organizations should start with developer surveys, which capture the holistic engineering experience far better than raw telemetry alone. Above all, define why you are measuring before choosing any metric.&lt;/p&gt;
&lt;h2 id="in-defense-of-ruthless-managers"&gt;&lt;a href="https://www.seangoedecke.com/ruthless-managers/" rel="noopener noreferrer"&gt;In defense of ruthless managers&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Sean Goedecke divides engineering managers into two archetypes: empathetic managers, who invest emotionally in their reports and regularly go to bat for them against upper management, and &amp;ldquo;ruthless&amp;rdquo; managers, who view their job simply as transmitting the company&amp;rsquo;s needs to engineers and vice versa. While Goedecke agrees that having an empathetic manager is generally great, he argues that ruthless managers are underrated for five reasons. First, they still want their engineers to be happy, because happy engineers perform better, are easier to manage, and don&amp;rsquo;t quit. Second, they accumulate far more political capital with leadership, whereas empathetic managers who constantly push back on executives often burn through their capital right when you need them to advocate for your promotion. Third, they aren&amp;rsquo;t emotionally weighed down by hard decisions, so they stay focused and unbothered. Fourth, they communicate bluntly without sugarcoating bad news or parroting corporate talking points—though they may occasionally lie or withhold information out of self-interest. Finally, they are predictable because they always align with upper management&amp;rsquo;s priorities.&lt;/p&gt;
&lt;p&gt;Goedecke stresses that this defense only applies to competent managers inside reasonably healthy companies. An incompetent, ruthless manager is a recipe for disaster, and given a free choice, most engineers should still pick an empathetic boss. Since we rarely get to choose our managers, though, understanding the strengths of both styles makes it easier to work effectively with whichever one you have.&lt;/p&gt;
&lt;h2 id="ai-ambivalence"&gt;&lt;a href="https://nolanlawson.com/2025/04/02/ai-ambivalence/" rel="noopener noreferrer"&gt;AI ambivalence&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Nolan Lawson holds a master&amp;rsquo;s degree in computational linguistics—having studied alongside the researchers who later coined the term &amp;ldquo;stochastic parrots&amp;rdquo;—but left the field because he grew tired of purely statistical approaches and preferred building software directly. For years he avoided generative AI: he was skeptical of AGI claims and disliked how autocomplete assistants turned programming into endlessly reading code rather than writing it. By 2025, with seemingly the entire industry adopting AI, he tried Claude and Claude Code and admitted they were far more capable than he expected: querying a large codebase, generating unit tests, or refactoring dozens of call sites to a new API pattern worked shockingly fast. The problem is that it drains the joy out of programming. He feels like a babysitter reviewing piles of machine-generated code for subtle bugs, where the strongest temptation is to stop reading altogether and surrender to &amp;ldquo;vibe coding.&amp;rdquo;&lt;/p&gt;
&lt;p&gt;Lawson doesn&amp;rsquo;t offer a neat conclusion, instead capturing a mood of deep ambivalence. He still uses AI for low-stakes tasks like throwaway prototypes and unit tests, but resents how generative AI has taken over software engineering and the underlying message—as Ezra Klein put it—that human creativity is merely derivative. Caught between adapting to the new normal and keeping his manual coding skills sharp for the day &amp;ldquo;vibe-coded&amp;rdquo; systems inevitably catch fire in production, he admits nobody truly knows how this plays out.&lt;/p&gt;
&lt;h2 id="use-abstraction-to-improve-function-readability"&gt;&lt;a href="https://testing.googleblog.com/2023/09/use-abstraction-to-improve-function.html" rel="noopener noreferrer"&gt;Use Abstraction to Improve Function Readability&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This installment of the Google Testing Blog&amp;rsquo;s Code Health series, written by Palak Bansal and Mark Manley, compares two versions of a &lt;code&gt;createPizza&lt;/code&gt; function in Go. The first version crams everything into a single function: preparing the dough and toppings, looping until the oven reaches temperature, baking the pizza, and boxing and slicing it. The second version consists of just three calls—&lt;code&gt;prepare&lt;/code&gt;, &lt;code&gt;bake&lt;/code&gt;, and &lt;code&gt;box&lt;/code&gt;—each of which delegates to lower-level helpers like &lt;code&gt;addToppings&lt;/code&gt; or &lt;code&gt;heatOven&lt;/code&gt; until reaching leaf functions that handle concrete implementation details without calling further helpers. The second version is far easier to read because the first mixes multiple levels of abstraction: low-level mechanics like polling the oven thermometer sit right alongside intermediate steps like baking and high-level intent.&lt;/p&gt;
&lt;p&gt;The takeaway is the Single Level of Abstraction principle: avoid mixing abstraction levels inside the same function, and instead compose functions at matching levels so the code reads top-to-bottom like a story with self-descriptive function names. This structure makes code easier to follow, debug, and reuse; the authors point readers to Robert C. Martin&amp;rsquo;s &lt;em&gt;Clean Code&lt;/em&gt; for a deeper dive.&lt;/p&gt;
&lt;h2 id="how-apple-pay-handles-41-million-transactions-a-day-securely"&gt;&lt;a href="https://newsletter.systemdesign.one/p/how-does-apple-pay-work" rel="noopener noreferrer"&gt;How Apple Pay Handles 41 Million Transactions a Day Securely&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Neo Kim breaks down Apple Pay&amp;rsquo;s architecture through the story of a traveler tapping an iPhone at a London Underground turnstile, noting that the post is based on public research and may differ from Apple&amp;rsquo;s internal implementation. When a user adds a card to Apple Wallet, the card details and device metadata are encrypted and routed through Apple to the payment network (such as Visa or Mastercard); the actual card number is never stored in full on the iPhone or on Apple&amp;rsquo;s servers. Once the payment network verifies the card with the issuing bank, it generates a Device Account Number (DAN)—an irreversible token bound to that specific card and iPhone pair—which is stored inside the iPhone&amp;rsquo;s Secure Element, a dedicated tamper-resistant hardware chip. At checkout, the point-of-sale terminal sends transaction details to the iPhone over NFC; the user authenticates via Touch ID or Face ID, and biometric data stays strictly inside the isolated Secure Enclave processor, never leaving the device.&lt;/p&gt;
&lt;p&gt;Next, the Secure Element combines the DAN with transaction details to compute a dynamic cryptogram—similar to a time-based one-time password—and sends the authorization request through the merchant&amp;rsquo;s acquirer without the merchant ever seeing the real card number. The payment network recomputes the cryptogram against its copy of the DAN to verify the transaction, then returns an approval code and a response cryptogram for the device to verify in turn. Built on the EMV contactless specification, Apple Pay works even when the iPhone has no cellular or Wi-Fi connection and is significantly safer than a physical card because the underlying card number is never exposed.&lt;/p&gt;
&lt;h2 id="four-kinds-of-optimisation"&gt;&lt;a href="https://tratt.net/laurie/blog/2023/four_kinds_of_optimisation.html" rel="noopener noreferrer"&gt;Four Kinds of Optimisation&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Laurence Tratt opens with two observations: programmers are chronically over-optimistic about knowing where their programs spend time, and equally over-optimistic about knowing how to speed up the slow parts. The cure for the first is disciplined profiling; for the second, Tratt outlines four categories of optimization, each with its own trade-offs. First, using a better algorithm requires understanding your data distribution: selection sort is three times faster than bubble sort on random data, but much slower on already-sorted data, and hand-rolled &amp;ldquo;fast&amp;rdquo; algorithms are notorious for subtle bugs. Second, using better data structures—such as a sorted array with binary search for read-heavy static data, or shrinking struct field sizes when allocating millions of instances. Third, moving to a lower-level system: rewriting Python in Rust might yield a 60x speedup, whereas running the exact same code on PyPy instead of CPython can deliver a 4x speedup with almost zero effort. Fourth, accepting a less accurate answer—including heuristic local search that may miss the global optimum, or probabilistic/lossy approaches like Bloom filters, JPEG compression, and machine learning.&lt;/p&gt;
&lt;p&gt;Tratt generally avoids jumping straight to a low-level rewrite because the return on engineering time is often poor, preferring simple wins first. He closes with three guiding rules: always pick the simplest optimization that meets your performance target because it introduces the fewest bugs; remember that human engineering time is expensive; and breadth of optimization knowledge matters more than narrow depth.&lt;/p&gt;
&lt;h2 id="the-fifth-kind-of-optimisation"&gt;&lt;a href="https://tratt.net/laurie/blog/2025/the_fifth_kind_of_optimisation.html" rel="noopener noreferrer"&gt;The Fifth Kind of Optimisation&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;In this follow-up post, Laurence Tratt admits he left out a fifth optimization technique that he relies on constantly: parallelization. When he parallelized his Rust-based static site builder across multiple threads, build times in &amp;ldquo;quick&amp;rdquo; mode dropped from roughly 0.6 seconds to under 0.3 seconds, while full &amp;ldquo;deploy&amp;rdquo; builds ran more than 3x faster. Similarly, his &lt;code&gt;lang_tester&lt;/code&gt; test harness runs test suites in parallel, cutting a test run on a 72-core machine from 37 seconds down to 2.5 seconds—a speedup that directly improves day-to-day developer flow.&lt;/p&gt;
&lt;p&gt;He reflects on why he overlooked parallelization the first time around. First is hardware history: consumer multicore CPUs only became mainstream around 2005, and it took years before x86 and Arm memory models were well-specified enough to program against reliably. Second is language support: Java only got a sound memory model with JSR 133 in 2004, C and C++ waited until 2011, and shared-memory multithreading remained fraught with data races such as lost updates or compilers optimizing away unsynchronized writes. Languages built around immutable data or actor models avoided most of these pitfalls but often paid a performance penalty. For Tratt, Rust changed the equation via the &lt;code&gt;Send&lt;/code&gt; and &lt;code&gt;Sync&lt;/code&gt; traits and ownership rules: he has yet to hit a single data race in Rust, even if occasional &lt;code&gt;clone()&lt;/code&gt; calls or subtle mutex deadlocks still crop up. Today, he designs for parallelism right from the start.&lt;/p&gt;
&lt;h2 id="bonus-interesting-images-from-bytebytego"&gt;Bonus: Interesting images from &lt;a href="https://bytebytego.com/" rel="noopener noreferrer"&gt;ByteByteGo&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/4036e9a7-f2b6-476c-ad5d-48916db3b610_1309x1536.gif" alt="REST API Design Best Practices"&gt;
&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/2a933717-1d59-46a6-ba51-76e24ae048fc_1280x1502.gif" alt="How to Learn Backend Development?"&gt;
&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/b9397d70-0232-4a8b-8b3e-edd4c15eb9bb_800x939.gif" alt="The Simplified Git Workflow"&gt;
&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/1bc9340f-de4f-4767-b2f8-f4c6529e9eea_1309x1536.gif" alt="Virtualization vs Containerization"&gt;
&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/1e7afaab-de4b-4604-a557-22974fb2e3ea_1280x1532.gif" alt="How Netflix Built a Distributed Counter?"&gt;&lt;/p&gt;
&lt;h2 id="bonus-2-interesting-videos-from-bytebytego"&gt;Bonus 2: Interesting videos from &lt;a href="https://bytebytego.com/" rel="noopener noreferrer"&gt;ByteByteGo&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;&lt;a href="https://www.youtube.com/watch?v=_d0duu3dED4" rel="noopener noreferrer"&gt;Why Everyone&amp;rsquo;s Talking About MCP?&lt;/a&gt;&lt;/p&gt;
&lt;hr&gt;
&lt;p&gt;&lt;em&gt;This post was rewritten by Claude Code with Opus 5.5 on 27/09/2026; reviewed and edited by Codex with GPT 6.1 Sol on 09/11/2026, and re-verified by Claude Code with Sonnet 5.5 on 16/11/2026.&lt;/em&gt;&lt;/p&gt;</description></item></channel></rss>