<?xml version="1.0" encoding="utf-8" standalone="yes"?><rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom"><channel><title>Cloudflare on miti99</title><link>https://miti99.com/en/tags/cloudflare/</link><description>Recent content in Cloudflare 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/cloudflare/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>When AI Crawlers Went Strolling Through My Self-Hosted Gitea</title><link>https://miti99.com/en/post/2026/10/29/</link><pubDate>Thu, 29 Oct 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/10/29/</guid><description>&lt;p&gt;I self-host Gitea on an OCI Always Free server to keep mirrors of my GitHub repositories. I always thought of it as a quiet little corner only I ever visited — until I discovered three regular &amp;ldquo;guests&amp;rdquo; dropping by: ClaudeBot, GPTBot, and Reflectionbot. Starting from a few unusual signs in the logs, I tracked down a private repository that had unintentionally been made public, then figured out how to block the crawlers while keeping all my other apps running smoothly. Here is the full story, from discovery to mitigation and follow-up monitoring.&lt;/p&gt;
&lt;h2 id="discovery"&gt;Discovery&lt;/h2&gt;&lt;p&gt;On the morning of October 29, 2026, I noticed that the server running Gitea in Japan was unusually busy. When I opened Traefik&amp;rsquo;s access log, I realized the logs were rotating so fast that the retained portion only covered about 4.5 hours — from 17:55 to 22:22 UTC on October 28. In just that window, there were &lt;strong&gt;86,765 requests&lt;/strong&gt;.&lt;/p&gt;
&lt;table&gt;
 &lt;thead&gt;
 &lt;tr&gt;
 &lt;th&gt;User agent&lt;/th&gt;
 &lt;th&gt;Requests&lt;/th&gt;
 &lt;/tr&gt;
 &lt;/thead&gt;
 &lt;tbody&gt;
 &lt;tr&gt;
 &lt;td&gt;ClaudeBot (Anthropic)&lt;/td&gt;
 &lt;td&gt;39,860&lt;/td&gt;
 &lt;/tr&gt;
 &lt;tr&gt;
 &lt;td&gt;GPTBot (OpenAI)&lt;/td&gt;
 &lt;td&gt;26,901&lt;/td&gt;
 &lt;/tr&gt;
 &lt;tr&gt;
 &lt;td&gt;Reflectionbot (Reflection AI)&lt;/td&gt;
 &lt;td&gt;16,412&lt;/td&gt;
 &lt;/tr&gt;
 &lt;tr&gt;
 &lt;td&gt;Bun (my own &lt;code&gt;gitea-mirror&lt;/code&gt; syncing)&lt;/td&gt;
 &lt;td&gt;3,587&lt;/td&gt;
 &lt;/tr&gt;
 &lt;tr&gt;
 &lt;td&gt;Others (DuckDuckBot, OAI-SearchBot)&lt;/td&gt;
 &lt;td&gt;5&lt;/td&gt;
 &lt;/tr&gt;
 &lt;/tbody&gt;
&lt;/table&gt;
&lt;p&gt;Around 95% of the HTTP 200 responses came from &lt;code&gt;src&lt;/code&gt;, &lt;code&gt;commit&lt;/code&gt;, and &lt;code&gt;raw&lt;/code&gt; pages across 86 mirrored repositories. The crawlers were walking through &lt;strong&gt;every single commit of every single repo&lt;/strong&gt;, and each commit had multiple pages to fetch. Added together, the request volume snowballed fast.&lt;/p&gt;
&lt;p&gt;Looking back at the full month&amp;rsquo;s metrics, traffic was virtually zero until October 10. Starting October 11, it spiked and stayed consistently high:&lt;/p&gt;
&lt;p&gt;&lt;img src="https://miti99.com/post/2026/10/29/requests-by-day.png" alt="Daily request count from September 30 to October 28"&gt;&lt;/p&gt;
&lt;p&gt;In total, that came out to nearly &lt;strong&gt;13.9 million requests&lt;/strong&gt; and &lt;strong&gt;1.48 TB&lt;/strong&gt; of bandwidth — all to serve a Gitea instance meant for an audience of one:&lt;/p&gt;
&lt;p&gt;&lt;img src="https://miti99.com/post/2026/10/29/traffic-overview.png" alt="Traffic overview: requests, unique visitors, bandwidth, error rate, and P95 latency"&gt;&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;If you self-host on a VPS, keep a close eye on bandwidth costs.&lt;/strong&gt; Data downloaded by bots still counts toward your server&amp;rsquo;s outbound transfer quota. Depending on your provider and plan, going over your allowance can mean surprise overage charges or throttled speeds. I got lucky because OCI&amp;rsquo;s outbound bandwidth allowance is very generous, so this incident didn&amp;rsquo;t cost me anything extra. On a VPS with a tighter cap, though, 1.48 TB from crawlers alone could easily turn into an unexpected bill.&lt;/p&gt;
&lt;p&gt;Nearly all of the traffic came from bots, and almost all of it originated in the United States:&lt;/p&gt;
&lt;p&gt;&lt;img src="https://miti99.com/post/2026/10/29/client-types.png" alt="Client type breakdown: almost entirely Bots"&gt;&lt;/p&gt;
&lt;p&gt;&lt;img src="https://miti99.com/post/2026/10/29/traffic-by-country.png" alt="Traffic by country: United States accounts for 13.51 million requests"&gt;&lt;/p&gt;
&lt;p&gt;ClaudeBot alone accounted for 10.82 million requests and 1.4 TB of bandwidth. GPTBot chipped in another 2.52 million requests:&lt;/p&gt;
&lt;p&gt;&lt;img src="https://miti99.com/post/2026/10/29/ai-bots.png" alt="AI agents &amp;amp; bots table: ClaudeBot and GPTBot"&gt;&lt;/p&gt;
&lt;h2 id="figuring-out-the-cause"&gt;Figuring Out the Cause&lt;/h2&gt;&lt;p&gt;My first worry was whether my account had been compromised. Checking the logs, I found:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;Every single request was anonymous — none of them were authenticated.&lt;/li&gt;
&lt;li&gt;No external client sent any POST, PATCH, push, or API requests. All write operations came from the server itself via &lt;code&gt;gitea-mirror&lt;/code&gt; running its sync jobs.&lt;/li&gt;
&lt;li&gt;All three crawlers were legitimate: GPTBot&amp;rsquo;s IPs matched OpenAI&amp;rsquo;s published ranges, ClaudeBot came from Anthropic&amp;rsquo;s IP space, and Reflectionbot&amp;rsquo;s reverse DNS resolved back to &lt;code&gt;reflection.ai&lt;/code&gt;.&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;&lt;img src="https://miti99.com/post/2026/10/29/crawler-verification.png" alt="Verifying the three crawlers: Reflectionbot, GPTBot, and ClaudeBot are all genuine bots"&gt;&lt;/p&gt;
&lt;p&gt;Nothing pointed to an account breach. The bots were simply crawling pages that Gitea left publicly accessible to anonymous visitors: they requested &lt;code&gt;/robots.txt&lt;/code&gt; first, got a 404 because none existed, and proceeded to scrape every page returning HTTP 200. Looking back, I had left the front door wide open without realizing it; the primary issue to fix was my own configuration.&lt;/p&gt;
&lt;p&gt;While auditing further, I uncovered something much more concerning: &lt;strong&gt;one private repository had been exposed&lt;/strong&gt;. The source repo on GitHub was private, but its mirror on Gitea was &lt;strong&gt;public&lt;/strong&gt;, and Reflectionbot had already fetched 48 pages from it. Tracing the sync history led me to a stale record that &lt;code&gt;gitea-mirror&lt;/code&gt; had reused:&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;Originally, that repository name belonged to a public repo. When importing it the first time, &lt;code&gt;gitea-mirror&lt;/code&gt; saved the flag &lt;code&gt;is_private = 0&lt;/code&gt;.&lt;/li&gt;
&lt;li&gt;Later, that public repo was moved to a different namespace.&lt;/li&gt;
&lt;li&gt;I created a new &lt;strong&gt;private&lt;/strong&gt; repository under the old name. The existing record in &lt;code&gt;gitea-mirror&lt;/code&gt; still pointed to that URL and kept the public flag. Because the tool treated it as the same repository, it never re-checked its visibility.&lt;/li&gt;
&lt;li&gt;Gitea kept pulling updates from that URL using my GitHub token. As a result, the contents of the new private repo were synced straight into the public mirror on Gitea.&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;Even setting &lt;code&gt;visibility: &amp;quot;private&amp;quot;&lt;/code&gt; in &lt;code&gt;gitea-mirror&lt;/code&gt; didn&amp;rsquo;t prevent this: that setting only applies to organizations created by the tool, whereas individual repository visibility is still taken from the GitHub private flag captured at the initial import.&lt;/p&gt;
&lt;p&gt;I audited everything and found 105 repositories readable without signing in, all under my personal Gitea account. All other organizations were private. Out of those 105 public mirrors, only the one I had just caught corresponded to a private repo on GitHub.&lt;/p&gt;
&lt;p&gt;Why Cloudflare hadn&amp;rsquo;t blocked the bots was even simpler: every DNS record for my apps was an &lt;code&gt;A&lt;/code&gt; record set to &lt;strong&gt;DNS only&lt;/strong&gt; (grey cloud). Bots were hitting the origin server directly, so their requests never passed through Cloudflare to be filtered in the first place.&lt;/p&gt;
&lt;h2 id="mitigation"&gt;Mitigation&lt;/h2&gt;&lt;p&gt;&lt;strong&gt;Step one was stopping any further data exposure.&lt;/strong&gt; I stopped both Gitea and &lt;code&gt;gitea-mirror&lt;/code&gt;, then switched the exposed repository to private.&lt;/p&gt;
&lt;p&gt;Initially, I considered putting all my applications behind Cloudflare Tunnel and Cloudflare Access. However, that approach would have required quite a bit of rework: changing URLs in Coolify to &lt;code&gt;http://&lt;/code&gt;, reconfiguring each app, and sorting out webhooks. I set that aside for later and chose a less invasive first step: &lt;strong&gt;enabling the Cloudflare proxy (orange cloud)&lt;/strong&gt; on my DNS records. They still point to the same IP, Traefik and Coolify keep working the same way, and Cloudflare sits in the middle to filter out bots.&lt;/p&gt;
&lt;p&gt;On the afternoon of October 29, I rolled out the changes step by step:&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;
&lt;p&gt;&lt;strong&gt;Switched SSL/TLS from Full to Full (strict).&lt;/strong&gt; Traefik continues using its Let&amp;rsquo;s Encrypt certificates and renews them via HTTP-01 even with the proxy enabled. I avoided Flexible mode because Traefik already redirects HTTP to HTTPS; combining the two would cause an infinite redirect loop.&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;&lt;strong&gt;Tested on a low-risk app first&lt;/strong&gt; — a web-based terminal. I verified the &lt;code&gt;server: cloudflare&lt;/code&gt; response header, page loading, and WebSocket connectivity.&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;&lt;strong&gt;Enabled the bot-blocking layers&lt;/strong&gt; available on the Cloudflare Free plan:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;
&lt;p&gt;&lt;strong&gt;AI bot policies&lt;/strong&gt;: set Training, Agent, and Search to Block, since I have no reason for these self-hosted apps to show up in AI search results.&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;&lt;strong&gt;Bot Preference Sync&lt;/strong&gt; (Cloudflare-managed &lt;code&gt;robots.txt&lt;/code&gt;): automatically injects &lt;code&gt;Disallow&lt;/code&gt; rules for AI bots into &lt;code&gt;robots.txt&lt;/code&gt;, or serves one if the app doesn&amp;rsquo;t have its own.&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;&lt;strong&gt;A custom WAF rule&lt;/strong&gt; to catch anything the built-in policies might miss:&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;span class="lnt"&gt;2
&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-text" data-lang="text"&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt;(cf.verified_bot_category in {&amp;#34;AI Crawler&amp;#34; &amp;#34;AI Assistant&amp;#34; &amp;#34;AI Search&amp;#34;})
&lt;/span&gt;&lt;/span&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt;or (http.user_agent contains &amp;#34;Reflectionbot&amp;#34;)
&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;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;&lt;strong&gt;Enabled the proxy on the wildcard record&lt;/strong&gt; &lt;code&gt;*.miti99.dev&lt;/code&gt;. Flipping that single switch covered nearly 20 apps at once, and any new app using the wildcard record will be proxied by default. If I ever need to roll back, I can just toggle the proxy off.&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;&lt;strong&gt;Enabled the proxy on Coolify last&lt;/strong&gt;, then tested GitHub push deployment webhooks, Sentinel metrics coming from my second server, MCP, and real-time WebSocket connections.&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;&lt;strong&gt;Configured Traefik to trust Cloudflare&amp;rsquo;s IP ranges&lt;/strong&gt; via &lt;code&gt;forwardedHeaders.trustedIPs&lt;/code&gt;, so backend applications see the real visitor IP instead of Cloudflare&amp;rsquo;s edge IP.&lt;/p&gt;
&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;I also deliberately &lt;strong&gt;left Bot Fight Mode turned off&lt;/strong&gt;. On the Free plan, its challenge mechanism can block legitimate automated traffic, and WAF rules aren&amp;rsquo;t allowed to bypass it. For my setup, turning it on risked breaking GitHub webhooks, Sentinel, MCP, Nextcloud sync, and even Git operations over HTTP.&lt;/p&gt;
&lt;p&gt;Testing with &lt;code&gt;curl&lt;/code&gt;, requests with a normal browser user agent returned HTTP 200, while requests spoofing GPTBot, ClaudeBot, or Reflectionbot user agents received an immediate HTTP 403 at Cloudflare&amp;rsquo;s edge. Once that was confirmed, I started Gitea back up behind the proxy.&lt;/p&gt;
&lt;p&gt;Even so, routing traffic through Cloudflare comes with a few limitations to keep in mind:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;Request bodies larger than 100 MB are rejected. Nextcloud uses chunked uploads, so it isn&amp;rsquo;t affected by this limit.&lt;/li&gt;
&lt;li&gt;Requests that take longer than ~100 seconds without sending data can hit an HTTP 524 timeout. Long-running LLM calls that don&amp;rsquo;t stream responses are something to watch out for.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;The origin server IP is still reachable directly.&lt;/strong&gt; Any bot that already knows the origin IP can talk straight to Traefik. Proxying filters crawlers that resolve via DNS through Cloudflare, but it doesn&amp;rsquo;t replace proper access control.&lt;/li&gt;
&lt;/ul&gt;
&lt;h2 id="follow-up-monitoring"&gt;Follow-Up Monitoring&lt;/h2&gt;&lt;p&gt;The post-cutover logs illustrated that last point clearly. I enabled the proxy for Gitea at 09:14 UTC (16:14 Vietnam time), then filtered the access log on the origin server to see whether the three bots were still getting through:&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;span class="lnt"&gt;2
&lt;/span&gt;&lt;span class="lnt"&gt;3
&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;&lt;span class="k"&gt;for&lt;/span&gt; ua in GPTBot ClaudeBot Reflectionbot&lt;span class="p"&gt;;&lt;/span&gt; &lt;span class="k"&gt;do&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt; &lt;span class="nb"&gt;echo&lt;/span&gt; &lt;span class="s2"&gt;&amp;#34;&lt;/span&gt;&lt;span class="nv"&gt;$ua&lt;/span&gt;&lt;span class="s2"&gt; &lt;/span&gt;&lt;span class="k"&gt;$(&lt;/span&gt;grep -c &lt;span class="s2"&gt;&amp;#34;&lt;/span&gt;&lt;span class="nv"&gt;$ua&lt;/span&gt;&lt;span class="s2"&gt;&amp;#34;&lt;/span&gt; access.log&lt;span class="k"&gt;)&lt;/span&gt;&lt;span class="s2"&gt;&amp;#34;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class="line"&gt;&lt;span class="cl"&gt;&lt;span class="k"&gt;done&lt;/span&gt;
&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;ul&gt;
&lt;li&gt;&lt;strong&gt;ClaudeBot&lt;/strong&gt; stopped completely at 09:14:20 — almost immediately after the DNS change.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Reflectionbot&lt;/strong&gt; trickled in for about 6 more minutes, likely due to DNS caching.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;GPTBot&lt;/strong&gt; kept sending requests directly to the origin IP — another &lt;strong&gt;7,056 requests over the next hour&lt;/strong&gt; — before finally stopping at 10:14. The &lt;code&gt;ClientAddr&lt;/code&gt; field showed OpenAI&amp;rsquo;s IPs rather than Cloudflare&amp;rsquo;s. My guess is that the bot caches DNS responses longer than the record&amp;rsquo;s TTL.&lt;/li&gt;
&lt;li&gt;From that point until the time of writing — about 4 hours — the origin server recorded &lt;strong&gt;0 requests&lt;/strong&gt; from all three bots.&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;To make sure this setup stays effective, here&amp;rsquo;s what I&amp;rsquo;ll continue monitoring:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;Security → Events&lt;/strong&gt; in Cloudflare: verify that AI bots continue to be blocked and check whether any new user agents need to be added to the WAF rule.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Traefik access logs on the origin server&lt;/strong&gt;: filter using the snippet above. If a crawler reappears with a &lt;code&gt;ClientAddr&lt;/code&gt; outside Cloudflare&amp;rsquo;s IP ranges, it&amp;rsquo;s hitting the origin IP directly. At that point, I&amp;rsquo;ll either lock the firewall down to allow only Cloudflare IPs or revisit the Cloudflare Tunnel approach.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;&lt;code&gt;robots.txt&lt;/code&gt; on each host&lt;/strong&gt;: run &lt;code&gt;curl https://&amp;lt;app&amp;gt;.example.com/robots.txt&lt;/code&gt; to confirm Cloudflare&amp;rsquo;s AI bot &lt;code&gt;Disallow&lt;/code&gt; rules are present.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;New applications&lt;/strong&gt;: Coolify creates new DNS records in DNS-only mode by default. Any host with its own dedicated record needs the proxy toggled on manually; forgetting one leaves a direct path open again.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Cloudflare IP ranges&lt;/strong&gt;: although they rarely change, I still need to keep Traefik&amp;rsquo;s &lt;code&gt;trustedIPs&lt;/code&gt; list updated when they do.&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;I still have a few follow-up tasks left: enabling &lt;code&gt;REQUIRE_SIGNIN_VIEW&lt;/code&gt; so Gitea requires authentication before viewing any page, wiping the existing mirrors, and rotating the GitHub token used by &lt;code&gt;gitea-mirror&lt;/code&gt;. Requiring sign-in is what truly stops outsiders from reading repositories; the Cloudflare proxy is just an extra layer of defense in front. I&amp;rsquo;m also considering sending data deletion requests to Reflection AI, OpenAI, and Anthropic.&lt;/p&gt;
&lt;h2 id="takeaways"&gt;Takeaways&lt;/h2&gt;&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;Anything public on the internet will eventually be scraped thoroughly.&lt;/strong&gt; AI crawlers don&amp;rsquo;t stop at your homepage — they will walk through every single commit.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Double-check visibility settings when syncing across systems.&lt;/strong&gt; A single stale record under a reused repo name was enough to mirror a private GitHub repository into a public Gitea repo.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;If you want Cloudflare to filter traffic, traffic actually has to go through the proxy.&lt;/strong&gt; For my small self-hosted setup, flipping on the proxy was a practical first step before moving to tunnels.&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;Audit your automated integrations before enabling Bot Fight Mode.&lt;/strong&gt; When your server also receives webhooks and serves non-browser clients, bot protection has to account for those workflows too.&lt;/li&gt;
&lt;/ul&gt;</description></item><item><title>Newsletter #133</title><link>https://miti99.com/en/post/2026/10/01/</link><pubDate>Thu, 01 Oct 2026 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2026/10/01/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #133.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="why-go-is-an-ideal-language-for-ai-assisted-software-engineering"&gt;&lt;a href="https://developers.googleblog.com/why-go-is-an-ideal-language-for-ai-assisted-software-engineering/" rel="noopener noreferrer"&gt;Why Go is an Ideal Language for AI-Assisted Software Engineering&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Cameron Balahan and Richard Seroter from Google argue that the bottleneck in software engineering has shifted: when AI can generate hundreds of lines of code in seconds, the hard part is no longer writing code, but reviewing, verifying, and maintaining it. Languages designed from day one for long-term team collaboration have a natural edge, and Go was built at Google for exactly that purpose. Go is a complete platform: its standard toolchain ships with &lt;code&gt;gofmt&lt;/code&gt;, a built-in testing framework, module management, and security tooling, alongside a rich standard library that minimizes third-party dependencies. Because Go favors explicitness over cleverness or terseness—and enforces a single canonical format across human- and LLM-written code alike—spotting hallucinated API calls or subtle logic bugs during code review becomes much easier.&lt;/p&gt;
&lt;p&gt;On the reliability front, static typing and blazing-fast compilation create a tight self-correction feedback loop for coding agents. Go&amp;rsquo;s checksum database guards against tampered dependencies, while &lt;code&gt;govulncheck&lt;/code&gt; alerts only on vulnerabilities in functions your code actually calls. For long-term maintenance, the Go 1 compatibility promise protects source compatibility within its documented scope; static binary compilation simplifies deployment (subject to configuration and C library dependencies), and &lt;code&gt;go fix&lt;/code&gt; lets agents deterministically modernize legacy idioms. While the post makes a conceptual argument rather than presenting empirical benchmarks, its takeaway is clear: AI is a high-velocity teammate that needs sturdy guardrails, and Go provides them out of the box.&lt;/p&gt;
&lt;h2 id="how-does-programming-language-affect-token-efficiency-and-correctness"&gt;&lt;a href="https://danluu.com/pl-tokens/" rel="noopener noreferrer"&gt;How does programming language affect token efficiency and correctness?&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;A popular claim holds that dynamically typed languages are more token-efficient than statically typed ones when working with large language models. Dan Luu puts this claim to the test, starting by auditing two existing benchmarks commonly cited in its favor. The first measures token counts on Rosetta Code tasks, which are too tiny and self-contained to generalize to real software. The second had a path bug that caused Rust and Haskell to fail unfairly alongside a broken test harness that passed regardless of output; once fixed and re-scored, Rust achieved a perfect score. Luu then builds two realistic benchmarks of his own: having agents write a complete &lt;code&gt;zstd&lt;/code&gt; decoder from scratch using only the RFC specification (graded against a hidden test suite), and re-implementing a subset of Pandoc (graded against a held-out test suite).&lt;/p&gt;
&lt;p&gt;The results tell a nuanced story: on &lt;code&gt;zstd&lt;/code&gt; at medium reasoning effort, dynamic languages appear to have a slight edge, but at maximum reasoning effort several statically typed languages take the lead. Clojure failed 36 out of 40 runs at medium effort, largely because its signed &lt;code&gt;byte&lt;/code&gt; coercion throws an exception on values &lt;code&gt;128–255&lt;/code&gt;. Assembly and niche languages performed poorly, while overall language popularity correlated modestly with both higher correctness and lower token cost. Notably, nearly every C and C++ Pandoc implementation contained memory-safety bugs that passed functional tests undetected. While Luu cautions that two benchmarks aren&amp;rsquo;t enough to draw universal laws, the blanket claim that &amp;ldquo;dynamic languages are better for LLMs&amp;rdquo; doesn&amp;rsquo;t hold water; picking a popular mainstream language is a sensible default, and clear specifications help across the board.&lt;/p&gt;
&lt;h2 id="my-agentic-coding-setup-july-2026"&gt;&lt;a href="https://domenic.me/agentic-coding-setup/" rel="noopener noreferrer"&gt;My Agentic Coding Setup, July 2026&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Domenic Denicola shares the agentic coding setup he converged on after months of experimentation—one that lets him steer frontier models to fix bugs on real projects straight from his phone while riding the train. His requirements are concrete: agents must run on Linux because they are far more fluent in Bash than PowerShell; sessions must roam seamlessly between his desktop, laptop, and phone without losing state; multiple agents must work in parallel on the same repository; and interactive permission prompts must be nearly eliminated. The foundation is a &amp;ldquo;semi-disposable&amp;rdquo; Ubuntu VM running on an always-on desktop, connected to all his devices over a private Tailscale tailnet for SSH and HTTPS access from anywhere. Inside the VM, he runs Claude Code and Codex CLI in full-auto (&lt;code&gt;--dangerously-skip-permissions&lt;/code&gt; / &lt;code&gt;--yolo&lt;/code&gt;) mode with &lt;code&gt;gh&lt;/code&gt; pre-authenticated so agents can manage repos, PRs, and CI autonomously. He readily admits this setup isn&amp;rsquo;t hardened against a determined prompt-injection attack, relying primarily on pushing commits to GitHub early and often as his safety net.&lt;/p&gt;
&lt;p&gt;The remaining pieces solve each workflow friction point: &lt;code&gt;git worktree&lt;/code&gt; lets multiple agents work on the same repo in parallel (he prefers Codex/ChatGPT&amp;rsquo;s worktree layout because Claude nests worktrees inside the project directory), VS Code Remote-SSH handles deeper code review, a tool called Portless wrapped over Tailscale gives every dev server its own private HTTPS URL accessible only on his tailnet, and &lt;code&gt;chezmoi&lt;/code&gt; syncs his &lt;code&gt;AGENTS.md&lt;/code&gt;, skills, and dotfiles across machines. Remaining rough edges include adopting devcontainers for tighter isolation, session histories being tightly coupled to directory paths, and the lack of automated durable backups for agent transcripts.&lt;/p&gt;
&lt;h2 id="the-bedrock-of-software-design"&gt;&lt;a href="https://alex.draftist.io/blog/the-bedrock-of-software-design-ycqvcedsj" rel="noopener noreferrer"&gt;The Bedrock of Software Design&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Alex Fedoseev argues that algebraic data types (ADTs) have shaped how he designs software more than any other concept—and that they are far simpler than their academic name suggests. &lt;em&gt;Product types&lt;/em&gt; combine multiple fields into a single value, like a struct with an &lt;code&gt;id&lt;/code&gt; and a &lt;code&gt;role&lt;/code&gt;; &lt;em&gt;sum types&lt;/em&gt; (tagged unions) express that a value is one of several mutually exclusive variants, each carrying its own specific data—for example, a session that is either &lt;code&gt;Anonymous&lt;/code&gt; or &lt;code&gt;Authenticated(User)&lt;/code&gt;. When business rules live scattered across comments and runtime validation helpers, they are easy to forget. Instead of modeling a UI component with a boolean flag plus several nullable fields that are only valid in certain combinations, you model it as a sum type with &lt;code&gt;Switchable&lt;/code&gt; and &lt;code&gt;Fixed&lt;/code&gt; variants, each holding only the fields that actually apply, making illegal states unrepresentable.&lt;/p&gt;
&lt;p&gt;The same thinking applies to errors and the absence of values. With unchecked exceptions, a function&amp;rsquo;s type signature shows only the happy path; in Rust or OCaml, expected failures are returned explicitly via &lt;code&gt;Result&lt;/code&gt;, whose error type can itself be a domain-specific sum type carrying rich context. &lt;code&gt;Option&amp;lt;T&amp;gt;&lt;/code&gt; replaces &lt;code&gt;null&lt;/code&gt;, and a signature like &lt;code&gt;Result&amp;lt;Option&amp;lt;User&amp;gt;, FindUserError&amp;gt;&lt;/code&gt; cleanly distinguishes three outcomes: found, not found, and lookup failed. Exhaustive &lt;code&gt;match&lt;/code&gt; expressions force callers to handle every variant, so when a new &lt;code&gt;Staff&lt;/code&gt; role is added, the compiler points to every single place in the codebase that needs a decision. Fedoseev&amp;rsquo;s conclusion: sum types and exhaustive pattern matching should be table stakes for any modern programming language.&lt;/p&gt;
&lt;h2 id="90--of-the-t-distribution"&gt;&lt;a href="https://entropicthoughts.com/ninety-percent-of-the-t-distribution" rel="noopener noreferrer"&gt;90 % of the t distribution&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;This post reminds readers that small sample sizes make uncertainty estimation harder and introduces Student&amp;rsquo;s t-distribution as a practical tool. However, the formula in the original post conflates a prediction interval (or standard-deviation band) with a confidence interval for the mean. For independent observations drawn from a normal distribution with unknown variance, a two-sided 90% confidence interval for the population mean is $\bar{x} \pm t_{0.95,, n-1} \times \frac{s}{\sqrt{n}}$, where $s$ is the sample standard deviation—dividing by $\sqrt{n}$ to get the standard error of the mean cannot be omitted.&lt;/p&gt;
&lt;p&gt;With $n = 7$ observations, a sample mean of 32 minutes, and $s = 8$ minutes, the critical value $t_{0.95,, 6} \approx 1.943$ yields a 90% confidence interval for the mean of $32 \pm 5.88$ minutes. The rounded multiplier table in the article illustrates how t-multipliers widen relative to a normal distribution at small $n$, but you still have to pick the right interval formula (confidence interval for the mean vs. prediction interval for the next observation) for the question you&amp;rsquo;re asking. And with just $n = 2$ observations, sample variance is too noisy to draw firm conclusions about whether a third measurement is an outlier.&lt;/p&gt;
&lt;h2 id="your-agent-needs-a-computer-not-a-container--introducing-cloudflarecomputer"&gt;&lt;a href="https://blog.cloudflare.com/cloudflare-computer/" rel="noopener noreferrer"&gt;Your agent needs a computer, not a container — introducing @cloudflare/computer&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Cloudflare has released a preview of &lt;code&gt;@cloudflare/computer&lt;/code&gt;, an open-source, npm-installable agent runtime that gives every AI agent its own virtual &amp;ldquo;computer&amp;rdquo; complete with a filesystem, shell, tools, and code execution. The core thesis is that spinning up a dedicated Linux container per agent will never scale economically when hundreds of millions or billions of agents run concurrently. Lightweight V8 isolates are a much better default: they spin up and tear down in milliseconds, hibernate for free when idle, persist state automatically, and scale horizontally—reserving full Linux containers only for the subset of tasks that genuinely need a complete OS environment. Cloudflare&amp;rsquo;s target is for containers to handle less than 10% of an agent&amp;rsquo;s workload.&lt;/p&gt;
&lt;p&gt;Architecturally, the runtime decouples the agent&amp;rsquo;s &amp;ldquo;brain&amp;rdquo; from its &amp;ldquo;hands&amp;rdquo;: the agent loop lives inside a Durable Object, while a container can be attached on demand and invoked like a tool. The workspace is a virtual filesystem backed by SQLite, seeded from cloud object storage or a Git repo, exposing read, write, edit, list, and exec operations alongside a &lt;code&gt;node:fs&lt;/code&gt;-compatible wrapper. Two execution backends sit behind a unified &lt;code&gt;exec&lt;/code&gt; interface: the isolate backend uses &lt;code&gt;just-bash&lt;/code&gt; to interpret shell commands in pure JavaScript, while the container backend mounts the workspace via FUSE to sync file changes seamlessly. Every file operation is audited and logged, and the LLM itself chooses whether a command needs the full container or can run in the fast isolate—a routing decision frontier models handle surprisingly well.&lt;/p&gt;
&lt;h2 id="notes-on-incidents"&gt;&lt;a href="https://www.seangoedecke.com/notes-on-incidents/" rel="noopener noreferrer"&gt;Notes on incidents&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Sean Goedecke shares candid lessons from years of on-call incident response. First, most incidents are surprisingly boring and consist mostly of waiting: waiting on another team, waiting on a deploy pipeline, or waiting for someone to wake up to a page. In his experience, a huge share of incidents self-heal automatically as Kubernetes restarts crashed pods or queues drain a transient traffic spike—he estimates that over half the incident calls he has joined would have resolved in roughly the same time even if nobody had touched a thing. Conversely, frantic &amp;ldquo;firefighting&amp;rdquo; often makes things much worse: purging a backed-up production queue to fix latency can accidentally wipe out unbilled usage records, turning a brief latency blip into a major billing incident. Consequently, the best first move on joining an incident call is often to do nothing at all—go make a cup of tea or take a five-minute walk while gathering facts.&lt;/p&gt;
&lt;p&gt;When intervention &lt;em&gt;is&lt;/em&gt; needed, effective fixes are almost always dead simple, like flipping a feature flag off or reverting a recent deploy. The single biggest asset during an outage is deep system familiarity: an engineer who knows the codebase inside out will spot the culprit flag or commit in minutes. That engineer also needs the decisiveness to state clearly on the call what they plan to do, pause briefly for objections, and execute. While visible incident heroics can win praise from leadership, Goedecke warns against relying on firefighting for career capital, since executives rarely distinguish genuine heroics from obvious one-line reverts—and the best incident is still the one that never happens.&lt;/p&gt;
&lt;h2 id="beyond-clean-code-why-your-comments-matter"&gt;&lt;a href="https://blog.moertel.com/posts/2026-07-27-beyond-clean-code-why-your-comments-matter.html" rel="noopener noreferrer"&gt;Beyond “Clean Code”: Why Your Comments Matter&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Tom Moertel argues that good comments are an indispensable part of well-engineered code. Code logic can only express &lt;em&gt;what&lt;/em&gt; the machine is instructed to do, whereas human readers also need to know &lt;em&gt;what the author intended&lt;/em&gt; and &lt;em&gt;why&lt;/em&gt; the code was written that way—information that is often best communicated in plain prose. You should make code self-explanatory where it comes naturally, but you shouldn&amp;rsquo;t contort control flow or invent awkwardly long identifier names just to avoid writing a comment. While Moertel agrees with Robert C. Martin&amp;rsquo;s &lt;em&gt;Clean Code&lt;/em&gt; that comments shouldn&amp;rsquo;t be used as deodorant for needlessly tangled code, he argues that the dogma &amp;ldquo;every comment is a failure&amp;rdquo; goes way too far. Crucial &amp;ldquo;why&amp;rdquo; context—like a global lock acquisition ordering to prevent deadlocks, an array length invariant, or why a brute-force search is safe because the input is guaranteed to have at most five elements—cannot be deduced from local syntax alone.&lt;/p&gt;
&lt;p&gt;Moertel offers a simple litmus test: squint at the code and ignore all the identifier names; if the structural shape looks more convoluted than the underlying algorithm requires, you may be bending the code into pretzels to avoid writing a comment. He also dismantled common anti-comment tropes. &lt;em&gt;&amp;ldquo;Comments lie&amp;rdquo;&lt;/em&gt;: without a comment stating the intent, buggy code leaves zero clue that it&amp;rsquo;s doing the wrong thing, whereas a contradiction between a comment and the code is a valuable signal to investigate. &lt;em&gt;&amp;ldquo;Comments rot&amp;rdquo;&lt;/em&gt;: stale comments are a code-review culture problem, solved by reviewing comments with the same rigor as code rather than banning comments altogether.&lt;/p&gt;
&lt;h2 id="relying-on-go"&gt;&lt;a href="https://antonz.org/relying-on-go/" rel="noopener noreferrer"&gt;Relying on Go&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Many new programming languages pitch themselves as &amp;ldquo;like Go, but with more features&amp;rdquo; or &amp;ldquo;like Rust, but simpler.&amp;rdquo; Anton Zhiyanov takes the opposite path with Solod, a &amp;ldquo;systems language for C and Go programmers&amp;rdquo;: instead of forking Go or inventing Go-like syntax, Solod is a strict subset of valid Go. Because every Solod program is syntactically valid Go, it inherits the entire Go ecosystem for free on day one: syntax highlighting, &lt;code&gt;gopls&lt;/code&gt; autocomplete, linters, formatters, and &lt;code&gt;go.mod&lt;/code&gt; package management. The developer workflow is identical to Go: install the &lt;code&gt;so&lt;/code&gt; CLI tool, initialize a Go module, import Solod&amp;rsquo;s standard library package, and write normal Go code; &lt;code&gt;so run .&lt;/code&gt; compiles and runs the binary just like &lt;code&gt;go run&lt;/code&gt;. Even Solod&amp;rsquo;s standard library reuses large swaths of Go&amp;rsquo;s standard library code and test suites, adapted for manual memory management.&lt;/p&gt;
&lt;p&gt;Zhiyanov is upfront about the trade-offs: standard Go tooling doesn&amp;rsquo;t know about Solod&amp;rsquo;s subset restrictions, so &lt;code&gt;gopls&lt;/code&gt; won&amp;rsquo;t warn you if you use unsupported Go features like closures or iterators—catching those is up to the &lt;code&gt;so&lt;/code&gt; compiler. Nor is ported Go code automatically memory-safe in Solod without its own tests. Under the hood, &lt;code&gt;so&lt;/code&gt; transpiles Go syntax into readable C11 and compiles it via GCC or Clang, benefiting from decades of C compiler optimizations; because there is no Go runtime or garbage collector, C interop has zero FFI overhead. His broader message: a new language doesn&amp;rsquo;t have to bootstrap a brand-new tooling ecosystem from scratch—leaning on Go is Solod&amp;rsquo;s greatest strength.&lt;/p&gt;
&lt;hr&gt;
&lt;p&gt;&lt;em&gt;This post was reviewed and updated 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 #29</title><link>https://miti99.com/en/post/2025/05/16/</link><pubDate>Fri, 16 May 2025 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2025/05/16/</guid><description>&lt;p&gt;&lt;em&gt;Welcome to Newsletter #29 - Today&amp;rsquo;s tech news roundup.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="a-clean-approach-to-process-optimization"&gt;&lt;a href="https://queue.acm.org/detail.cfm?id=3722546" rel="noopener noreferrer"&gt;A Clean Approach to Process Optimization&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Thomas A. Limoncelli opens with an everyday example: how he reorganized doing the dishes at home. Instead of waiting until the start of a wash cycle to add detergent to the dishwasher, he does it right after unloading the clean dishes. Simply reordering the steps made the chore smoother without any extra effort. He then applied this exact mindset to customer onboarding at his company, cutting wait times from several days down to just a few minutes.&lt;/p&gt;
&lt;p&gt;The core idea is to split a process into two phases. The slow phase covers generic tasks that can be done in advance before an order arrives; the fast phase handles only the specific customization after the order comes in. Alongside this, review optional tasks, since they are often unnecessary or can be done more efficiently. For junior developers, this is a practical lesson: the same approach applies to software deployment pipelines, infrastructure provisioning, and many other areas, improving both performance and service quality.&lt;/p&gt;
&lt;hr&gt;
&lt;h2 id="microsoft"&gt;&lt;a href="https://www.gatesnotes.com/microsoft-original-source-code" rel="noopener noreferrer"&gt;Microsoft&amp;rsquo;s Original Source Code Released for 50th Anniversary&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;To mark Microsoft&amp;rsquo;s 50th anniversary, Bill Gates released the original source code for Altair BASIC, the company&amp;rsquo;s first product, calling it the &amp;ldquo;coolest&amp;rdquo; code he has ever written. The story began with the January 1975 cover of Popular Electronics featuring the Altair 8800 computer from MITS. Gates and Paul Allen contacted founder Ed Roberts and told him they already had a version of BASIC for the Altair&amp;rsquo;s chip, even though they hadn&amp;rsquo;t written a single line yet. The pair chose to build an interpreter rather than a compiler because running code line by line gave beginners immediate feedback and made debugging easier.&lt;/p&gt;
&lt;p&gt;Since they didn&amp;rsquo;t have an Intel 8080 chip, Allen wrote a simulator for it on Harvard&amp;rsquo;s PDP-10 mainframe, Gates wrote the core interpreter, and Monte Davidoff handled the math package. After about two months of working day and night, they squeezed the entire interpreter into just 4 KB of memory using compact data structures and efficient algorithms, because memory at the time cost more than the computer itself. The demo succeeded, MITS licensed the software, and Micro-Soft was born. For developers today, it is a vivid example of optimizing under extreme hardware constraints; Gates tells the fuller story in his memoir &amp;ldquo;Source Code.&amp;rdquo;&lt;/p&gt;
&lt;hr&gt;
&lt;h2 id="no-code-is-dead-long-live-vibe-coding"&gt;&lt;a href="https://kenneth.io/post/no-code-is-dead-long-live-vibe-coding" rel="noopener noreferrer"&gt;No code is dead. Long live vibe coding&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Kenneth Auchenberg makes a blunt call: in 2025, no-code is dead. For a decade, no-code and low-code platforms promised to democratize software creation, yet none truly broke through or replaced traditional programming. Instead, a new generation of tools powered by AI and large language models is emerging, known as &amp;ldquo;vibe coding.&amp;rdquo; Tools like Bolt, Lovable, and v0 show that generating real, production-grade code from natural-language descriptions is not only viable, but better than drag-and-drop WYSIWYG editors.&lt;/p&gt;
&lt;p&gt;According to the author, users turned out not to want &amp;ldquo;less code&amp;rdquo;—they wanted a better way to write code. They don&amp;rsquo;t want to be locked into proprietary runtimes; they want real source code, full control, and the freedom to edit and deploy anywhere. The previous generation, such as Webflow and Retool, bundled the editor, hosting, runtime, and UI components into a closed system. Now, large language models can generate clean React code that follows open standards and industry best practices, ready to deploy onto open infrastructure. The author calls this the &amp;ldquo;unbundling&amp;rdquo; of no-code.&lt;/p&gt;
&lt;hr&gt;
&lt;h2 id="simple-scalable-and-global-containers-are-coming-to-cloudflare-workers-in-june-2025"&gt;&lt;a href="https://blog.cloudflare.com/cloudflare-containers-coming-2025/" rel="noopener noreferrer"&gt;Simple, scalable, and global: Containers are coming to Cloudflare Workers in June 2025&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Cloudflare announced that Containers will enter open beta in late June 2025. Workers are already the simplest way to deploy software globally, but there are workloads they cannot handle: running user-generated code in arbitrary languages, executing CLI tools that require a full Linux environment, using multiple gigabytes of memory or multiple CPU cores, or lifting and shifting applications from AWS, GCP, or Azure without a rewrite. Containers fill that gap. With just a few lines of Wrangler configuration and &lt;code&gt;wrangler deploy&lt;/code&gt;, containers spin up on demand near the user, go to sleep after a configurable timeout, and support autoscaling based on CPU usage.&lt;/p&gt;
&lt;p&gt;What sets them apart is the architecture: each container is backed by a Durable Object acting as a programmable &amp;ldquo;sidecar,&amp;rdquo; letting you start, stop, run commands, and monitor container state directly from code. That allows Workers to act as an API gateway, service mesh, or orchestrator for containers without writing Kubernetes operators or configuring a complex control plane. On pricing, users pay only for the time a container actually runs, billed per vCPU, memory, and disk at rates Cloudflare says are competitive with Google Cloud Run. The takeaway: handle the bulk of requests with lightweight, inexpensive Workers, and reach for containers only for heavy workloads that truly need them.&lt;/p&gt;
&lt;hr&gt;
&lt;h2 id="the-types-of-companies-you-can-work-for-and-what-they-do-for-your-career"&gt;&lt;a href="https://www.elenaverna.com/p/the-types-of-companies-you-can-work" rel="noopener noreferrer"&gt;The types of companies you can work for and what they do for your career&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Elena Verna advises choosing where you work intentionally rather than chasing titles or compensation. She breaks companies into six archetypes. &amp;ldquo;Unicorns&amp;rdquo; grow around 100% year over year, like early Miro or Figma: the pace is breakneck and burnout is a real risk, but experience there opens many doors. &amp;ldquo;Tankers&amp;rdquo; like Google, Apple, and Microsoft run with mature processes, high pay, and abundant training resources—great for starting a career, though roles are highly specialized and progress is slow. &amp;ldquo;Declining Giants&amp;rdquo; are in constant reorganization; pressure for results is intense, but advancement can be fast. &amp;ldquo;Survival Mode&amp;rdquo; startups haven&amp;rsquo;t found product-market fit yet: autonomy is high and skills broaden quickly, but the risk is steep and the author advises newcomers to avoid them.&lt;/p&gt;
&lt;p&gt;The remaining two are &amp;ldquo;Lifestyle Boats,&amp;rdquo; often bootstrapped, profitable, and sustainably growing like Basecamp, which are great for beginners thanks to a supportive environment; and &amp;ldquo;Social Good Seekers,&amp;rdquo; where social impact comes before revenue—pay may be lower, but fulfillment is high. To identify which type a company is, ask about headcount, revenue growth over the past three years, and how much runway remains before the next fundraise. At the same time, ask yourself how much change and pressure you can tolerate, whether you need a clearly defined role, and what your current financial priorities are.&lt;/p&gt;
&lt;hr&gt;
&lt;h2 id="how-to-create-a-chain-reaction-of-good-habits"&gt;&lt;a href="https://jamesclear.com/domino-effect" rel="noopener noreferrer"&gt;How to Create a Chain Reaction of Good Habits&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;James Clear, author of &amp;ldquo;Atomic Habits,&amp;rdquo; explains the Domino Effect: when you change one behavior, it sets off a chain reaction that shifts related behaviors too. He shares the story of Jennifer Dukes Lee, who didn&amp;rsquo;t make her bed for over twenty years; after doing it four days in a row, she found herself folding laundry, washing the dishes, and organizing the kitchen cabinets. A 2012 Northwestern University study similarly found that when people cut down their sedentary time, they naturally ate less fat even though nobody asked them to. The effect works for bad habits as well—checking your phone leads to scrolling social media, which turns into twenty more minutes of procrastination.&lt;/p&gt;
&lt;p&gt;Clear argues this happens because daily habits are tightly interconnected and because of the principle of commitment and consistency: once we make even a tiny commitment, we tend to follow through because it aligns with our self-image. To deliberately trigger a positive domino chain, start with the small habit you feel most motivated to do and practice it consistently, ride the momentum of finishing one task straight into the next, and when things get hard, break them into smaller pieces and focus on consistency rather than outcomes. Remarkably, the effect doesn&amp;rsquo;t just create new behaviors—it shifts beliefs: each falling domino helps you believe in a new version of yourself and build identity-based habits.&lt;/p&gt;
&lt;hr&gt;
&lt;h2 id="the-post-developer-era"&gt;&lt;a href="https://www.joshwcomeau.com/blog/the-post-developer-era/" rel="noopener noreferrer"&gt;The Post-Developer Era&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Two years after writing &amp;ldquo;The End of Front-End Development&amp;rdquo; when GPT-4 launched, Josh W. Comeau revisits whether we have entered a &amp;ldquo;post-developer era.&amp;rdquo; His answer is no. The headline figure that &amp;ldquo;AI writes over 25% of code at Google&amp;rdquo; is easy to misread, because AI isn&amp;rsquo;t working autonomously—skilled developers are always at the wheel, steering and editing. Meanwhile Devin, pitched as an autonomous replacement for software engineers, completed only 3 out of 20 tasks in an independent team&amp;rsquo;s real-world evaluation. Comeau uses Cursor with Claude Sonnet and finds it impressive, but compares it to cruise control: take your hands off the wheel and the car slowly drifts out of its lane. Non-programmers won&amp;rsquo;t spot subtle bugs and eventually end up stuck with an unmaintainable mess.&lt;/p&gt;
&lt;p&gt;The job market remains tough, but Comeau attributes that primarily to high interest rates, waves of layoffs at large tech companies, and the mistaken belief among executives that AI is about to make developers redundant—not to AI actually replacing people. He also worries that newcomers will fall into &amp;ldquo;vibe coding,&amp;rdquo; endlessly clicking accept without understanding the code. Conversely, if you use AI actively as a personal tutor, there has never been a better time to learn programming, and a &amp;ldquo;developer renaissance&amp;rdquo; may follow once companies realize AI is a force multiplier rather than a replacement.&lt;/p&gt;
&lt;hr&gt;
&lt;h2 id="everything-wrong-with-model-context-protocol-mcp"&gt;&lt;a href="https://blog.sshh.io/p/everything-wrong-with-mcp" rel="noopener noreferrer"&gt;Everything Wrong With Model Context Protocol (MCP)&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Shrivu Shankar examines the flaws and limitations of the Model Context Protocol, the standard for connecting third-party tools and data to AI assistants like Claude, ChatGPT, and Cursor. On protocol security, the initial version didn&amp;rsquo;t define an authentication mechanism and the subsequent specification drew criticism for its complexity; running MCP servers locally over stdio creates a shortcut for less experienced users to download and execute malware; and many servers trust inputs and execute them directly. On user experience, MCP doesn&amp;rsquo;t distinguish risk levels between a tool that reads logs and one that deletes files, offers no token-cost controls, and at the time of writing only returned unstructured text—something later specs addressed.&lt;/p&gt;
&lt;p&gt;More serious is the security of the language models themselves. Tool descriptions are typically injected into the system prompt, giving them outsized influence over the agent; a server can silently rename or rewrite tool descriptions after the user has approved them, and data pulled from fourth-party sources—such as a database row—can carry prompt injections. Easy data aggregation also lets employees infer sensitive information from data they are individually permitted to view. Finally, model reliability drops when too many tools are exposed, and simple primitives like listing or reading files fall short of the queries users expect. Shankar concludes that safe adoption requires a secure-by-default protocol, applications that protect users, and users who understand the trade-offs of their choices.&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 #27</title><link>https://miti99.com/en/post/2025/05/14/</link><pubDate>Wed, 14 May 2025 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2025/05/14/</guid><description>&lt;p&gt;&lt;em&gt;Enjoy Newsletter #27.&lt;/em&gt;&lt;/p&gt;
&lt;h2 id="heading"&gt;&lt;a href="https://blog.cloudflare.com/introducing-the-cloudflare-vite-plugin/" rel="noopener noreferrer"&gt;&amp;ldquo;Just use Vite&amp;rdquo;&amp;hellip; with the Workers runtime&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Cloudflare announced version 1.0 of the Cloudflare Vite plugin alongside official support for React Router v7. Previously, Vite&amp;rsquo;s development server always executed server-side code inside Node.js—even when the application targeted Cloudflare Workers in production—causing subtle, hard-to-catch discrepancies between local dev and production. Built on the experimental Environment API introduced in Vite 6, the new plugin runs your Worker code directly inside the native Workers runtime (&lt;code&gt;workerd&lt;/code&gt;) during local development, keeping dev behavior as close to production as possible.&lt;/p&gt;
&lt;p&gt;For single-page applications (SPAs) built with React, Vue, or Svelte, you can scaffold a new project with the &lt;code&gt;create-cloudflare&lt;/code&gt; CLI or migrate an existing app simply by adding &lt;code&gt;@cloudflare/vite-plugin&lt;/code&gt; to your Vite config and creating a &lt;code&gt;wrangler.jsonc&lt;/code&gt; file. When you edit server-side Worker code, Vite hot-reloads the Worker environment without losing client-side UI state in the browser. Running &lt;code&gt;vite build&lt;/code&gt; outputs both client and server bundles, &lt;code&gt;vite preview&lt;/code&gt; previews the production build inside the Workers runtime, and &lt;code&gt;wrangler deploy&lt;/code&gt; deploys straight to Cloudflare without an extra bundling step. With React Router v7 (the successor to Remix), a single entry file defines the Worker across both dev and build without needing a separate adapter, and the plugin supports the full Cloudflare Developer Platform including KV, D1, Durable Objects, and Workers AI.&lt;/p&gt;
&lt;h2 id="the-best-programmers-i-know"&gt;&lt;a href="https://endler.dev/2025/best-programmers/" rel="noopener noreferrer"&gt;The Best Programmers I Know&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Matthias Endler distills the common traits he has observed in the best programmers he has ever worked with—a list he wishes he had when starting out. First and foremost, they read the canonical reference documentation directly instead of guessing, copying from Stack Overflow, or asking an LLM. Second, they know their tools inside and out: why the tool was created, who maintains it, where its limits lie, and what the surrounding ecosystem looks like. Great programmers also actually read error messages carefully, break intimidating problems down into small, solvable steps, and aren&amp;rsquo;t afraid to get their hands dirty in unfamiliar codebases—which is how they become the go-to person on their team.&lt;/p&gt;
&lt;p&gt;Beyond raw technical chops, they generously help others, write clearly because clear writing reflects clear thinking, and never stop learning—some of the sharpest programmers Endler knows are in their 60s and still run circles around developers half their age. They don&amp;rsquo;t care about titles or hierarchy, build lasting reputation by shipping widely used work, stay patient with both computers and people, never blame &amp;ldquo;random&amp;rdquo; hardware glitches or compiler bugs before checking their own assumptions, aren&amp;rsquo;t afraid to say &amp;ldquo;I don&amp;rsquo;t know,&amp;rdquo; refuse to guess when requirements are ambiguous, and relentlessly favor simple code. Endler notes that this isn&amp;rsquo;t a checklist or a competition, just a reminder that there are no shortcuts around deliberate practice.&lt;/p&gt;
&lt;h2 id="rdel-87-how-do-ai-coding-tools-actually-change-developer-work"&gt;&lt;a href="https://rdel.substack.com/p/rdel-87-how-do-ai-coding-tools-actually" rel="noopener noreferrer"&gt;RDEL #87: How do AI coding tools actually change developer work?&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;In this installment of &lt;em&gt;Research-Driven Engineering Leadership&lt;/em&gt;, Lizzie Matusov summarizes a three-week randomized controlled trial conducted by Microsoft and the Institute for Work Life across 228 engineers at a global software company. Participants were split into three groups—engineers newly granted access to GitHub Copilot, a control group using no AI tools, and a comparison group of existing Copilot users—combining daily diary studies with system telemetry. Before the trial began, 86% of experienced Copilot users believed AI coding tools were useful compared to just 44% of non-users, and the single most common reason engineers hadn&amp;rsquo;t tried AI tools yet was simply being too busy.&lt;/p&gt;
&lt;p&gt;After three weeks, enjoyment and perceived usefulness rose significantly among the new users; 84% reported that Copilot positively changed how they worked, cutting down on tedious boilerplate and making coding more enjoyable. Engineers used Copilot not just for code completion, but also as a replacement for web search and as a sounding board for ideation and design. Interestingly, system telemetry showed no statistically significant difference in lines of code, pull request volume, or active coding time, and engineers&amp;rsquo; baseline level of trust in AI-generated code remained unchanged. Matusov advises engineering leaders to measure productivity holistically across satisfaction and flow using the SPACE framework, carve out dedicated time for teams to experiment, and view AI as a way to offload repetitive drudgery so engineers can focus on design and learning.&lt;/p&gt;
&lt;h2 id="overclocking-dbt-discord"&gt;&lt;a href="https://discord.com/blog/overclocking-dbt-discords-custom-solution-in-processing-petabytes-of-data" rel="noopener noreferrer"&gt;Overclocking dbt: Discord&amp;rsquo;s Custom Solution in Processing Petabytes of Data&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Discord data engineer Chris Dong shares how his team scaled &lt;code&gt;dbt&lt;/code&gt; (data build tool) to process petabytes of data across more than 100 developers collaborating on 2,500+ models. Their out-of-the-box setup quickly hit a wall: full project compilation took over 20 minutes, default incremental materialization strategies struggled at petabyte scale, and developers constantly clobbered each other&amp;rsquo;s test tables in shared environments. To isolate environments cleanly, they overrode the &lt;code&gt;generate_alias_name&lt;/code&gt; macro to automatically prefix table names with the developer&amp;rsquo;s username in local dev, the PR number or commit SHA in CI/CD, and the canonical name in production.&lt;/p&gt;
&lt;p&gt;On the performance side, they replaced standard &lt;code&gt;MAX(timestamp)&lt;/code&gt; incremental filtering with explicit &lt;code&gt;start_date&lt;/code&gt; and &lt;code&gt;end_date&lt;/code&gt; variables—noting that the expensive full-table scans came from the &lt;code&gt;MAX(timestamp)&lt;/code&gt; subquery in the old pattern rather than the &lt;code&gt;is_incremental()&lt;/code&gt; macro itself. They also patched partial-parsing hash mismatches and leveraged zero-copy BigQuery partition copies; together, these optimizations sped up runs by 5x. Historical backfills were automated via semantic versioning inside each model&amp;rsquo;s &lt;code&gt;meta&lt;/code&gt; config: bumping the major version triggers a full refresh of the table and all downstream dependents, while bumping the minor version runs a targeted date-chunked backfill. A shared macro library and Buildkite CI/CD pipeline validate query dry-run costs, dependencies, and blast radius before any change lands in production.&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.&lt;/em&gt;&lt;/p&gt;</description></item><item><title>Newsletter #2</title><link>https://miti99.com/en/post/2025/02/16/</link><pubDate>Sun, 16 Feb 2025 00:00:00 +0700</pubDate><guid>https://miti99.com/en/post/2025/02/16/</guid><description>&lt;i&gt;
Hello everyone, right on schedule, here is my Newsletter #2. I went on a weekend trip to Xuyên Mộc and just got back today, which is why this issue is going up a bit late.
&lt;p&gt;Without further ado, let&amp;rsquo;s jump straight into MiTi&amp;rsquo;s Newsletter #2.
&lt;/i&gt;&lt;/p&gt;
&lt;h2 id="some-things-to-expect-in-2025"&gt;&lt;a href="https://lwn.net/Articles/1003780/" rel="noopener noreferrer"&gt;Some things to expect in 2025&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;In keeping with his New Year tradition, LWN.net&amp;rsquo;s Jonathan Corbet shares a set of predictions for the Linux and free software communities in 2025. Sched-ext—the mechanism for loading CPU schedulers from user space as BPF programs—will ship in more distributions, sparking a wave of new scheduling ideas tested rapidly on real production systems. More Rust code will land in the Linux kernel, this time in components that everyday users will actually run without realizing it. The author also expects another XZ-style backdoor attempt to come to light, and predicts that single-maintainer projects will increasingly be viewed as a risk, both for security and maintainer burnout.&lt;/p&gt;
&lt;p&gt;A major project may discover it has merged a substantial amount of AI-generated code that the contributor didn&amp;rsquo;t actually understand, forcing a revert; alongside that, efforts to build truly free generative AI systems will continue. Free software foundations will keep facing funding struggles, though a dedicated fund to support maintainers may emerge. More cloud-dependent consumer devices will turn into &amp;ldquo;bricks&amp;rdquo; when their manufacturers go under, creating opportunities for open solutions like Home Assistant; open hardware like the OpenWrt One will gain traction, and alternative mobile Linux distributions will see renewed interest. Finally, the author worries that global geopolitical tensions will spill over into the community and urges everyone to hold fast to the spirit of building systems for all and welcoming contributions from anyone.&lt;/p&gt;
&lt;h2 id="why-you-should-use-compact-table-columns"&gt;&lt;a href="https://vladmihalcea.com/compact-table-columns/" rel="noopener noreferrer"&gt;Why you should use compact table columns&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Vlad Mihalcea explains why choosing compact column types matters when designing database schemas. Relational database management systems cache disk pages in a Buffer Pool (such as PostgreSQL&amp;rsquo;s shared buffers); because RAM is orders of magnitude faster than SSDs, narrower columns pack more rows and index entries into each page, allowing more queries to be served directly from memory. StackOverflow is a prime example: they serve roughly 11,000 queries per second from a single active SQL Server node thanks to 1.5 TB of RAM fronting a 2.8 TB database and a Frugal Schema—avoiding 16-byte UUIDs for primary and foreign keys, using 4-byte &lt;code&gt;int&lt;/code&gt; or 1-byte &lt;code&gt;tinyint&lt;/code&gt; instead of &lt;code&gt;bigint&lt;/code&gt; for most primary keys, keeping enums to 1 byte, and bounding &lt;code&gt;VARCHAR&lt;/code&gt; column lengths.&lt;/p&gt;
&lt;p&gt;The author backs this up with concrete measurements. On MySQL, in a five-million-row &lt;code&gt;customer&lt;/code&gt; table, using &lt;code&gt;tinyint&lt;/code&gt; instead of &lt;code&gt;smallint&lt;/code&gt; for a single indexed foreign key saves about 71.59 MB; across ten such columns on a 100-million-row table, that adds up to roughly 14.3 GB. PostgreSQL lacks a 1-byte integer type and enforces column data alignment, so columns should be ordered using &amp;ldquo;Column Tetris&amp;rdquo; to avoid wasted padding bytes; even so, using &lt;code&gt;smallint&lt;/code&gt; instead of &lt;code&gt;int&lt;/code&gt; shrinks the &lt;code&gt;customer&lt;/code&gt; table by 38 MB. The takeaway: right-sizing column types is a proven performance optimization strategy that has served StackOverflow well for over 15 years.&lt;/p&gt;
&lt;h2 id="rate-limiting-with-redis-an-essential-guide"&gt;&lt;a href="https://foojay.io/today/rate-limiting-with-redis-an-essential-guide/" rel="noopener noreferrer"&gt;Rate limiting with Redis: An essential guide&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Raphael De Lio opens with familiar encounters with rate limiting, such as &amp;ldquo;429 Too Many Requests&amp;rdquo; errors or tiered API quotas. Rate limiting prevents abuse, ensures fair access, smooths traffic spikes, controls costs, and protects service availability: Figma famously stopped a mass-invite spam attack using a Redis-backed rate limiter, while Stripe relies on rate limiting to keep misconfigured scripts or bad actors from monopolizing resources. Redis is a popular choice thanks to its speed, reliability, atomic operations, persistence options, and Lua scripting; GitHub also migrated to a Redis-based rate-limiting setup with client-side sharding.&lt;/p&gt;
&lt;p&gt;The article compares five common algorithms. Leaky Bucket processes requests at a steady rate, ideal for smooth traffic flows but unforgiving of bursts; Token Bucket allows short bursts as long as tokens remain; Fixed Window Counter is simple to implement but vulnerable to boundary spikes across adjacent time windows; Sliding Window Log is the most accurate but consumes significant memory and CPU at scale; and Sliding Window Counter balances accuracy with resource efficiency. Choosing the right algorithm depends on traffic patterns, required precision, resource constraints, and user experience. As the author notes, rate limiting isn&amp;rsquo;t just about setting caps—it&amp;rsquo;s about designing efficient, fair, and user-friendly systems; follow-up posts implementing each algorithm in Java and Redis will roll out weekly.&lt;/p&gt;
&lt;h2 id="why-does-cloudflare-pages-have-such-a-generous-free-tier"&gt;&lt;a href="https://mattsayar.com/why-does-cloudflare-pages-have-such-a-generous-free-tier/" rel="noopener noreferrer"&gt;Why does Cloudflare Pages have such a generous Free tier?&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;Matt Sayar, who hosts his personal site on Cloudflare Pages, wonders why there are so many high-quality free hosting tiers available today. The biggest concern with free hosting is bandwidth, since a surprise viral post can stick you with a massive bill or knock your site offline. Comparing providers, GitHub Pages has a soft limit of 100 GB per month, Netlify and AWS S3 offer around 100 GB, GitLab Pages throttles by requests per minute, whereas Cloudflare Pages offers completely unlimited bandwidth.&lt;/p&gt;
&lt;p&gt;The author outlines three practical reasons behind this generosity. First, static sites are tiny—his own site is only about 2.2 MB—so with Cloudflare&amp;rsquo;s massive edge network, aggressive caching, and optimization techniques, the marginal cost of serving them is negligible. Second, Cloudflare benefits from a fast, secure internet: the more people and businesses come online, the more enterprises need commercial security products—which is exactly what Cloudflare sells, in the same spirit as its free 1.1.1.1 DNS resolver and unmetered DDoS protection. Third is the classic freemium flywheel: developers try the free tier, have a great experience, and later champion Cloudflare&amp;rsquo;s paid plans at work. Although the author initially couldn&amp;rsquo;t find an official statement explaining the bandwidth policy, the Hacker News community pointed him to a Cloudflare post affirming their commitment to the free tier; even so, he keeps a mirror on GitHub just in case policies change.&lt;/p&gt;
&lt;h2 id="how-i-program-with-llms"&gt;&lt;a href="https://crawshaw.io/blog/programming-with-llms" rel="noopener noreferrer"&gt;How I program with LLMs&lt;/a&gt;&lt;/h2&gt;&lt;p&gt;David Crawshaw reflects on a year of actively programming with large language models (LLMs) and concludes that they deliver a clear productivity boost. He uses LLMs in three ways: code autocomplete, search engine replacement, and chat-driven programming—the hardest mode to master, but also the most valuable. Chat is especially helpful when you know what needs to be written but lack the energy to set up a new file and look up library APIs: the LLM produces a first draft with good structure, the right imports, and a few bugs, and fixing bugs is much easier than staring at a blank page. His advice is to frame prompts like exam questions: specific goals, self-contained context, and verifiable outputs—and always compile and run tests before reading the generated code closely.&lt;/p&gt;
&lt;p&gt;As a concrete example, he walks through writing a reservoir sampler in Go to estimate quartiles. The LLM generated a well-structured package with clean interfaces, though the initial code failed to compile due to an unused variable and included fabricated expected values in the unit test. When prompted, it wrote a naive reference implementation for comparison and a fuzz test that initially passed the wrong argument types, which it fixed as soon as the compiler error was pasted back; in the author&amp;rsquo;s experience, over 80% of tool-reported errors can be resolved by the LLM on its own. He argues that LLMs shift traditional software engineering trade-offs: favoring smaller packages, more thorough tests, and a looser adherence to DRY—such as generating a 200-line custom wrapper for the exact subset of an API you need rather than pulling in a bloated official SDK. He is currently automating these workflows at sketch.dev.&lt;/p&gt;
&lt;h2 id="bonus"&gt;Bonus&lt;/h2&gt;&lt;p&gt;This week comes with quite a few bonuses from various sources.&lt;/p&gt;
&lt;h3 id="bonus-1-a-couple-of-ebooks-i-found"&gt;Bonus #1: A couple of ebooks I found&lt;/h3&gt;&lt;ul&gt;
&lt;li&gt;&lt;a href="https://info.microsoft.com/rs/157-GQE-382/images/EN-CNTNT-eBook-DesigningDistributedSystems.pdf" rel="noopener noreferrer"&gt;Designing Distributed Systems&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href="https://drive.google.com/file/d/1U7EchvgzCjTtF5JzGVVCFgjXC-qw7lIG/view" rel="noopener noreferrer"&gt;Quastor Summaries&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;
&lt;h3 id="bonus-2-interesting-images-from-bytebytego"&gt;Bonus #2: Interesting images from &lt;a href="https://bytebytego.com/" rel="noopener noreferrer"&gt;ByteByteGo&lt;/a&gt;&lt;/h3&gt;&lt;p&gt;&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/11b53f30-8dba-4520-9b1a-425b54b9b84a_1280x1585.gif" alt="Cookies Vs Sessions Vs JWT Vs PASETO"&gt;
&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/fdbcc119-8f5d-4d27-9a4b-2c8bde82b537_4026x8030.jpeg" alt="Algorithms you should know before taking System Design Interviews"&gt;
&lt;img src="https://substack-post-media.s3.amazonaws.com/public/images/12dffcce-f231-48cc-915f-d53c0f8bce0c_3735x3573.jpeg" alt="Top 6 Load Balancing Algorithms"&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.&lt;/em&gt;&lt;/p&gt;</description></item></channel></rss>